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
