def get(self, request): """ 查询购物车所有的商品 """ user = request.user if user.is_authenticated(): redis_conn = get_redis_connection('cart') dict_cart = redis_conn.hgetall('cart_%s' % user.id) list_cart_selected = redis_conn.smembers('cart_selected_%s' % user.id) cart = {} for sku_id, count in dict_cart.items(): cart[int(sku_id)] = { 'count': int(count), 'selected': sku_id in list_cart_selected } else: # 用户未登录,从cookie中读取 cart = request.COOKIES.get('cart') if cart is not None: # 购物车base64字符串 --> 字典 cart = pickle.loads(base64.b64decode(cart.encode())) print('cookie:', cart) else: cart = {} # 查询购物车中所有的商品 skus = SKU.objects.filter(id__in=cart.keys()) for sku in skus: # 给sku对象新增两个字段: 商品数量和勾选状态 sku.count = cart[sku.id]['count'] sku.selected = cart[sku.id]['selected'] serializer = CartSKUSerializer(skus, many=True) return Response(serializer.data)
def get(self,request): # 查询redis中选中的商品 redis_cli = get_redis_connection('cart') # 获取商品的编号与数量{b'1': b'1', b'15': b'1'} cart_dict = redis_cli.hgetall('cart%d'%request.user.id) # 转换为int cart_dict2 = {int(k):int(v) for k,v in cart_dict.items()} # 获取选中的商品 cart_selected = redis_cli.smembers('cart_selected%d'%request.user.id) # 查询商品对象 skus = SKU.objects.filter(pk__in=cart_selected) for sku in skus: sku.count = cart_dict2.get(sku.id) sku.selected = True serializer = CartSKUSerializer(skus,many=True) result = { 'freight':10, 'skus':serializer.data } return Response(result)
def get(self, request): try: user = request.user except Exception: user = None if user is not None and user.is_authenticated: redis_conn = get_redis_connection('cart') redis_cart = redis_conn.hgetall('cart_%s' % user.id) redis_cart_select = redis_conn.smembers('cart_selected_%s' % user.id) cart = {} for sku_id, count in redis_cart.items(): cart[int(sku_id)] = { 'count': int(count), 'selected': sku_id in redis_cart_select } else: cart_str = request.COOKIES.get('cart') if cart_str is not None: cart = pickle.loads(base64.b64decode(cart_str.encode())) else: cart = {} skus = SKU.objects.filter(id__in=cart.keys()) for sku in skus: sku.count = cart[sku.id]['count'] sku.selected = cart[sku.id]['selected'] serializer = CartSKUSerializer(skus, many=True) return Response(serializer.data)
def get(self, request): """查询购物车商品""" try: user = request.user except Exception: user = None if user and user.is_authenticated: # 已登录用户从redis中查询购物车商品 redis_conn = get_redis_connection("cart") # redis_cart = { # 商品的sku_id(bytes类型): count数量(bytes类型) # 1: 1 # 16: 2 # ... # } redis_cart = redis_conn.hgetall("cart_%s" % user.id) # set(勾选的商品sku_id(bytes类型), 1, 3, 16,....) redis_cart_selected = redis_conn.smembers("cart_selected_%s" % user.id) cart_dict = {} for sku_id, count in redis_cart.items(): cart_dict[int(sku_id)] = { "count": int(count), "selected": sku_id in redis_cart_selected } else: # 未登录匿名用户从cookie中查询购物车商品 cookie_cart = request.COOKIES.get("cart") if cookie_cart: cart_dict = pickle.loads(base64.b64decode( cookie_cart.encode())) else: cart_dict = {} # cart_dict = { # sku_id_1: { # 'count': 10 # 'selected': True # }, # sku_id_2: { # 'count': 10 # 'selected': False # }, # } sku_id_list = cart_dict.keys() sku_obj_list = SKU.objects.filter(id__in=sku_id_list) for sku in sku_obj_list: # 添加需要额外返回的属性 sku.count = cart_dict[sku.id]["count"] sku.selected = cart_dict[sku.id]["selected"] serializer = CartSKUSerializer(sku_obj_list, many=True) return Response(serializer.data)
def get(self,request): # 1.接收用户信息 try: user=request.user except Exception as e: user=None # 2.根据用户信息进行判断 if user is not None and user.is_authenticated: # 3.登陆用户从redis中获取数据 # 3.1 连接redis redis_conn = get_redis_connection('cart') # 3.2 hash cart_userid: {sku_id:count} # set cart_selected_userid: sku_id # 获取hash的所有数据 redis_ids_count=redis_conn.hgetall('cart_%s'%user.id) # [sku_id,sku_id] # 获取set数据 redis_selected_ids=redis_conn.smembers('cart_selected_%s'%user.id) # redis获取的数据是 bytes类型的,我们将它转换为 cookie的数据格式 cookie_cart={} for sku_id,count in redis_ids_count.items(): cookie_cart[int(sku_id)]={ 'count':int(count), 'selected':sku_id in redis_selected_ids } else: # 4.未登陆用户从cookie中获取数据 # 4.1 先从cookie中获取数据 cookie_str=request.COOKIES.get('cart') # 4.2 判断是否存在购物车数据 if cookie_str is not None: #将base64数据进行解码 decode=base64.b64decode(cookie_str) #将二进制转换为字典 cookie_cart=pickle.loads(decode) else: cookie_cart={} # {sku_id:{count:xxx,selected:xxxx}} # # [sku_id,sku_id] # 5 根据商品id,获取商品的详细信息 ids=cookie_cart.keys() skus=SKU.objects.filter(pk__in=ids) #对商品列表数据进行便利,来动态的添加count和选中状态 for sku in skus: sku.count=cookie_cart[sku.id]['count'] sku.seleted=cookie_cart[sku.id]['selected'] # 6 返回相应 serializer = CartSKUSerializer(skus,many=True) return Response(serializer.data)
def get(self,request): """查询购物车中的商品""" # 获取用户对象 user = request.user # 判断是否已经登录 if user.is_authenticated(): # cart_1 = {1: 2, 2: 2} # cart_selected_1 = {1, 2} # 用户已登录,获取操作Redis的StrictRedis对象 strict_redis = get_redis_connection('carts') # type: StrictRedis # 读取购物车的商品数据,得到一个字典 cart_dict = strict_redis.hgetall('cart_%s' % user.id) # 字典: bytes # 读取商品勾选状态,得到一个列表 cart_selected_list = strict_redis.smembers('cart_selected_%s' % user.id) # 列表: bytes cart = {} for sku_id, count in cart_dict.items(): ''' cart[1] = { 'count': 1, 'selected': True } ''' cart[int(sku_id)] = { 'count': int(count), 'selected': sku_id in cart_selected_list } # 拼接得到类似如下字典 : # {1:{'count':2, 'selected':False}, 2:{'count':2, 'selected':False}} else: # 未登录 # 从cookie中获取购物车信息 cart = request.COOKIES.get('cart') # base64字符串 -> 字典: cookie_cart.keys() -> [1,2] # {1: {'count':2, 'selected':False}, 2: {'count':2, 'selected':False}} if cart is None: cart = {} else: cart = pickle.loads(base64.b64decode(cart.encode())) print('cookie', cart) # 查询的所有的商品对象: SKU.objects.filter(id__in=[1,2]) skus = SKU.objects.filter(id__in=cart.keys()) # 给商品对象新增count和selected属性 for sku in skus: sku.count = cart[sku.id].get('count') sku.selected = cart[sku.id].get('selected') # 序列化商品对象并响应数据 s = CartSKUSerializer(instance=skus, many=True) return Response(s.data)
def get(self, request): ''' 查询购物车 1.前端get方式请求 2.接收前端请求 3.登录用户redis中获取数据 1)链接redis 2)hash cat_userid: {sku_id: count}, set selected: {sku_id, sku_id} 3) 根据商品id获取商品详情信息 4.未登录用户从cookie中获取数据 1)判断cookie中是否存在购物车数据 2)存在解码转换字典 3)返回数据 :param request: :return: ''' try: user = request.user except Exception: user = None if user is not None: redis_conn = get_redis_connection('cart') if user is not None and user.is_authenticated: redis_cart_select = redis_conn.smembers('cart_selected_%s' % user.id) redis_cart = redis_conn.hgetall('cart_%s' % user.id) cart = {} for sku_id, count in redis_cart.items(): cart[int(sku_id)] = { 'count': int(count), 'selected': sku_id in redis_cart_select } else: # 非登录用户,从cookie中获取数据 cart_str = request.COOKIES.get('cart') if cart_str is not None: cart = pickle.loads(base64.b64decode(cart_str.encode())) else: cart = {} # 获取所有商品的信息 skus = SKU.objects.filter(id__in=cart.keys()) for sku in skus: sku.count = cart[sku.id]['count'] sku.selected = cart[sku.id]['selected'] # 序列化数据,并返回响应 serializer = CartSKUSerializer(skus, many=True) return Response(serializer.data)
def get(self, request): """ 思路 #判断是否为登录用户 #登录用户,从redis中获取数据 #非登录用户,从cookie中获取数据 #获取所有商品的信息 #返回响应 """ try: user = request.user except Exception: user = None # 判断是否为登录用户 if user is not None and user.is_authenticated: # 登录用户,从redis中获取数据 redis_conn = get_redis_connection('cart') redis_cart = redis_conn.hgetall('cart_%s' % user.id) redis_cart_select = redis_conn.smembers('cart_selected_%s' % user.id) cart = {} for sku_id, count in redis_cart.items(): # cart[sku_id] = { # 'count': count, # 'selected': sku_id in redis_cart_select # } cart[int(sku_id)] = { 'count': int(count), 'selected': sku_id in redis_cart_select } else: # 非登录用户,从cookie中获取数据 cart_str = request.COOKIES.get('cart') if cart_str is not None: cart = pickle.loads(base64.b64decode(cart_str.encode())) else: cart = {} # 获取所有商品的信息 skus = SKU.objects.filter(id__in=cart.keys()) for sku in skus: sku.count = cart[sku.id]['count'] sku.selected = cart[sku.id]['selected'] # 序列化数据,并返回响应 serializer = CartSKUSerializer(skus, many=True) return Response(serializer.data)
def get_action(self): """获取购物车数据""" # 返回购物车数据 response_cart = {} # 如果是已登录用户 -- 数据存储在Redis if self.user_.is_authenticated(): # 获取数据库中当前用户的购物车商品信息 self.pl.hgetall('cart_%s' % self.user_.id) # 获取数据库中当前用户的购物车商品勾选信息 self.pl.smembers('cart_selected_%s' % self.user_.id) # 管道执行 -- 返回结果 result = self.pl.execute() # 购物车商品信息 dict_cart = result[0] # 购物车商品勾选信息 list_cart_selected = result[1] # 拼装字典 -- 循环购物车商品信息, sku_id: 商品id, count: 数量 for sku_id, count in dict_cart.items(): # 当前购物车商品 response_cart[int(sku_id)] = { # 商品数量 'count': int(count), # 是否选择 -- 判断当前商品是否在商品勾选信息中 'selected': sku_id in list_cart_selected } # 未登陆用户 -- 数据存储在cookie else: # 如果有cookie购物车数据 if self.cookie_cart: # 获取cookie购物车数据 response_cart = self.cookie_cart # 查询购物车中所有的商品 skus = SKU.objects.filter(id__in=response_cart.keys()) # 循环sku列表, 添加两个字段: 商品数量和勾选状态 for sku in skus: # sku当前购物车中的数量 sku.count = response_cart[sku.id]['count'] # sku当前购物车中是否勾选状态 sku.selected = response_cart[sku.id]['selected'] # 响应序列化数据 serializer = CartSKUSerializer(skus, many=True) # 返回响应 return Response(serializer.data)
def get(self, request): """ 查询购物车 :return: """ # 判断用户是否登录 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_cart = redis_conn.hgetall( "cart_%s" % user.id) # hgetall() 返回哈希表 key 中,所有的域和值。 redis_cart_selected = redis_conn.smembers("cart_selected_%s" % user.id) # 返回字典所有key cart = {} for sku_id, count in redis_cart.items(): cart[int(sku_id)] = { "count": int(count), "selected": sku_id in redis_cart_selected } else: # 如果没有登录 从cookie查询商品 cart = request.COOKIES.get("cart") if cart is not None: cart = pickle.loads(base64.b64decode(cart.encode())) else: cart = {} # 遍历处理购物车数据 skus = SKU.objects.filter(id__in=cart.keys()) # 得到大字典 for sku in skus: sku.count = cart[sku.id]["count"] sku.selected = cart[sku.id]["selected"] serizlizer = CartSKUSerializer(skus, many=True) return Response(serizlizer.data)
def get(self, request): # 判断用户是否登录 try: user = request.user except Exception: # 验证失败,用户未登录 user = None # 必须同时检查认证状态和是否存在 if user is not None and user.is_authenticated: # 用户已登录,从redis中读取 redis_conn = get_redis_connection('cart') redis_cart = redis_conn.hgetall('cart_%s' % user.id) redis_cart_selected = redis_conn.smembers('cart_selected_%s' % user.id) cart = {} for sku_id, count in redis_cart.items(): print(sku_id) print(count) cart[int(sku_id)] = { 'count': int(count), 'selected': sku_id in redis_cart_selected } else: # 用户未登录,从cookie中读取 cart = request.COOKIES.get('cart') if cart is not None: cart = pickle.loads(base64.b64decode(cart.encode())) else: cart = {} # 获取查询集并进行序列化 skus = SKU.objects.filter(id__in=cart.keys()) # 此时SKU不包含数量和勾选状态, 需要手动添加 for sku in skus: sku.count = cart[sku.id]['count'] sku.selected = cart[sku.id]['selected'] serializer = CartSKUSerializer(skus, many=True) return Response(serializer.data)
def get(self,request): try: user = request.user except Exception: user = None if user is not None and user.is_authenticated: redis_conn = get_redis_connection('cart') redis_ids_count = redis_conn.hgetall('cart_%s'%user.id) redis_selected_ids = redis_conn.smembers('cart_selected_%s'%user.id) cookie_cart = {} for id,count in redis_ids_count: if id in redis_selected_ids: selected=True else: selected=False cookie_cart[id]={ 'count':count, 'selected':selected } else: cart_str=request.COOKIES.get('cart') if cart_str is not None: cookie_cart=pickle.loads(base64.b64decode(cart_str)) else: cookie_cart={} ids=cookie_cart.keys() skus=SKU.objects.filter(pk__in=ids) for sku in skus: sku.count=cookie_cart[sku.id]['count'] sku.selected=cookie_cart[sku.selected]['selected'] serializer=CartSKUSerializer(skus,many=True) return Response(serializer.data)
def get(self, request): """获取购物车商品信息""" # 判断用户是是否存在 try: user = request.user except: user = None if user and user.is_authenticated: # 用户已登录,从redis中获取数据 redis_conn = get_redis_connection("cart") redis_cart = redis_conn.hgetall("cart_%s" % user.id) redis_cart_selected = redis_conn.smembers("cart_selected_%s" % user.id) # 购物车内商品 cart = {} for sku_id, count in redis_cart.items(): cart[int(sku_id)] = { "count":int(count), "selected":sku_id in redis_cart_selected } else: # 用户未登录,从cookie中获取数据 cart = request.COOKIES.get("cart") if cart is not None: cart = pickle.loads(base64.b64decode(cart.encode())) else: cart = {} # 遍历处理购物车数据 skus = SKU.objects.filter(id__in=cart.keys()) for sku in skus: sku.count = cart[sku.id]["count"] sku.selected = cart[sku.id]["selected"] # 序列化返回 serializer = CartSKUSerializer(skus, many=True) return Response(serializer.data)
def get(self, request): try: user = request.user except Exception: user = None # 登陆用户 if user is not None and user.is_authenticated: redis_conn = get_redis_connection('cart') redis_cart = redis_conn.hgetall('cart_%s' % user.id) # 1:{sku_id:1,count:1} redis_selected = redis_conn.smembers('cart_selected_%s' % user.id) # 1:{1,2,3} cart = {} for sku_id, count in redis_cart.items(): cart[int(sku_id)] = { 'count': int(count), 'selected': sku_id in redis_selected } # {1: {'count': 1, 'selected': True}} # 未登录用户 else: cookie_str = request.COOKIES.get('cart') if cookie_str is not None: cart = pickle.loads(base64.b64decode(cookie_str)) else: cart = {} # 获取商品的信息 skus = SKU.objects.filter(id__in=cart.keys()) # 修改信息 for sku in skus: sku.count = cart[sku.id]['count'] sku.selected = cart[sku.id]['selected'] serializer = CartSKUSerializer(skus, many=True) return Response(serializer.data)
def get(self, request): # 连接redis数据库 redis_cli = get_redis_connection('carts') # 获取商品的编号与数量 cart_dict = redis_cli.hgetall('cart%d' % request.user.id) cart_dict2 = {} for k, v in cart_dict.items(): cart_dict2[int(k)] = int(v) # 获取选中的商品 cart_selected = redis_cli.smembers('cart_selected%d' % request.user.id) # 查询商品对象 skus = SKU.objects.filter(pk__in=cart_selected) for sku in skus: sku.count = cart_dict2.get(sku.id) sku.selected = True # 构造响应结果 serializer = CartSKUSerializer(skus, many=True) result = {'freight': 10, 'skus': serializer.data} # 返回结果 return Response(result)
def get(self, request): """ 获取购物车 """ try: user = request.user except Exception: user = None if user is not None and user.is_authenticated: # 用户已登录,从redis中读取 redis_conn = get_redis_connection('cart') redis_cart = redis_conn.hgetall('cart_%s' % user.id) redis_cart_selected = redis_conn.smembers('cart_selected_%s' % user.id) cart = {} for sku_id, count in redis_cart.items(): cart[int(sku_id)] = { 'count': int(count), 'selected': sku_id in redis_cart_selected } else: # 用户未登录,从cookie中读取 cart = request.COOKIES.get('cart') if cart is not None: cart = myjson.loads(cart) else: cart = {} # 遍历处理购物车数据 skus = SKU.objects.filter(id__in=cart.keys()) for sku in skus: sku.count = cart[sku.id]['count'] sku.selected = cart[sku.id]['selected'] serializer = CartSKUSerializer(skus, many=True) return Response(serializer.data)
def get(self, request): """获取购物车列表""" # 判断用户登陆状态 try: user = request.user except Exception: user = None # 如果已登陆,从redis取回购物车信息 if user and user.is_authenticated: redis = get_redis_connection('cart') redis_cart = redis.hgetall('cart_%s' % user.id) redis_cart_selected = redis.smembers('cart_selected_%s' % user.id) cart = {} for sku_id, count in redis_cart.items(): cart[int(sku_id)] = { "count": int(count), "selected": sku_id in redis_cart_selected } # 未登录状态,从cookie取回购物车信息 else: cart = request.COOKIES.get('cart') if cart: cart = pickle.loads(base64.b64decode(cart.encode())) else: cart = {} skus = SKU.objects.filter(id__in=cart.keys()) for sku in skus: sku.count = cart[sku.id]["count"] sku.selected = cart[sku.id]["selected"] serializer = CartSKUSerializer(instance=skus, many=True) return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, request): """ 当用户点击购物车列表的时候,前端需要发送一个get请求 get请求的数据 需要将用户信息传递过来 1.接收用户信息 2.根据用户信息进行判断 3.登陆用户从redis中获取数据 3.1 连接redis 3.2 hash cart_userid: {sku_id:count} set cart_selected_userid: sku_id 获取hash的所有数据 [sku_id,sku_id] 3.3 根据商品id,获取商品的详细信息 3.4 返回相应 4.未登陆用户从cookie中获取数据 4.1 先从cookie中获取数据 4.2 判断是否存在购物车数据 {sku_id:{count:xxx,selected:xxxx}} [sku_id,sku_id] 4.3 根据商品id,获取商品的详细信息 4.4 返回相应 # 1.接收用户信息 # 2.根据用户信息进行判断 # 3.登陆用户从redis中获取数据 # 3.1 连接redis # 3.2 hash cart_userid: {sku_id:count} # set cart_selected_userid: sku_id # 获取hash的所有数据 # [sku_id,sku_id] # 4.未登陆用户从cookie中获取数据 # 4.1 先从cookie中获取数据 # 4.2 判断是否存在购物车数据 # {sku_id:{count:xxx,selected:xxxx}} # # [sku_id,sku_id] # 5 根据商品id,获取商品的详细信息 # 6 返回相应 """ # 1.接收用户信息 try: user = request.user except Exception as e: user = None # 2.根据用户信息进行判断 # request.user.is_authenticated if user is not None and user.is_authenticated: # 3.登陆用户从redis中获取数据 # 3.1 连接redis redis_conn = get_redis_connection('cart') # 3.2 hash cart_userid: {sku_id:count} # set cart_selected_userid: sku_id # 获取hash的所有数据 redis_sku_ids = redis_conn.hgetall('cart_%s' % user.id) # [sku_id,sku_id] # 获取set数据 redis_selected = redis_conn.smembers('cart_selected_%s' % user.id) cookie_cart = {} for sku_id, count in redis_sku_ids.items(): cookie_cart[int(sku_id)] = { 'count': int(count), 'selected': sku_id in redis_selected } else: # 4.未登陆用户从cookie中获取数据 # 4.1 先从cookie中获取数据 cart_str = request.COOKIES.get('cart') # 4.2 判断是否存在购物车数据 if cart_str is not None: # {sku_id:{count:xxx,selected:xxxx}} # 有数据 # 因为是base64所以进行解码,在转换为字典 cookie_cart = pickle.loads(base64.b64decode(cart_str)) else: cookie_cart = {} # [sku_id,sku_id] # 5 根据商品id,获取商品的详细信息 ids = cookie_cart.keys() #[1,2,3,4] #[sku,sku,sku] skus = SKU.objects.filter(pk__in=ids) # 对商品列表数据进行遍历,来动态的添加count和选中状态 for sku in skus: sku.count = cookie_cart[sku.id]['count'] sku.selected = cookie_cart[sku.id]['selected'] # 6 返回相应 serializer = CartSKUSerializer(skus, many=True) return Response(serializer.data)
class OrderSettlementSerializer(serializers.Serializer): # max_digits 包含小数的最多位数,decimal_places 几位小数 freight = serializers.DecimalField(max_digits=10, decimal_places=2) # skus = [ {'id': 10, 'name': ... }, { ... }, ... ] # skus 是一个嵌套的序列化器结果 skus = CartSKUSerializer(many=True, read_only=True)
def get(self, request): """查询购物车""" # 1. 判断用户是否登录 try: user = request.user except Exception: user = None # 查询 if user and user.is_authenticated: # 2. 如果已登录,那么从redis 中查询 : sku_id, count, selected redis_conn = get_redis_connection('cart') redis_cart = redis_conn.hgetall("cart_%s" % user.id) # redis 中虽然保存的都是字典,但是具体的数据类型都是bytes # redis_cart = { # 商品的sku_id bytes字节类型: 数量 bytes字节类型 # 商品的sku_id bytes字节类型: 数量 bytes字节类型 # ... # } redis_cart_selected = redis_conn.smembers('cart_selected_%s' % user.id) # redis_cart_selected = set(勾选的商品sku_id bytes字节类型, ....) # 遍历 redis_dict , 形成 cart_dict cart_dict = {} for sku_id, count in redis_cart.items(): cart_dict[int(sku_id)] = { 'count': int(count), # 可以直接将bytes转成python中的int 'selected': sku_id in redis_cart_selected # in 直接来形成 True|False } else: # 3. 如果未登录, 那么从 cookies 中查询: ... cookie_cart = request.COOKIES.get('cart', None) # 前面设置的cookies中的名字就是 cart if cookie_cart: # 表示cookie中有购物车数据 # 解析 cart_dict = pickle.loads(base64.b64decode(cookie_cart.encode())) else: cart_dict = {} # 不论是否登录,最终都处理成 下面的 数据结构设计 # cart_dict = { # sku_id_1: { # 'count': 10 # 'selected': True # }, # sku_id_2: { # 'count': 10 # 'selected': False # }, # } # 4. 查询数据库,获取商品的详细信息 sku_id_list = cart_dict.keys() sku_obj_list = SKU.objects.filter(id__in=sku_id_list) # 遍历sku_obj_list 向sku对象中添加count和selected属性 for sku in sku_obj_list: sku.count = cart_dict[sku.id]['count'] sku.selected = cart_dict[sku.id]['selected'] # 5. 序列化返回 serializer = CartSKUSerializer(sku_obj_list, many=True) return Response(serializer.data)
def get(self, request): """ 购物车记录获取 1. 获取user 2. 获取用户的购物车记录 2.1 如果用户已登录, 从redis中获取用户的redis 2.2 如果用户未登录, 从cookie中获取购物车记录 3. 根据用户购物车中的商品sku_id获取对应的商品的信息 4. 将商品数据序列化并返回 """ # 1. 获取user try: user = request.user except Exception: user = None # 2. 获取用户的购物车记录 if user and user.is_authenticated: # 2.1 如果用户已登录, 从redis中获取用户的redis redis_conn = get_redis_connection('carts') # 从redis中获取用户购物车记录中的sku_id cart_key = 'cart_%s' % user.id # hgetall(key): 获取redis中hash的属性和值 # { # b'<sku_id>': b'<count>', # ... # } redis_cart = redis_conn.hgetall(cart_key) # 从redis中获取用户购物车记录被勾选后商品的sku_id cart_selected_key = 'cart_selected_%s' % user.id # smembers(key): 获取redis中set的所有元素 # (b'<sku_id>', b'<sku_id>', ...) redis_cart_selected = redis_conn.smembers(cart_selected_key) # set cart_dict = {} for sku_id, count in redis_cart.items(): cart_dict[int(sku_id)] = { 'count': int(count), 'selected': sku_id in redis_cart_selected } else: # 2.2 如果用户未登录, 从cookie中获取购物车记录 cookie_cart = request.COOKIES.get('cart') # None if cookie_cart: # 解析cookie购物车数据 # { # '<sku_id>': { # 'count': '<count>', # 'selected': '<selected>' # }, # ... # } cart_dict = pickle.loads(base64.b64decode(cookie_cart)) else: cart_dict = {} # 3. 根据用户购物车中的商品sku_id获取对应的商品的信息 sku_ids = cart_dict.keys() # select * from tb_sku where id in (1,2,3) skus = SKU.objects.filter(id__in=sku_ids) for sku in skus: # 给sku对象增加属性count和selected # 分别保存用户购物车中添加的该商品的数量和勾选状态 sku.count = cart_dict[sku.id]['count'] sku.selected = cart_dict[sku.id]['selected'] # 4. 将商品数据序列化并返回 skus_serializer = CartSKUSerializer(skus, many=True) return Response(skus_serializer.data)
class OrderSettlementSerializer(serializers.Serializer): # max_digits 包含小数的最多位数,decimal_places 几位小数 12345123.45 freight = serializers.DecimalField(max_digits=10, decimal_places=2, read_only=True) skus = CartSKUSerializer(many=True, read_only=True)
def get(self, request): """ 查询购物车 1. 先判断用户是否登陆 2. 根据不同的登陆状态取出客户的购物车数据 """ # 获取user try: user = request.user except Exception: user = None # 链接redis数据库 redis_conn = get_redis_connection("cart") if user and user.is_authenticated: # 用户登陆状态 # 创建key cart_key = "cart_%s" % user.id # 获取hash中所有的属性和值 redis_cart = redis_conn.hgetall(cart_key) # 获取购物车商品中被选中的商品id cart_selected_key = "cart_selected_%s" % user.id redis_cart_selected = redis_conn.smembers(cart_selected_key) # 组织数据 # { # '<sku_id>': { # 'count': '<count>', # 'selected': '<selected>' # }, # ... # } cart_dict = {} for sku_id, count in redis_cart.items(): cart_dict[int(sku_id)] = { 'count': count, 'selected': sku_id in redis_cart_selected } else: # 用户未登陆 # 从cookie中获取数据 cookie_cart = request.COOKIES.get('cart') if cookie_cart: cart_dict = pickle.loads(base64.b64decode(cookie_cart)) else: cart_dict = {} # 根据购物车信息获取商品的信息 skus = SKU.objects.filter(id__in=cart_dict.keys()) for sku in skus: sku.count = cart_dict[sku.id]['count'] sku.selected = cart_dict[sku.id]['selected'] # 将商品数据序列化并进行返回 serializer = CartSKUSerializer(skus, many=True) # serializer.is_valid(raise_exception=True) return Response(serializer.data)
class OrderSettlementSerializer(serializers.Serializer): freight = serializers.DecimalField(label='运费', max_digits=10, decimal_places=2) skus = CartSKUSerializer(many=True, read_only=True)
def get(self, request): """查询购物车""" # 判断用户登录状态 try: user = request.user except Exception: user = None # 查询 if user and user.is_authenticated: # 如果用户已登录,从redis中查询 sku_id count selected redis_conn = get_redis_connection('cart') redis_cart = redis_conn.hgetall('cart_%s' % user.id) # redis_cart = { # 商品的sku_id bytes字节类型: 数量 bytes字节类型 # 商品的sku_id bytes字节类型: 数量 bytes字节类型 # ... # } redis_cart_selected = redis_conn.smembers('cart_selected_%s' % user.id) # redis_cart_selected = set(勾选的商品sku_id bytes字节类型, ....) # 遍历 redis_cart,形成cart_dict cart_dict = {} for sku_id, count in redis_cart.items(): cart_dict[int(sku_id)] = { 'count': int(count), 'selected': sku_id in redis_cart_selected } else: # 如果用户未登录,从cookie中查询 cookie_cart = request.COOKIES.get('cart') if cookie_cart: # 表示cookie中有购物车数据 # 解析 cart_dict = pickle.loads(base64.b64decode( cookie_cart.encode())) else: # 表示cookie中没有购物车数据 cart_dict = {} # cart_dict = { # sku_id_1: { # 'count': 10 # 'selected': True # }, # sku_id_2: { # 'count': 10 # 'selected': False # }, # } # 查询数据库 sku_id_list = cart_dict.keys() sku_obj_list = SKU.objects.filter(id__in=sku_id_list) # 遍历sku_obj_list 向sku对象中添加count和selected属性 for sku in sku_obj_list: sku.count = cart_dict[sku.id]['count'] sku.selected = cart_dict[sku.id]['selected'] # 序列化返回 serializer = CartSKUSerializer(sku_obj_list, many=True) return Response(serializer.data)