def put(self, request):
json_dict = json.loads(request.body.decode())
selected = json_dict.get('selected')
user = request.user
if user.is_authenticated:
# 修改 redis
redis_client = get_redis_connection('carts')
carts_data = redis_client.hgetall(user.id)
for cart in carts_data.items():
sku_id = cart[0].decode() # 转换为字符串
carts_dict = json.loads(cart[1].decode())
if selected:
carts_dict['selected'] = True
else:
carts_dict['selected'] = False
redis_client.hset(user.id, sku_id, json.dumps(carts_dict))
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '全选购物车成功'})
else:
# 修改cookie
carts_str = request.COOKIES.get('carts')
response = http.JsonResponse({
'code': RETCODE.OK,
'errmsg': '全选购物车成功'
})
if carts_str is not None:
carts_dict = CookieSecret.loads(carts_str)
for sku in carts_dict:
carts_dict[sku]['selected'] = selected
carts_secret = CookieSecret.dumps(carts_dict)
response.set_cookie('carts',
carts_secret,
max_age=14 * 24 * 3600)
return response
def put(self, request):
# 接收参数
selected = json.loads(request.body.decode()).get("selected")
# 判断是否登陆
user = request.user
if user.is_authenticated:
# 查询ｒｅｄｉｓ数据库
client = get_redis_connection("carts")
carts_data = client.hgetall(user.id)
for key, value in carts_data.items():
sku_id = int(key.decode())
carts_dict = json.loads(value.decode())
carts_dict["selected"] = selected
client.hset(user.id, sku_id, json.dumps(carts_dict))
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '全选购物车成功'})
else:
# 找到指定ｃｏｏｋｉｅ
carts_str = request.COOKIES.get("carts")
# 判断ｃａｒｔｓ_str 有没有
if carts_str:
carts_dict = CookieSecret.loads(carts_str)
for sku_id in carts_dict.keys():
carts_dict[sku_id]["selected"] = selected
cookie_cart = CookieSecret.dumps(carts_dict)
response = http.JsonResponse({
'code': RETCODE.OK,
'errmsg': '全选购物车成功'
})
response.set_cookie('carts', cookie_cart, 24 * 30 * 3600)
return response
def put(self, request):
# 1.接收参数 json
json_dict = json.loads(request.body.decode())
sku_id = json_dict.get('sku_id')
count = json_dict.get('count')
selected = json_dict.get('selected', True)
# 2. 校验 判空, sku, int(count), selected
try:
sku = SKU.objects.get(id=sku_id)
except:
return HttpResponseForbidden('商品不存在')
# 3.是否对登录
user = request.user
cookie_secret_str = ""
if user.is_authenticated:
# redis:
# 1.链接
carts_redis_client = get_redis_connection('carts')
# 2. hset
new_dict = {'count': count, 'selected': selected}
carts_redis_client.hset(user.id, sku_id, json.dumps(new_dict))
else:
# cookie
cookie_str = request.COOKIES.get('carts')
if cookie_str:
carts_dict = CookieSecret.loads(cookie_str)
else:
carts_dict = {}
carts_dict[sku_id] = {'count': count, 'selected': selected}
# 将修改完毕的 cookie 加密
cookie_secret_str = CookieSecret.dumps(carts_dict)
# 4. 构建前端的数据
cart_sku = {
'id': sku_id,
'count': count,
'selected': selected,
'name': sku.name,
'default_image_url': sku.default_image.url,
'price': sku.price,
'amount': sku.price * count,
}
response = JsonResponse({
'code': RETCODE.OK,
'errmsg': '修改购物车成功',
'cart_sku': cart_sku
})
if not user.is_authenticated:
response.set_cookie('carts',
cookie_secret_str,
max_age=30 * 24 * 3600)
# 5.返回响应
return response
def delete(self, request):
# 1 接收参数
json_dict = json.loads(request.body.decode())
sku_id = json_dict.get('sku_id')
# 2 校验参数
try:
sku = SKU.objects.get(id=sku_id)
except SKU.DoesNotExist:
return http.HttpResponseForbidden('商品不存在')
# 3 判断用户是否登录
user = request.user
if user.is_authenticated:
# 如果用户登录，操作redis
# 1 连接redis
client_conn = get_redis_connection('carts')
# 2 删除redis中数据
client_conn.hdel(user.id, sku_id)
# 3 响应结果
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '删除购物车成功'})
else:
# 如果用户没登录 操作cookie
# 1 获取cookie
cookie_str = request.COOKIES.get('carts')
# 2 判断用户是否操作过cookie
if cookie_str:
# 2.1 解密
carts_dict = CookieSecret.loads(cookie_str)
else:
# 2.2 空字典
carts_dict = {}
# 3 构造响应对象
response = http.JsonResponse({
'code': RETCODE.OK,
'errmsg': '删除购物车成功'
})
# 4 判断 商品 是否在cookie中
if sku_id in carts_dict:
# 4.1删除数据
del carts_dict[sku_id]
# 4.2加密
cookie_sstr = CookieSecret.dumps(carts_dict)
# 4.3将结果写入cookie
response.set_cookie('carts',
cookie_sstr,
max_age=3600 * 15 * 24)
# 5 响应结果
return response
def put(self, request):
# 接收参数
sku_id = json.loads(request.body.decode()).get("sku_id")
count = json.loads(request.body.decode()).get("count")
selected = json.loads(request.body.decode()).get("selected")
# 校验
try:
sku = SKU.objects.get(id=sku_id)
except Exception as e:
return http.HttpResponseForbidden("没有这个商品")
# 判断是否登陆
user = request.user
if user.is_authenticated:
# 修改redis
redis_client = get_redis_connection("carts")
# 覆盖ｒｅｄｉｓ以前所有数据
new_data = {"count": count, "selected": selected}
redis_client.hset(user.id, sku_id, json.dumps(new_data))
else:
# 修改ｃｏｏｋｉｅ
# 指定ｃｏｏｋｉｅ
cart_str = request.COOKIES.get("carts")
if cart_str:
# 将ｃｏｏｋｉｅ中的数据解密
cart_dict = CookieSecret.loads(cart_str)
else:
cart_dict = {}
# 将原来的数据覆盖
cart_dict[sku_id] = {"count": count, "selected": selected}
# 将明文转化为密文
cookie_dict_str = CookieSecret.dumps(cart_dict)
cart_sku = {
"id": sku.id,
"count": count,
"selected": selected,
"name": sku.name,
"default_image_url": sku.default_image.url,
"price": sku.price,
"amount": sku.price * count,
}
response = http.JsonResponse({
'code': RETCODE.OK,
'errmsg': '修改购物车成功',
'cart_sku': cart_sku
})
# 如果用户没有登录就创建一个新cookie
if not user.is_authenticated:
response.set_cookie("carts",
cookie_dict_str,
max_age=24 * 14 * 3600)
return response
def put(self,request):
# 接收参数
json_dict = json.loads(request.body.decode())
selected = json_dict.get('selected')
# 校验参数
if selected:
if not isinstance(selected,bool):
return
# 判断用户是否登录
user = request.user
if user.is_authenticated:
# 登录 操作redis
redis_conn = get_redis_connection('carts')
# 获取当前用户所有数据
redis_data = redis_conn.hgetall(user.id)
# 转成普通字典 修改seletecd
for key,value in redis_data.items():
sku_id = int(key.decode())
sku_value = json.loads(value.decode())
sku_value["selected"] = selected
# 写入数据
redis_conn.hset(user.id,sku_id,json.dumps(sku_value))
# 响应结果
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '全选购物车成功'})
else:
# 没登录 操作cookie
# 接收cookie
cookie_str = request.COOKIES.get('carts')
# 构造响应对象
response = http.JsonResponse({'code': RETCODE.OK, 'errmsg': '全选购物车成功'})
# 判断
if cookie_str is not None:
# 解密
carts_dict = CookieSecret.loads(cookie_str)
# 修改seleted
for sku_id in carts_dict:
carts_dict[sku_id]['selected'] = selected
# 加密
cookie_sstr = CookieSecret.dumps(carts_dict)
# 写入cookie
response.set_cookie('carts',cookie_sstr,max_age=3600*15*24)
# 响应结果
return response
def put(self, request):
'''
全选购物车
:param request:
:return:
'''
# 1.0 接收参数
json_dict = json.loads(request.body.decode())
selected = json_dict.get('selected', True)
# 2.0 校验参数
if selected:
if not isinstance(selected, bool):
HttpResponseForbidden('selected 参数不正确')
# 3.0 判断是否登录
user = request.user
if user.is_authenticated:
# 3.1 登录成功 redis
# 3.1.1 链接redis
carts_redis_client = get_redis_connection('carts')
# 3.1.2 获取所有数据
carts_data = carts_redis_client.hgetall(user.id)
# 3.1.3 将所有商品改成True
# 循环遍历
for carts in carts_data.items():
sku_id = carts[0].decode()
carts_dict = json.loads(carts[1].decode())
if selected:
# 全选
carts_dict['selected'] = selected
else:
# 取消全选
carts_dict['selected'] = selected
carts_redis_client.hset(user.id, sku_id,
json.dumps(carts_dict))
return JsonResponse({'code': RETCODE.OK, 'errmsg': '全选购物车成功'})
else:
# 3.2 未登录 cookie
# 获取carts 的cookie
carts_str = request.COOKIES.get('carts')
response = JsonResponse({'code': RETCODE.OK, 'errmsg': '全选购物车成功'})
# 3.2.1 如果存在 解密
if carts_str is not None:
carts_dict = CookieSecret.loads(carts_str)
for sku_id in carts_dict:
carts_dict[sku_id]['selected'] = selected
cookie_cart = CookieSecret.dumps(carts_dict)
response.set_cookie('carts',
cookie_cart,
max_age=constants.CARTS_COOKIE_EXPIRES)
return response
def put(self, request):
# 1.接收参数
selected = json.loads(request.body.decode()).get('selected', True)
# 2.校验参数 -省略
# 3.判断是否登录
user = request.user
dumps_str = ""
if user.is_authenticated:
# redis
# 1.链接
client = get_redis_connection('carts')
# 2.取所有 hgetall == {b'5':b'{count:3,selected:true}'}
redis_carts = client.hgetall(user.id)
# 3.遍历所有 购物车数据 --修改 selected 属性 hset
p1 = client.pipeline()
for k, v in redis_carts.items():
sku_id = int(k.decode())
sku_dict = json.loads(v.decode())
# 修改 所有购物车商品选中属性
sku_dict['selected'] = selected
p1.hset(user.id, sku_id, json.dumps(sku_dict))
p1.execute()
else:
# cookie
# 1.取出购物车的数据
cookie_str = request.COOKIES.get('carts')
# 2.如果有--解密
if cookie_str:
cart_dict = CookieSecret.loads(cookie_str)
# 3.遍历字典--判断是否有---修改 selected
for sku_id in cart_dict:
cart_dict[sku_id]['selected'] = selected
# 4.加密--set_cookie
dumps_str = CookieSecret.dumps(cart_dict)
response = http.JsonResponse({'code': 0, 'errmsg': "修改成功!"})
if not user.is_authenticated:
response.set_cookie('carts', dumps_str, max_age=24 * 3600 * 30)
# 4.返回响应对象
return response
def delete(self,request):
# 接收参数
json_dict = json.loads(request.body.decode())
sku_id = json_dict.get('sku_id')
# 校验参数
try:
sku = SKU.objects.get(id = sku_id)
except SKU.DoesNotExist:
return
# 判断用户是否登录
user = request.user
if user.is_authenticated:
# 登录 操作redis
redis_conn = get_redis_connection('carts')
# 删除数据
redis_conn.hdel(user.id,sku_id)
# 响应结果
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '删除购物车成功'})
else:
# 没登录 操作cookie
cookie_str = request.COOKIES.get('carts')
# 判断
if cookie_str:
# 解密
carts_dict = CookieSecret.loads(cookie_str)
else:
# 空字典
carts_dict = {}
# 构造响应对象
response = http.JsonResponse({'code': RETCODE.OK, 'errmsg': '删除购物车成功'})
# 判断 如果该商品在购物车中 就删除
if sku_id in carts_dict:
# 删除
del carts_dict[sku_id]
# 加密
cookie_sstr = CookieSecret.dumps(carts_dict)
# 响应结果并将购物车数据写入cookie
response.set_cookie('carts',cookie_sstr,max_age=3600*24*15)
# 响应结果
return response
def get(self,request):
# 接收参数
access_token = request.GET.get('access_token')
# 解密
token = CookieSecret.loads(access_token)
# 提取用户id和手机号
user_id = token['user_id']
user_mobile = token['mobile']
print("提出来的用户手机号:",user_mobile)
# 校验用户的手机号是否存在
try:
mobile = User.objects.get(id=user_id,mobile=user_mobile)
except:
return http.JsonResponse({'error':'手机号不正确'},status=400)
# 生成短信验证码
from random import randint
sms_code = '%06d' % randint(0,999999)
# 写入redis中
redis_conn = get_redis_connection('sms_code')
redis_conn.setex('sms_%s' % user_mobile,constants.SMS_CODE_REDIS_EXPIRES,sms_code)
# 异步发送短信
ccp_send_sms_code.delay(user_mobile,sms_code)
print("手机验证码是:", sms_code)
# 响应结果
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
def get(self, request, username):
sms_code = request.GET.get('sms_code')
try:
user = User.objects.get(username=username)
except:
return JsonResponse({}, status=400)
# 短信验证码
# 1.读取redis中的短信验证码
redis_cli = get_redis_connection('sms_code')
sms_code_redis = redis_cli.get(user.mobile)
# 2.判断是否过期
if sms_code_redis is None:
return HttpResponseForbidden('短信验证码已经过期')
# 3.删除短信验证码，不可以使用第二次
redis_cli.delete(user.mobile)
redis_cli.delete(user.mobile + '_flag')
# 4.判断是否正确
if sms_code_redis.decode() != sms_code:
return HttpResponseForbidden('短信验证码错误')
json_str = CookieSecret.dumps({
"user_id": user.id,
'mobile': user.mobile
})
return JsonResponse({'user_id': user.id, 'access_token': json_str})
def get(self, request):
# 接收token
access_token = request.GET.get('access_token')
# 解密
token = CookieSecret.loads(access_token)
# 验证token
user_id = token['user_id']
user_mobile = token['mobile']
try:
user = User.objects.get(id=user_id, mobile=user_mobile)
except:
return http.JsonResponse({'error': '数据错误'}, status=400)
# 生成短信验证码
sms_code = '%06d' % randint(0, 999999)
# 写入redis
redis_conn = get_redis_connection('sms_code')
redis_conn.setex('sms_%s' % user_mobile, 300, sms_code)
# 异步发送短信验证码
ccp_send_sms_code.delay(user_mobile, sms_code)
print("短信验证码是:", sms_code)
# 响应结果
return http.JsonResponse({'message': 'ok'})
def get(self, request, username):
# 接收参数
sms_code = request.GET.get('sms_code')
# 验证参数
try:
user = User.objects.get(username=username)
except:
return http.JsonResponse({'error': '数据错误'}, status=400)
redis_conn = get_redis_connection('sms_code')
redis_sms_code = redis_conn.get('sms_%s' % user.mobile)
if redis_sms_code is None:
return http.JsonResponse({'error': '数据错误'}, status=400)
if sms_code != redis_sms_code.decode():
return http.JsonResponse({'error': '数据错误'}, status=400)
# 加密token
access_token = CookieSecret.dumps({
'user_id': user.id,
'mobile': user.mobile
})
# 响应结果
return http.JsonResponse({
'user_id': user.id,
'access_token': access_token
})
def post(self, request, user_id):
# 接收参数
json_dict = json.loads(request.body.decode())
access_token = json_dict.get('access_token')
password = json_dict.get('password')
password2 = json_dict.get('password2')
# 校验参数
token = CookieSecret.loads(access_token)
user_mobile = token['mobile']
try:
user = User.objects.get(id=user_id, mobile=user_mobile)
except:
return http.JsonResponse({'error': '数据错误'}, status=400)
if not all([password, password2, access_token]):
return http.JsonResponse({'error': '数据错误'}, status=400)
if not re.match(r'^[0-9A-Za-z_]{8,20}', password):
return http.JsonResponse({'error': '数据错误'}, status=400)
if password != password2:
return http.JsonResponse({'error': '数据错误'}, status=400)
# 修改密码
user.set_password(password)
user.save()
# 响应结果
return http.JsonResponse({'message': 'ok'})
def get(self, request, username):
# 接收参数
uuid = request.GET.get('image_code_id')
image_code = request.GET.get('text')
# 校验参数
try:
user = User.objects.get(username=username)
except:
return http.JsonResponse({'error': '数据错误'}, status=400)
redis_conn = get_redis_connection('verify_image_code')
redis_image_code = redis_conn.get(uuid)
if redis_image_code is None:
return http.JsonResponse({'error': '数据错误'}, status=400)
if image_code.lower() != redis_image_code.decode().lower():
return http.JsonResponse({'error': '数据错误'}, status=400)
# 构造token
access_token = CookieSecret.dumps({
'user_id': user.id,
'mobile': user.mobile
})
# 响应结果
return http.JsonResponse({
'mobile': user.mobile,
'access_token': access_token
})
def get(self,request,username):
# 接收参数
sms_code = request.GET.get('sms_code')
print("用户输入的短信验证码:",sms_code)
# 取出用户对象信息，校验用户名是否正确
try:
user = User.objects.get(username=username)
except:
return http.JsonResponse({'error':'该用户不存在'},status=400)
# 校验参数
# 1 从redis中取出短信验证码
redis_conn = get_redis_connection('sms_code')
redis_sms_code = redis_conn.get('sms_%s' % user.mobile)
print("user.mobile",user.mobile)
print("redis取出来的短信验证码是：",redis_sms_code)
# 2 判断是否过期
if redis_sms_code is None:
return http.JsonResponse({'error':'验证过期了，再发送一次吧'}, status = 400)
# 3 删除Redis中的验证码
redis_conn.delete('sms_%s' % user.mobile)
# 4 判断短信验证码是否正确
if sms_code.lower() != redis_sms_code.decode().lower():
return http.JsonResponse({'error':'验证码错误'}, status = 400)
# 加密
json_str = CookieSecret.dumps({'user_id': user.id, 'mobile': user.mobile})
# 响应结果
return http.JsonResponse({'mobile': user.mobile, 'access_token': json_str})
def post(self,request,username):
# 接收参数
json_dict = json.loads(request.body.decode())
password = json_dict.get('password')
password2 = json_dict.get('password2')
access_token = json_dict.get('access_token')
# 校验参数
if not all([password,password2,access_token]):
return http.JsonResponse({'error':'数据错误'},status=400)
# 解密
token = CookieSecret.loads(access_token)
user_id = token['user_id']
user_mobile = token['mobile']
try:
user = User.objects.get(id=user_id,mobile=user_mobile)
except:
return http.JsonResponse({'error':'数据错误'},status=400)
if password != password2:
return http.JsonResponse({'error':'数据错误'},status=400)
# 修改密码
user.set_password(password)
user.save()
# 响应结果
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
def get(self, request):
# 判断用户是否登陆
user = request.user
if user.is_authenticated:
# 用户已登陆，查询Redis购物
carts_redis_client = get_redis_connection('carts')
carts_data = carts_redis_client.hgetall(user.id)
# 转换格式
cart_dict = {int(key.decode()): json.loads(value.decode()) for key,value in carts_data.items()}
else:
# 用户未登陆，查询cookie购物车
cart_str = request.COOKIES.get('carts')
if cart_str:
cart_dict = CookieSecret.loads(cart_str)
else:
cart_dict = {}
# 构造简单购物车JSON数据
cart_skus = []
sku_ids = cart_dict.keys()
skus = SKU.objects.filter(id__in=sku_ids)
for sku in skus:
cart_skus.append({
'id': sku.id,
'name': sku.name,
'count': cart_dict.get(sku.id).get('count'),
'default_image_url': sku.default_image.url
})
# 响应json列表数据
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'cart_skus': cart_skus})
def merge_cart_cookie_to_redis(request, response, user):
# 获取cookie_str
cookie_str = request.COOKIES.get('carts')
# 判断cookie_str是否有值
if cookie_str:
# 解密
cookie_dict = CookieSecret.loads(cookie_str)
else:
cookie_dict = {}
return response
# 获取redis
client_conn = get_redis_connection('carts')
client_data_dict = client_conn.hgetall(user.id)
redis_dict = {}
# 将取出的redis 二进制转换为普通字典
for key, value in client_data_dict.items():
sku_id = int(key.decode())
sku_dict = json.loads(value.decode())
redis_dict[sku_id] = sku_dict
# 合并redis和cookie
redis_dict.update(cookie_dict)
# 重新插入数据到redis
for sku_id in redis_dict:
client_conn.hset(user.id, sku_id, json.dumps(redis_dict[sku_id]))
# 删除cookie
response.delete_cookie('carts')
# 响应结果
return response
def post(self, request, user_id):
data = request.body.decode()
data_dict = json.loads(data)
password = data_dict.get('password')
password2 = data_dict.get('password2')
access_token = data_dict.get('access_token')
# 1.非空
if not all([access_token, password, password2, ]):
return HttpResponseForbidden('填写数据不完整')
if password != password2:
return HttpResponseForbidden('两个密码不一致')
user_dict = CookieSecret.loads(access_token)
if user_dict is None:
return JsonResponse({}, status=400)
if int(user_id) != user_dict['user_id']:
return JsonResponse({}, status=400)
try:
user = User.objects.get(id=user_id)
except:
return JsonResponse({}, status=400)
user.set_password(password)
user.save()
return JsonResponse({})
def get(self, request):
user = request.user
if user.is_authenticated:
# 链接ｒｅｄｉｓ数据库
client = get_redis_connection("carts")
# 取出所有商品数据
carts_data = client.hgetall(user.id)
# 转换格式
cart_dict = {
int(key.decode()): json.loads(value.decode())
for key, value in carts_data.items()
}
else:
carts_str = request.COOKIES.get("carts")
if carts_str:
cart_dict = CookieSecret.loads(carts_str)
else:
cart_dict = {}
cart_skus = []
sku_ids = cart_dict.keys()
skus = SKU.objects.filter(id__in=sku_ids)
for sku in skus:
cart_skus.append({
'id': sku.id,
'name': sku.name,
'count': cart_dict.get(sku.id).get('count'),
'default_image_url': sku.default_image.url
})
return http.JsonResponse({
'code': RETCODE.OK,
'errmsg': 'OK',
'cart_skus': cart_skus
})
def get(self, request):
code = request.GET.get('code')
client = sinaweibopy3.APIClient(app_key=settings.APP_KEY,
app_secret=settings.APP_SECRET,
redirect_uri=settings.REDIRECT_URL)
# 1.根据code获取access_token
result = client.request_access_token(code)
client.set_access_token(result.access_token, result.expires_in)
openid = result.uid
print('openid={}'.format(openid))
# 判断是否初次授权
try:
qquser = OAuthSinaUser.objects.get(uid=openid)
except:
# 未查到数据，则为初次授权，显示绑定页面
# 将openi加密
json_str = CookieSecret.dumps(openid)
# 显示绑定页面
context = {'openid': json_str}
return render(request, 'oauth_callback.html', context)
# 查询到授权对象，则状态保持，转到相关页面
user = qquser.user
login(request, user)
response = redirect(reverse('contents:index'))
response.set_cookie('username', user.username)
return response
def merge_cart_cookie_to_redis(request, response):
"""
登录后合并cookie购物车数据到Redis
:param request: 本次请求对象，获取cookie中的数据
:param response: 本次响应对象，清除cookie中的数据
:return: response
"""
# 查询ｃｏｏｋｉｅ将ｃｏｏｋｉｅ中的数据都提取出来
cookie_str = request.COOKIES.get("carts")
# 判断ｃｏｏｋｉｅ里是否有数据
if cookie_str:
# 连接ｒｅｄｉｓ数据库
client = get_redis_connection("carts")
# 将取出来的ｃｏｏｋｉｅ数据解密
cookie_dict = CookieSecret.loads(cookie_str)
# 覆盖ｒｅｄｉｓ里的数据
for sku_id in cookie_dict.keys():
client.hset(request.user.id, sku_id,
json.dumps(cookie_dict[sku_id]))
# 删除ｃｏｏｋｉｅ
response.delete_cookie("carts")
def put(self, request):
# 1.接收参数
selected = json.loads(request.body.decode()).get('selected', True)
# 2.校验 seleted bool
# 3.是否登录
user = request.user
if user.is_authenticated:
# redis
# 1.链接
carts_redis_client = get_redis_connection('carts')
# 2. hgetall
carts_data = carts_redis_client.hgetall(user.id)
# 3. 遍历修改每一个字典
for data in carts_data.items():
sku_id = data[0].decode()
sku_dict = json.loads(data[1].decode())
# 判断 全选
if selected:
sku_dict['selected'] = True
else:
sku_dict['selected'] = False
carts_redis_client.hset(user.id, sku_id, json.dumps(sku_dict))
return JsonResponse({'code': RETCODE.OK, 'errmsg': '全选购物车成功'})
else:
# cookie
cookie_str = request.COOKIES.get('carts')
response = JsonResponse({'code': RETCODE.OK, 'errmsg': '全选购物车成功'})
if cookie_str is not None:
carts_dict = CookieSecret.loads(cookie_str)
for sku_id in carts_dict:
carts_dict[sku_id]['selected'] = selected
cookie_secret_str = CookieSecret.dumps(carts_dict)
response.set_cookie('carts',
cookie_secret_str,
max_age=24 * 30 * 3600)
return response
def delete(self, request):
'''
删除 购物车
:param request:
:return:
'''
# 1.0 接收参数
json_dict = json.loads(request.body.decode())
sku_id = json_dict.get('sku_id')
# 2.0 校验
try:
SKU.objects.get(id=sku_id)
except SKU.DoesNotExist:
return HttpResponseForbidden('商品不存在')
# 3.0 判断 是否登录
user = request.user
if user is not None and user.is_authenticated:
# 3.1 用户登录 redis
# 3.1.1 链接redis
carts_redis_client = get_redis_connection('carts')
# 3.1.2 删除 根据用户id 删除商品sku
carts_redis_client.hdel(user.id, sku_id)
# 3.1.3 删除结束后，没有响应的数据，只需要响应状态码即可
return JsonResponse({'code': RETCODE.OK, 'errmsg': '删除购物车成功'})
else:
# 3.2 cookie
# 3.2.1 获取 cookie
cart_str = request.COOKIES.get('carts')
# 3.2.2 如果存在解密
if cart_str:
cart_dict = CookieSecret.loads(cart_str)
else:
cart_dict = {}
# 4.0 创建响应对象
response = JsonResponse({'code': RETCODE.OK, 'errmsg': '删除购物车成功'})
# 4.1循环便利
if sku_id in cart_dict:
# 4.2 删除数据
del cart_dict[sku_id]
# 4.3 将字典转成密文
cookie_cart_str = CookieSecret.dumps(cart_dict)
# 响应结果并将购物车数据写入到cookie
response.set_cookie('carts',
cookie_cart_str,
max_age=constants.CARTS_COOKIE_EXPIRES)
return response
def get(self,request):
# 判断用户是否登录
user = request.user
if user.is_authenticated:
# 登录 操作redis
redis_conn = get_redis_connection('carts')
# 取出该用户所有购物车数据
redis_data = redis_conn.hgetall(user.id)
# 转换格式
carts_dict = {}
for key,value in redis_data.items():
sku_id = int(key.decode())
sku_value = json.loads(value.decode())
carts_dict[sku_id] = sku_value
else:
# 未登录 操作cookie
# 取出cookie_str
cookie_str = request.COOKIES.get('carts')
# 判断是否有购物车数据
if cookie_str:
# 解密
carts_dict = CookieSecret.loads(cookie_str)
else:
# 空字典
carts_dict = {}
# 取出所有的sku_id 键
sku_ids = carts_dict.keys()
# 构造前端需要的数据
cart_skus = []
# 取出当前商品信息
skus = SKU.objects.filter(id__in = sku_ids)
# 遍历取数据
for sku in skus:
cart_skus.append({
'id': sku.id,
'name': sku.name,
'count': carts_dict.get(sku.id).get('count'),
'selected': str(carts_dict.get(sku.id).get('selected')), # 将True，转'True'，方便json解析
'default_image_url': sku.default_image.url,
'price': str(sku.price), # 从Decimal('10.2')中取出'10.2'，方便json解析
'amount': str(sku.price * carts_dict.get(sku.id).get('count')),
})
context = {
'cart_skus':cart_skus,
}
return render(request,'cart.html',context)
def get(self, request):
'''
展示购物车
:param request:
:return:
'''
user = request.user
if user.is_authenticated:
# 1.用户已登录，查询redis购物车
carts_redis_client = get_redis_connection('carts')
# 2.获取当前用户的 所有购物车数据
carts_data = carts_redis_client.hgetall(request.user.id)
# 3.转换格式-->和cookie一样的字典 方便后面构建数据
carts_dict = {
int(data[0].decode()): json.loads(data[1].decode())
for data in carts_data.items()
}
else:
# 用户未登录，查询cookies购物车
cookie_str = request.COOKIES.get('carts')
if cookie_str:
carts_dict = CookieSecret.loads(cookie_str)
else:
carts_dict = {}
sku_ids = carts_dict.keys()
skus = SKU.objects.filter(id__in=sku_ids)
cart_skus = []
for sku in skus:
cart_skus.append({
'id':
sku.id,
'name':
sku.name,
'count':
carts_dict.get(sku.id).get('count'),
'selected':
str(carts_dict.get(
sku.id).get('selected')), # 将True，转'True'，方便json解析
'default_image_url':
sku.default_image.url,
'price':
str(sku.price), # 从Decimal('10.2')中取出'10.2'，方便json解析
'amount':
str(sku.price * carts_dict.get(sku.id).get('count')),
})
context = {
'cart_skus': cart_skus,
}
# 渲染购物车页面
return render(request, 'cart.html', context)
def delete(self, request):
# 接收参数
sku_id = json.loads(request.body.decode()).get("sku_id")
# 校验
try:
SKU.objects.get(id=sku_id)
except:
return http.HttpResponseForbidden("商品不存在")
user = request.user
# 判断是否登陆
if user.is_authenticated:
# 删除redis里的数据
# 链接redis数据库
client = get_redis_connection("carts")
# 查询数据库所有数据
# 删除数据库该商品
client.hdel(user.id, sku_id)
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '删除购物车成功'})
else:
# 删除cookie里的数据
# 获得指定的cookie
carts_str = request.COOKIES.get("carts")
# 解密 获得字典
try:
carts_dict = CookieSecret.loads(carts_str)
except:
carts_dict = {}
# 删掉对应的商品
if sku_id in carts_dict.keys():
del carts_dict[sku_id]
# 将字典转成密文
cookie_cart_str = CookieSecret.dumps(carts_dict)
response = http.JsonResponse({
'code': RETCODE.OK,
'errmsg': '删除购物车成功'
})
response.set_cookie("carts",
cookie_cart_str,
max_age=14 * 24 * 3600)
return response
def put(self, request):
# 1.接收参数
json_dict = json.loads(request.body.decode())
sku_id = json_dict.get('sku_id')
count = json_dict.get('count')
selected = json_dict.get('selected', True)
# 2.校验--省略
try:
sku = SKU.objects.get(pk=sku_id)
except:
return render(request, '404.html')
# 3.判断是否登录
user = request.user
dumps_str = ""
if user.is_authenticated:
# redis
client = get_redis_connection('carts')
new_sku = {'count': count, 'selected': selected}
client.hset(user.id, sku_id, json.dumps(new_sku))
else:
# cookie
# 1.获取 所有购物车 数据 cookie
cookie_str = request.COOKIES.get('carts')
# 2.判断是否有 --有--解密
if cookie_str:
cart_dict = CookieSecret.loads(cookie_str)
else:
cart_dict = {}
# 3. 整体覆盖
cart_dict[sku_id] = {'count': count, 'selected': selected}
# 4.加密
dumps_str = CookieSecret.dumps(cart_dict)
response = get_response(sku, count, selected)
if not user.is_authenticated:
response.set_cookie('carts', dumps_str, max_age=24 * 3600 * 30)
return response
def put(self, request):
# 1.接收参数
selected = json.loads(request.body.decode()).get('selected', True)
# 2.校验参数--判断selected是否有值
if selected:
if not isinstance(selected, bool):
return http.HttpResponseForbidden('参数selected有误')
# 3.判断是否登录
response = http.JsonResponse({'code': RETCODE.OK, 'errmsg': '全选购物车成功'})
user = request.user
if user.is_authenticated:
redis_client = get_redis_connection('carts')
redis_client_data = redis_client.hgetall(user.id)
# 遍历每一个商品 修改选中状态
for key, value in redis_client_data.items():
sku_id = int(key.decode())
cart_dict = json.loads(value.decode())
# 统一修改所有的选中状态
cart_dict['selected'] = selected
# 改完之后重新赋值
redis_client.hset(user.id, sku_id, json.dumps(cart_dict))
else:
cookie_str = request.COOKIES.get('carts')
if cookie_str is not None:
cart_dict = CookieSecret.loads(cookie_str)
for sku_id in cart_dict:
cart_dict[sku_id]['selected'] = selected
# 加密
dumps_cookie_str = CookieSecret.dumps(cart_dict)
response.set_cookie('carts',
dumps_cookie_str,
max_age=24 * 15 * 3600)
# 4.返回响应对象
return response
