def get(self,request):
sku_result = get_cart(request.user)
serializer = CartSKUSerializer(sku_result, many=True)
return Response(serializer.data)
def get(self, request):
"""cart_data"""
# cart_dict = self.read_cart(request)
cart_dict = request.cart
cart_sku_list = SKU.objects.filter(id__in=cart_dict.keys())
for sku in cart_sku_list:
sku.count = cart_dict[str(sku.id)][0]
sku.selected = cart_dict[str(sku.id)][1]
serializer = CartSKUSerializer(cart_sku_list, many=True)
return Response(serializer.data)
def get(self, request):
# 判断用户的登录状态,
try:
user = request.user
except Exception as e:
logger.error(e)
user = None
# 如果已经登录从redis中查询
if user is not None and user.is_authenticated:
redis_conn = get_redis_connection('cart')
# 分别查询两张表,byte类型
sku_id_count_dict = redis_conn.hgetall('cart_%s' % user.id)
selected_list = redis_conn.smembers('cart_selected_%s' % user.id)
# 调整
cart = {}
for sku_id, count in sku_id_count_dict.items():
cart[int(sku_id)] = {
'selected': sku_id in selected_list,
'count': int(count),
}
# 没有登录从cookie中查询
else:
cart_cookie = request.COOKIES.get('cart')
if cart_cookie is not None:
cart = pickle.loads(base64.b64decode(cart_cookie.encode()))
else:
cart = {}
# 返回数据给前端
sku_query_set = SKU.objects.filter(id__in=cart.keys())
for sku in sku_query_set:
# 再返回的数据中新增不在model中的额外字段
sku.count = cart[sku.id]['count']
sku.selected = cart[sku.id]['selected']
serializer = CartSKUSerializer(sku_query_set, many=True)
return Response(serializer.data)
def get(self, request):
"""
购物车记录获取:
1. 获取用户购物车的记录
1.1 如果用户已登录，从redis中获取用户的购物车记录
1.2 如果用户未登录，从cookie中获取用户的购物车记录
2. 根据用户购物车中商品的id获取对应商品的数据
3. 将购物车数据序列化并返回
"""
try:
# 触发认证机制
user = request.user
except Exception:
user = None
# 1. 获取用户购物车的记录
if user and user.is_authenticated:
# 1.1 如果用户已登录，从redis中获取用户的购物车记录
# redis链接
redis_conn = get_redis_connection('cart')
# 从redis hash中获取用户购物车中添加的商品的id和对应的数量count
cart_key = 'cart_%s' % user.id
# {
# b'<sku_id>': b'<count>',
# ...
# }
cart_redis = redis_conn.hgetall(cart_key)
# 从redis set中获取用户购物车被勾选的商品的id
cart_selected_key = 'cart_selected_%s' % user.id
# Set(b'<sku_id>', b'<sku_id>', ...)
sku_ids = redis_conn.smembers(cart_selected_key)
# 组织数据
# {
# '<sku_id>': {
# 'count': '<count>',
# 'selected': '<selected>'
# },
# ...
# }
cart_dict = {}
for sku_id, count in cart_redis.items():
cart_dict[int(sku_id)] = {
'count': int(count),
'selected': sku_id in sku_ids
}
else:
# 1.2 如果用户未登录，从cookie中获取用户的购物车记录
# 获取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.encode()))
else:
cart_dict = {}
# 2. 根据用户购物车中商品的id获取对应商品的数据
cart_sku_ids = cart_dict.keys() # (1, 3, 5)
# select * from tb_sku where id in (1, 3, 5);
skus = SKU.objects.filter(id__in=cart_sku_ids)
for sku in skus:
# 给sku对象增加属性count和selected
# 分别保存该对象在用户购物车中添加的商品的数量和勾选状态
sku.count = cart_dict[sku.id]['count']
sku.selected = cart_dict[sku.id]['selected']
# 3. 将购物车数据序列化并返回
serializer = CartSKUSerializer(skus, many=True)
return Response(serializer.data)
def get(self, request):
"""
购物车记录获取:
1. 获取user
2. 获取用户的购物车记录
2.1 如果用户已登录，从redis中获取用户的购物车记录
2.2 如果用户未登录，从cookie中获取用户的购物车记录
3. 根据用户购物车中商品的id查询对应商品的信息
4. 把商品数据序列化并返回
"""
# 1. 获取user
try:
user = request.user
except Exception as e:
user = None
# 2. 获取用户的购物车记录
if user is not None and user.is_authenticated:
# 2.1 如果用户已登录，从redis中获取用户的购物车记录
# 获取redis链接
redis_conn = get_redis_connection('cart')
# 从redis中获取用户购物车中添加的商品sku_id和对应数量count hash
cart_key = 'cart_%s' % user.id
# hgetall(key): 返回hash中所有属性和值
# {
# b'<sku_id>': b'<count>',
# b'<sku_id>': b'<count>',
# ...
# }
cart_redis = redis_conn.hgetall(cart_key) # dict
# 从redis中获取用户购物车勾选商品sku_id set
cart_selected_key = 'cart_selected_%s' % user.id
# smembers(key): 获取set中所有元素
# (b'<sku_id>', b'<sku_id>', ...)
cart_selected_redis = redis_conn.smembers(cart_selected_key) # set
# 组织数据
# {
# '<sku_id>': {
# 'count': '<count>',
# 'selected': '<selected>'
# },
# ...
# }
cart_dict = {}
for sku_id, count in cart_redis.items():
cart_dict[int(sku_id)] = {
'count': int(count),
'selected': sku_id in cart_selected_redis
}
else:
# 2.2 如果用户未登录，从cookie中获取用户的购物车记录
# 尝试从cookie中获取原始的购物车数据
cookie_cart = request.COOKIES.get('cart') # None
if cookie_cart:
# 解析cookie中购物车数据
cart_dict = pickle.loads(base64.b64decode(cookie_cart))
else:
cart_dict = {}
# 3. 根据用户购物车中商品的id查询对应商品的信息
sku_ids = cart_dict.keys()
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. 把商品数据序列化并返回
serializer = CartSKUSerializer(skus, many=True)
return Response(serializer.data)
def get(self, request):
"""
购物车记录获取
1.获取用户的购物车记录
1.1如果用户以登录,从redis中获取用户的购物车记录
1.2rug用户未登录,从cookie中获取用户的购物车记录
2.根据用户购物车中商品id获取对应商品的数据
3.将购物车商品的数据序列化并返回
"""
try:
user = request.user
except Exception:
user = None
# 1.获取用户的购物车记录
if user and user.is_authenticated:
#1.1如果用户以登录,从redis中获取用户的购物车记录
#获取redis链接
redis_conn = get_redis_connection('cart')
# 从redis 哈市中获取用户购物车中添加的商品id和对应的数量count
cart_key = 'cart_%s' % user.id
# {
# b'<sku_id>':b'<count>',
# ...
# }
cart_redis = redis_conn.hgetall(cart_key)
# 从redis set中获取用户购物车中勾选的商品id
cart_selected_key = 'cart_selected_%s' % user.id
cart_selected_redis = redis_conn.smembers(cart_selected_key)
# {
# '<sku_id>':{
# 'count':'<count>',
# 'selected':'<selected>'
# },
# ...
# }
cart_dict = {}
for sku_id, count in cart_redis.items():
cart_dict[int(sku_id)] = {
'count': int(count),
'selected': sku_id in cart_selected_redis
}
else:
#1.2rug用户未登录,从cookie中获取用户的购物车记录
# 获取cookie中的购物车数据
cookie_cart = request.COOKIES.get('cart')
if cookie_cart:
# 解析cookie中购物车数据
cart_dict = pickle.loads(base64.b64decode(cookie_cart))
else:
cart_dict = {}
# 2.根据用户购物车中商品id获取对应商品的数据
sku_ids = cart_dict.keys()
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']
# 3.将购物车商品的数据序列化并返回
serializer = CartSKUSerializer(skus, many=True)
return Response(serializer.data)
def get(self, request):
"""
获取用户的购物车记录:
1. 获取用户购物车记录
1.1 如果用户已登录，从redis中获取用户的购物车记录
1.2 如果用户未登录，从cookie中获取用户的购物车记录
2. 根据用户购物车中商品的sku_id获取对应商品的数据
3. 将商品的数据序列化并返回
"""
try:
user = request.user
except Exception as e:
user = None
# 1. 获取用户购物车记录
if user is not None and user.is_authenticated:
# 1.1 如果用户已登录，从redis中获取用户的购物车记录
redis_conn = get_redis_connection('cart')
# 从redis hash中获取登录用户购物车添加的商品的sku_id和对应数量count
cart_key = 'cart_%s' % user.id
# hgetall(key): 获取hash中所有的属性和值
# {
# b'<sku_id>': b'<count>',
# b'<sku_id>': b'<count>',
# ...
# }
cart_redis = redis_conn.hgetall(cart_key)
# 从redis set中获取登录用户购物车记录中被勾选的商品的sku_id
cart_selected_key = 'cart_selected_%s' % user.id
# smembers(key): 获取set中所有元素
# (b'<sku_id>', b'<sku_id>', ...)
cart_selected_redis = redis_conn.smembers(cart_selected_key)
# 组织数据
# {
# '<sku_id>': {
# 'count': '<count>',
# 'selected': '<selected>',
# },
# ...
# }
cart_dict = {}
for sku_id, count in cart_redis.items():
cart_dict[int(sku_id)] = {
'count': int(count),
'selected': sku_id in cart_selected_redis
}
else:
# 1.2 如果用户未登录，从cookie中获取用户的购物车记录
# 获取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 = {}
# 2. 根据用户购物车中商品的sku_id获取对应商品的数据
sku_ids = cart_dict.keys()
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']
# 3. 将商品的数据序列化并返回
serializer = CartSKUSerializer(skus, many=True)
return Response(serializer.data)
def get(self, request):
"""
购物车记录获取:
1. 获取user
2. 获取用户的购物车记录
2.1 如果用户已登录，从redis中获取用户的购物车记录
2.2 如果用户未登录，从cookie中获取用户的购物车记录
3. 根据用户购物车中商品sku_id获取对应商品的信息
4. 将商品数据序列化并返回
"""
# 1. 获取user
try:
# 调用request.user会触发DRF的认证，在这里如果认证处理，可以自己进行处理
user = request.user
except Exception:
user = None
# 2. 获取用户的购物车记录
if user is not None and user.is_authenticated:
# 2.1 如果用户已登录，从redis中获取用户的购物车记录
# 获取redis链接
redis_conn = get_redis_connection('cart')
# 从redis中获取用户购物车记录中商品的sku_id和对应数量count hash
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 set
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
# 组织数据
# {
# '<sku_id>': {
# 'count': '<count>',
# 'selected': '<selected>'
# },
# ...
# }
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. 将商品数据序列化并返回
serializer = CartSKUSerializer(skus, many=True)
return Response(serializer.data)