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)
