def put(self, request): """ 修改购物车 :return: """ serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) sku_id = serializer.validated_data.get("sku_id") count = serializer.validated_data.get("count") selected = serializer.validated_data.get("selected") # 尝试对请求的用户进行验证 try: user = request.user except Exception: # 验证失败,用户未登录 user = None if user is not None and user.is_authenticated: # 用户已登录用redis保存 redis_con = get_redis_connection("cart") pl = redis_con.pipeline() # 记录购物车商品数量 pl.hset("cart_%s" % user.id, sku_id, count) # 勾选 if selected: pl.sadd("cart_selected_%s" % user.id, sku_id) else: pl.srem("cart_selected_%s" % user.id, sku_id) pl.execute() return Response(serializer.data) else: # 用户未登录 cart = request.COOKIES.get("cart") if cart is not None: # 使用pickle序列化购物车数据, pickle操作的是bytes类型的数据 cart = pickle.loads(base64.b64decode(cart.encode())) else: cart = {} sku = cart.get(sku_id) if sku: count += int(sku.get('count')) cart[sku_id] = {"count": count, "selected": selected} cookie_cart = base64.b64encode(pickle.dumps(cart)).decode() response = Response(serializer.data, status=status.HTTP_201_CREATED) # 设置购物车的cookie # 需要设置有效期,否则是临时cookie response.set_cookie("cart", cookie_cart, max_age=constants.CART_COOKIE_EXPIRES) return response
def post(self, request): serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) sku_id = serializer.data.get('sku_id') count = serializer.data.get('count') selected = serializer.data.get('selected') try: user = request.user except Exception: user = None # 判断用户是否登陆 # 如果登陆并通过验证 将数据保存在redis中 if user is not None and user.is_authenticated: redis_conn = get_redis_connection('cart') # redis_conn.hset('cart_%s'%user.id,sku_id,count) # 累加 # redis_conn.hincrby('cart_%s'%user.id,sku_id,count) # # if selected: # redis_conn.sadd('cart_selected_%s'%user.id,sku_id) # return Response(serializer.data) # redis管道 pl = redis_conn.pipeline() pl.hincrby('cart_%s' % user.id, sku_id, count) if selected: pl.sadd('cart_selected_%s' % user.id, sku_id) pl.execute() return Response(serializer.data) # 未登录保存在cookies中 else: cookie_str = request.COOKIES.get('cart') # 如果有cookie 解密 if cookie_str is not None: bytes_data = base64.b64decode(cookie_str) cookie_cart = pickle.loads(bytes_data) # 如果没有 cookie else: cookie_cart = {} # cookie_cart = {1:{'count':2,'selected':True}} # 如果有则把前段传过来的个数累加 if sku_id in cookie_cart: original_count = cookie_cart[sku_id]['count'] count += original_count # 更新数据 cookie_cart[sku_id] = {'count': count, 'selected': selected} # 加密 bytes_dumps = pickle.dumps(cookie_cart) bytes_str = base64.b64encode(bytes_dumps) cookie_save_str = bytes_str.decode() # 设置cookie response = Response(serializer.data) response.set_cookie('cart', cookie_save_str, 3600) return response
def put(self,request): """修改购物车中的商品""" # 创建序列化器,校验请求参数是否合法 s = CartSerializer(data=request.data) s.is_valid(raise_exception=True) # 获取校验后的3个参数: sku_id, count, selected sku_id = s.validated_data.get('sku_id') count = s.validated_data.get('count') selected = s.validated_data.get('selected') # 获取用户对象: AnnomousUser user = request.user # 判断是否已经登录 if user.is_authenticated(): # 已登录 # cart_1 = {1: 2, 2: 2} # cart_selected_1 = {1, 2} # set # 用户已登录,获取操作Redis的StrictRedis对象 strict_redis = get_redis_connection('carts') # type: StrictRedis pipeline = strict_redis.pipeline() # 修改商品数量 pipeline.hset('cart_%s' % user.id, sku_id, count) # 修改商品的勾选状态 if selected: # 往set中添加成员 pipeline.sadd('cart_selected_%s' % user.id, sku_id) else: # 从set中删除成员 pipeline.srem('cart_selected_%s' % user.id, sku_id) pipeline.execute() # 响应序列化数据 return Response(s.data) else: # 未登录 # 1. 从cookie中获取购物车信息 cart = request.COOKIES.get('cart') # 2. base64字符串 -> 字典 # {1: {'count':2, 'selected':False}, 2: {'count':2, 'selected':False}} if cart is None: cart = {} else: cart = pickle.loads(base64.b64decode(cart.encode())) # 3. 修改字典中对应的商品数量和选中状态 cart[sku_id] = { 'count': count, 'selected': selected, } # 4. 字典 --> base64字符串 cart_cookie = base64.b64encode(pickle.dumps(cart)).decode() # 5. 通过cookie保存购物车数据(base64字符串): response.set_cookie() response = Response(s.data) response.set_cookie('cart', cart_cookie, 60 * 60 * 24 * 365) # 有效期: 1年 # 6. 响应序列化数据 return response
def post(self, request): """ 购物车记录添加 """ # 1. 获取参数(sku_id, count, selected)并进行参数校验 serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) sku_id = serializer.validated_data['sku_id'] count = serializer.validated_data['count'] selected = serializer.validated_data['selected'] # 获取登录用户 try: user = request.user except Exception as e: user = None if user and user.is_authenticated: # 2. 保存用户的购物车记录 redis_conn = get_redis_connection('cart') pipeline = redis_conn.pipeline() cart_key = 'cart_%s' % user.id # 保存购物车中商品及数量 pipeline.hincrby(cart_key, sku_id, count) # 保存购物车中商品的选中状态 cart_selected_key = 'cart_selected_%s' % user.id if selected: pipeline.sadd(cart_selected_key, sku_id) pipeline.execute() # 3. 返回应答,保存购物车记录成功 return Response(serializer.data, status=status.HTTP_201_CREATED) else: # 获取客户端发送的cookie信息 cookie_cart = request.COOKIES.get('cart') if cookie_cart: # 对cookie数据进行解析 cart_dict = pickle.loads(base64.b64decode(cookie_cart)) else: cart_dict = {} if sku_id in cart_dict: count += cart_dict[sku_id]['count'] cart_dict[sku_id] = {'count': count, 'selected': selected} # 对cart_dict数据进行处理 cart_data = base64.b64encode(pickle.dumps(cart_dict)).decode() response = Response(serializer.data, status=status.HTTP_201_CREATED) response.set_cookie('cart', cart_data, max_age=constants.CART_COOKIE_EXPIRES) return response
def put(self, request): serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) sku_id = serializer.data.get('sku_id') count = serializer.data.get('count') selected = serializer.data.get('selected') try: user = request.user except Exception: user = None if user is not None and user.is_authenticated: redis_conn = get_redis_connection('cart') redis_conn.hset('cart_%s' % user.id, sku_id, count) if selected: redis_conn.sadd('cart_selected_%s' % user.id, sku_id) else: redis_conn.srem('cart_selected_%s' % user.id, sku_id) return Response(serializer.data) else: cookie_str = request.COOKIES.get('cart') if cookie_str is not None: cart = pickle.loads(base64.b64decode(cookie_str)) else: cart = {} if sku_id in cart: cart[sku_id] = {'count': count, 'selected': selected} new_cookie = base64.b64encode(pickle.dumps(cart)).decode() response = Response(serializer.data) response.set_cookie('cart', new_cookie) return response
def post(self, request): """ 添加购物车 """ serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) sku_id = serializer.validated_data.get('sku_id') count = serializer.validated_data.get('count') selected = serializer.validated_data.get('selected') # 尝试对请求的用户进行验证 try: user = request.user except Exception: # 验证失败,用户未登录 user = None if user is not None and user.is_authenticated: # 用户已登录,在redis中保存 redis_conn = get_redis_connection('cart') pl = redis_conn.pipeline() # 记录购物车商品数量 pl.hincrby('cart_%s' % user.id, sku_id, count) # 记录购物车的勾选项 if selected: pl.sadd('cart_select_%s' % user.id, sku_id) pl.execute() return Response(serializer.data, status=status.HTTP_201_CREATED) else: # 用户未登录,在cookie中保存 # { # 1001: { "count": 10, "selected": true}, # ... # } # 使用pickle序列化购物车数据,pickle操作的是bytes类型 cart = request.COOKIES.get('cart') if cart is not None: cart = myjson.loads(cart) else: cart = {} sku = cart.get(sku_id) if sku: cart_count = int(sku.get('count')) else: cart_count = 0 cart[sku_id] = {'count': count + cart_count, 'selected': selected} cookie_cart = myjson.dumps(cart) response = Response(serializer.data, status=status.HTTP_201_CREATED) # 设置购物车的cookie # 需要设置有效期, 否则是临时cookie response.set_cookie('cart', cookie_cart, max_age=constants.CART_COOKIE_EXPIRES) return response
def put(self, request): """修改购物车数据""" # sku_id, count, selected # 校验 serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) sku_id = serializer.validated_data['sku_id'] count = serializer.validated_data['count'] selected = serializer.validated_data['selected'] # 判断用户是否登录 try: user = request.user except Exception: user = None if user and user.is_authenticated: # 已登录,查询 修改 redis redis_conn = get_redis_connection('cart') pl = redis_conn.pipeline() # 处理count pl.hset('cart_%s' % user.id, sku_id, count) # 处理 selected 状态 if selected: # 表示勾选 pl.sadd('cart_selected_%s' % user.id, sku_id) else: # 取消勾选 pl.srem('cart_selected_%s' % user.id, sku_id) pl.execute() # 序列化返回 return Response(serializer.data) else: # 未登录,查询 修改 cookie cart_cookie = request.COOKIES.get('cart') if cart_cookie: # 表示cookie中有购物车数据 # 解析 cart_dict = pickle.loads(base64.b64decode(cart_cookie.encode())) else: # 表示 cookie 中没有购物车数据 cart_dict = {} response = Response(serializer.data) # 修改 cookie 中的cart数据 if sku_id in cart_dict: # 存在购物车数据, 进行修改 cart_dict['sku_id'] = { 'count': count, 'selected': selected } cart_cookie = base64.b64encode(pickle.dumps(cart_dict)).decode() # 序列化返回 # 设置cookie response.set_cookie('cart', cart_cookie, max_age=constants.CART_COOKIE_EXPIRES) return response
def post(self, request): """添加商品到购物车""" # 调用序列化器校验数据 serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) sku_id = serializer.validated_data.get('sku_id') count = serializer.validated_data.get('count') selected = serializer.validated_data.get('selected') # 判断用户登陆状态 try: user = request.user except Exception: user = None # 如果已登陆,将数据保存至redis if user and user.is_authenticated: # 连接数据库 redis = get_redis_connection('cart') pl = redis.pipeline() # 保存商品sku_id及数量 pl.hincrby("cart_%s" % user.id, sku_id, count) # 保存商品勾选状态 pl.sadd("cart_selected_%s" % user.id, sku_id) pl.execute() return Response(serializer.data, status=status.HTTP_201_CREATED) # 如果未登录,则将商品信息保存在cookie else: # 获取cookie中购物车数据 cart = request.COOKIES.get('cart') if cart: cart = pickle.loads(base64.b64decode(cart.encode())) else: cart = {} # 添加购物信息 sku_dict = cart.get(sku_id) if sku_dict: count += int(sku_dict["count"]) cart[sku_id] = { "count": count, "selected": selected, } cookie_cart = base64.b64encode(pickle.dumps(cart)).decode() response = Response(serializer.data, status=status.HTTP_201_CREATED) response.set_cookie("cart", cookie_cart, max_age=constants.CART_COOKIE_EXPIRE) return response
def put(self, request): #1.接收数据,进行数据的校验 serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) #2.获取sku_id,count,selected 的值 sku_id = serializer.data.get('sku_id') count = serializer.data.get('count') selected = serializer.data.get('selected') #3.获取用户信息,进行判断 try: user = request.user except Exception: user = None if user is not None and user.is_authenticated: #4.登录用户redis #4.1连接redis redis_conn = get_redis_connection('cart') #4.2更新数据 redis_conn.hset('cart_%s' % user.id, sku_id, count) #set #选中状态 if selected: redis_conn.sadd('cart_selected_%s' % user.id, sku_id) else: #未选中 redis_conn.srem('cart_%s' % user.id, sku_id) #4.3返回数据(要将最终的商品数据返回回去) return Response(serializer.data) else: #5.未登录用户 cookie #5.1读取cookie,并判断数据是否存在 cookie_str = request.COOKIES.get('cart') if cookie_str is not None: #读取数据 cart = pickle.loads(base64.b64decode(cookie_str)) else: cart = {} #5.2更新数据 if sku_id in cart: cart[sku_id] = {'count': count, 'selected': selected} #5.3对字典进行处理 new_cookie = base64.b64encode(pickle.dumps(cart)).decode() #5.4返回响应 response = Response(serializer.data) response.set_cookie('cart', new_cookie) return response
def put(self, request): """修改购物车""" # 调用序列化器校验数据 serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) sku_id = serializer.validated_data.get('sku_id') count = serializer.validated_data.get('count') selected = serializer.validated_data.get('selected') # 判断用户登陆状态 try: user = request.user except Exception: user = None # 如果已登陆,从redis取回购物车信息 if user and user.is_authenticated: # 连接数据库 redis = get_redis_connection('cart') pl = redis.pipeline() pl.hset('cart_%s' % user.id, sku_id, count) if selected: pl.sadd('cart_selected_%s' % user.id, sku_id) else: pl.srem('cart_selected_%s' % user.id, sku_id) pl.execute() return Response(serializer.data, status=status.HTTP_200_OK) else: # 获取cookie中购物车数据 cart = request.COOKIES.get('cart') if cart: cart = pickle.loads(base64.b64decode(cart.encode())) else: cart = {} # 添加购物信息 cart[sku_id] = { "count": count, "selected": selected, } cookie_cart = base64.b64encode(pickle.dumps(cart)).decode() response = Response(serializer.data, status=status.HTTP_201_CREATED) response.set_cookie("cart", cookie_cart, max_age=constants.CART_COOKIE_EXPIRE) return response
def put(self, request): data = request.data serializer = CartSerializer(data=data) serializer.is_valid(raise_exception=True) sku_id = serializer.data['sku_id'] count = serializer.data.get('count') selected = serializer.data.get('selected') try: user = request.user except Exception as e: user = None # request.user.is_authenticated if user is not None and user.is_authenticated: #登录用户从redis获取数据 redis_conn = get_redis_connection('cart') #管道 提升程序运行效率 # pl = redis_conn.pipeline() # #更新数据 # pl.hset('cart_%s'%user.id,sku_id,count) # if selected: # pl.srem('cart_selected_%s'%user.id,sku_id) # else: # pl.srem('cart_selected_%s'%user.id,sku_id) # pl.execute() #更新数据 hash redis_conn.hset('cart_%s' % user.id, sku_id, count) #set if selected: redis_conn.sadd('cart_selected_%s' % user.id, sku_id) else: redis_conn.srem('cart_selected_%s' % user.id, sku_id) return Response(serializer.data) else: #未登录用户cookie中获取数据 cart_str = request.COOKIES.get('cart') if cart_str is not None: cart = pickle.loads(base64.b64decode(cart_str)) else: cart = {} if sku_id in cart: cart[sku_id] = {'count': count, 'selected': selected} cookie_str = base64.b64encode(pickle.dumps(cart)).decode() response = Response(serializer.data) response.set_cookie('cart', cookie_str) return response
def post(self, request): """添加购物车""" serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) sku_id = serializer.validated_data.get('sku_id') count = serializer.validated_data.get('count') selected = serializer.validated_data.get('selected') """尝试对请求的用户进行验证""" try: user = request.user except Exception: # 验证失败,用户未登录 user = None if user is not None and user.is_authenticated: # 用户已登录, 在redis中保存 redis_conn = get_redis_connection('cart') pl = redis_conn.pipeline() pl.hincrby('cart_%s' % user.id, sku_id, count) if selected: pl.sadd('cart_selected_%s' % user.id, sku_id) pl.execute() return Response(serializer.data, status=status.HTTP_201_CREATED) else: cart = request.COOKIES.get('cart') if cart is not None: cart = pickle.loads(base64.b64decode(cart.encode())) else: cart = {} sku = cart.get(sku_id) if sku: count += int(sku.get('count')) cart[sku_id] = {'count': count, 'selected': selected} cookie_cart = base64.b64encode(pickle.dumps(cart)).decode() response = Response(serializer.data, status=status.HTTP_201_CREATED) response.set_cookie('cart', cookie_cart, max_age=constants.CART_COOKIE_EXPIRES) return response
def put(self, request): """ 修改购物车数据 """ serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) sku_id = serializer.validated_data.get('sku_id') count = serializer.validated_data.get('count') selected = serializer.validated_data.get('selected') # 尝试对请求的用户进行验证 try: user = request.user except Exception: # 验证失败,用户未登录 user = None if user is not None and user.is_authenticated: # 用户已登录,在redis中保存 redis_conn = get_redis_connection('cart') pl = redis_conn.pipeline() pl.hset('cart_%s' % user.id, sku_id, count) if selected: pl.sadd('cart_selected_%s' % user.id, sku_id) else: pl.srem('cart_selected_%s' % user.id, sku_id) pl.execute() return Response(serializer.data) else: # 用户未登录,在cookie中保存 # 使用pickle序列化购物车数据,pickle操作的是bytes类型 cart = request.COOKIES.get('cart') if cart is not None: cart = pickle.loads(base64.b64decode(cart.encode())) else: cart = {} cart[sku_id] = { 'count': count, 'selected': selected } cookie_cart = base64.b64encode(pickle.dumps(cart)).decode() response = Response(serializer.data) # 设置购物车的cookie # 需要设置有效期,否则是临时cookie response.set_cookie('cart', cookie_cart, max_age=constants.CART_COOKIE_EXPIRES) return response
class TransactionWithCartSerializer(serializers.ModelSerializer): cart = CartSerializer() class Meta: model = Transaction fields = '__all__'
def load_cart_api(request, *args, **kwargs): user = request.user ids = CartListsToolkit.get_cart_lists_ids_from_request(request) cart_lists = CartListsSelector.get_cart_lists_by_user_and_ids(user=request.user, ids=ids) cart = cart_lists["cart"] serializer = CartSerializer(instance=cart) return Response(serializer.data, status=200)
def put(self, request, format=None, *args, **kwags): itemId = request.POST.get('itemId', 0) itemCount = request.POST.get('itemCount', 1) itemFound = CartItem.objects.filter(id=itemId) if not itemFound: return CustomJSONRenderer().render404('Cart Item', None) itemFoundFirst = itemFound.first() itemFoundFirst.count = itemCount try: itemFoundFirst.save() CartItem().update_price(itemFoundFirst.cart.id) cart = Cart.objects.filter(user=request.user) return CustomJSONRenderer().render({ 'count': cart.count(), 'result': CartSerializer(cart, many=True, context={ 'request': request }).data }) except Exception as e: return CustomJSONRenderer().render({ 'success': False, 'e': str(e) }, status=500)
def delete(self, request, format=None, *args, **kwargs): # pId = 0 # if 'product' not in request.POST: # body_unicode = request.body.decode('utf-8') # body_data = json.loads(body_unicode) # if 'product' in body_data: # pId = body_data['product'] # else: cId = request.POST.get('cart', 0) cartItem = CartItem.objects.filter(id=cId) if not cartItem.exists(): return CustomJSONRenderer().render404('cart', '') else: try: idCart = cartItem.first().cart.id cartItem.first().delete() CartItem().update_price(idCart) except Exception as e: return CustomJSONRenderer().render500(str(e), '') cart = Cart.objects.filter(user=request.user) return CustomJSONRenderer().render( { 'count': cart.count(), 'result': CartSerializer( cart, many=True, context={ 'request': request }).data }, status=200)
class OrderDetailSerializer(serializers.ModelSerializer): cart = CartSerializer() reciver = ReciverInfoSerializer() class Meta: model = Order fields = '__all__'
def get(self, request): # 1.读取redis中的购物车数据 redis_cli = get_redis_connection('cart') key_cart = 'cart_%d' % request.user.id key_selected = 'cart_selected_%d' % request.user.id # hash--->读取商品编号, 表示选中的商品 cart_dict = redis_cli.hgetall(key_cart) # {sku_id:count,....} # set----->读取商品编号,表示选中的商品 cart_selected = redis_cli.smembers(key_selected) # [sku_id, ...] # 将redis中读取的字节转换成int cart_dict2 = {} for sku_id, count in cart_dict.items(): cart_dict2[int(sku_id)] = int(count) cart_selected2 = [int(sku_id) for sku_id in cart_selected] # 查询商品对象 skus = SKU.objects.filter(pk__in=cart_selected2) # 遍历,增加数量属性 for sku in skus: sku.count = cart_dict2[sku.id] sku.selected = True # 3.序列化输出 serializer = CartSerializer(skus, many=True) return Response({'freight': 10, 'skus': serializer.data})
def create(self, request, *args, **kwargs): sku, quantity = self.get_data(request.data) variation = self.get_variation(sku) if variation is None: return no_sku_error() kwargs = {"sku": variation.sku, "unit_price": variation.price()} in_cart = request.cart.items.filter(**kwargs).first() if in_cart is not None: if quantity <= 0: in_cart.delete() else: if variation.has_stock(quantity) is False: quantity_available = variation.live_num_in_stock() return not_enough_stock_error(quantity_available) in_cart.quantity = quantity in_cart.save() elif quantity > 0: request.cart.add_item(variation, quantity) recalculate_cart(request) able_to_purchase = variation is not None and variation.has_stock( quantity) not_enough_stock = variation is not None and variation.has_stock( quantity) is False if able_to_purchase: return Response(CartSerializer(request.cart).data) elif not_enough_stock: quantity_available = variation.live_num_in_stock() return not_enough_stock_error(quantity_available)
class OrderRetrieveUpdateSerializer(serializers.ModelSerializer): cart = CartSerializer(read_only=True) class Meta: model = Order fields = ( 'id', 'cart', 'status', 'recipient', 'total_cost', 'address', 'delivery_at', 'created_at', ) read_only_fields = ( 'cart', 'recipient', 'total_cost', 'created_at', ) def validate(self, attrs): instance = getattr(self, 'instance', None) if instance.status != Order.StatusOrder.CREATED.value: raise serializers.ValidationError("Impossible to change this item") return attrs
def put(self, request): """修改购物车的数据""" # 取出数据 serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) sku_id = serializer.validated_data.get('sku_id') count = serializer.validated_data.get('count') selected = serializer.validated_data.get('selected') # 用户进行验证 try: user = request.user except Exception: user = None if user is not None and user.is_authenticated: # 用户已经登录,在redis中保存 redis_conn = get_redis_connection('cart') pl = redis_conn.pipeline() # HSET key field value, 数据库操作 pl.hset('cart_%s' % user.id, sku_id, count) if selected: # SADD key member [member ...] pl.sadd('cart_selected_%s' % user.id, sku_id) else: pl.srem('cart_selected_%s' % user.id, sku_id) pl.execute() return Response(serializer.data) else: # 用户未登录,在cookie中保存 cart = request.COOKIES.get('cart') # str if cart: cart = pickle.loads(base64.b64decode(cart.encode())) else: cart = {} cart[sku_id] = {'count': count, 'selected': selected} cookie_cart = base64.b64encode(pickle.dumps(cart)).decode() response = Response(serializer.data) # 设置购物车的cookie response.set_cookie('cart', cookie_cart, max_age=constants.CART_COOKIE_EXPIRES) return response
def post(self, request): """ 添加购物车 """ # 校验请求参数是否合法 serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) # 获取请求参数 sku_id = serializer.validated_data.get('sku_id') count = serializer.validated_data.get('count') selected = serializer.validated_data.get('selected') user = request.user if user.is_authenticated(): # 判断是否登录 # 用户已登陆,下redis红保存 redis_conn = get_redis_connection('cart') pl = redis_conn.pipepline() # 增加购物车商品数量 pl.hincrby('cart_%s' % user.id, sku_id, count) if selected: # 保存商品勾选状态 pl.sadd('cart_selected_%s' % user.id, sku_id) pl.execute() return Response(serializer.data, status=status.HTTP_201_CREATED) else: # 1.从cookie中获取购物车信息 cart = request.COOKIES.get('cart') # 2.base64字符串->字典 if cart is not None: cart = pickle.loads(base64.b64decode(cart.encode())) else: cart = {} # 3.新增字典中对应的商品数量 sku = cart.get(sku_id) if sku: # 原有数量+新增数量 count += int(sku.get('count')) cart[sku_id] = {'count': count, 'selected': selected} # 4.字典->base64字符串 cookie_cart = base64.b64encode(pickle.dumps(cart)).decode() # 5.通过cookies保存购物车数据(base64字符串) response = Response(serializer.data, status=201) # 参数3:cookie 有效期 response.set_cookie('cart', cookie_cart, constants.CART_COOKIE_EXPIRES) return response
def put(self, request): """ 修改购物车数据 """ serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) goods_id = serializer.data.get('goods_id') count = serializer.data.get('count') # 尝试对请求的用户进行验证 user = request.user redis_conn = get_redis_connection('cart') redis_conn.hset('cart_%s' % user.id, goods_id, count) datas = { # 返回购物车总条数 'total_count': get_cart_count(request, redis_conn) } return Response(datas)
def post(self, request): data = request.data serializer = CartSerializer(data=data) serializer.is_valid(raise_exception=True) sku_id = serializer.validated_data.get('sku_id') count = serializer.validated_data.get('count') selected = serializer.validated_data.get('selected') try: user = request.user except Exception: user = None if user is not None and user.is_authenticated: redis_conn = get_redis_connection('cart') redis_conn.hset('cart_%s' % user.id, sku_id, count) if selected: redis_conn.sadd('cart_selected_%s' % user.id, sku_id) return Response(serializer.data) else: cookie_str = request.COOKIES.get('cart') print(type(cookie_str)) if cookie_str is not None: cookie_cart = pickle.loads( base64.b64decode(cookie_str.encode())) else: cookie_cart = {} if sku_id in cookie_cart: original_count = cookie_cart[sku_id]['count'] count += original_count cookie_cart[sku_id] = { 'count': count, 'selected': selected, } # 字符串编码成二进制 bytes_dumps = pickle.dumps(cookie_cart) # 编码成b64 bytes_str = base64.b64encode(bytes_dumps) # 解码成字符串 cookie_save_str = bytes_str.decode() response = Response(serializer.data) response.set_cookie('cart', cookie_save_str) return response
def post(self, request): ''' 添加购物车: 1.获取前端提交数据,商品id:sku_id,商品数量:count,是否选中默认为true:selelcted 2.通过序列化器校验数据 3.视图获取校验后的数据,判断如果登陆用户保存数据到redis,未登陆保存到cookie中 3.1登陆用户判断redis中是否有该商品,没有则添加,有则数量累加 3.2未登陆用户接收前端请求中的cookie,没有则添加,有则解码转字典,累加数量,转字符串编码set_cookie :param request: :return: ''' data = request.data serializer = CartSerializer(data=data) serializer.is_valid(raise_exception=True) sku_id = serializer.data['sku_id'] count = serializer.data.get('count') selected = serializer.data.get('selected') try: user = request.user except Exception: user = None if user != None and user.is_authenticated: '''redis操作''' redis_conn = get_redis_connection('cart') redis_conn.hset('cart_%s' % user.id, sku_id, count) #hash方式写入redis if selected: redis_conn.sadd('cart_selected_%s' % user.id, sku_id) return Response(serializer.data) else: '''cookie操作''' cart_str = request.COOKIES.get('cart') if cart_str is not None: cart_dict = pickle.loads(base64.b64decode(cart_str.encode())) else: cart_dict = {} if sku_id in cart_dict: origin_count = cart_dict[sku_id]['count'] count += origin_count cart_dict[sku_id] = {'count': count, 'selected': selected} response = Response(serializer.data) cookie_cart = base64.b64encode(pickle.dumps(cart_dict)).decode() response.set_cookie('cart', cookie_cart) return response
class OrderDetailSerializer(serializers.ModelSerializer): billing_profile = BillingProfileSerializer(required=False) shipping_address = AddressSerializer(required=False) billing_address = AddressSerializer(required=False) cart = CartSerializer(required=False) timestamp = serializers.DateTimeField(format="%d %B %Y %I:%m %P") class Meta: model = Order fields = '__all__'
def get(self, request, format=None, *args, **kwargs): cart = Cart.objects.filter(user=request.user).filter(status=1) print(str(cart.query)) return CustomJSONRenderer().render({ 'count': cart.count(), 'result': CartSerializer(cart, many=True, context={ 'request': request }).data })
def post(self, request): """ 添加购物车 """ serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) goods_id = serializer.data.get('goods_id') count = serializer.data.get('count') # 尝试对请求的用户进行验证 user = request.user # 用户已登录,在redis中保存 redis_conn = get_redis_connection('cart') # type: StrictRedis # 记录购物车商品数量 redis_conn.hincrby('cart_%s' % user.id, goods_id, count) datas = { # 返回购物车总条数 'total_count': get_cart_count(request, redis_conn) } return Response(datas)
def put(self, request): serializer = CartSerializer(data=request.data) serializer.is_valid(raise_exception=True) sku_id = serializer.data.get('sku_id') count = serializer.data.get('count') selected = serializer.data.get('selected') try: user = request.user except Exception: user = None # 如果用户登陆 则更新redis数据 覆盖 if user is not None and user.is_authenticated: redis_conn = get_redis_connection('cart') redis_conn.hset('cart_%s' % user.id, sku_id, count) # 改变选中状态 if selected: redis_conn.sadd('cart_selected_%s' % user.id, sku_id) else: redis_conn.srem('cart_selected_%s' % user.id, sku_id) return Response(serializer.data) # 没有登陆 else: cart = request.COOKIES.get('cart') # 解密 if cart is not None: cookie_cart = pickle.loads(base64.b64decode(cart)) else: cookie_cart = {} # 便利数据并更新 if sku_id in cookie_cart: cookie_cart[sku_id] = {'count': count, 'selected': selected} # 加密 cookie = base64.b64encode(pickle.dumps(cookie_cart)).decode() # 设置cookie response = Response(serializer.data) response.set_cookie('cart', cookie, 3600) return response