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: # 查询redis数据库 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: # 找到指定cookie carts_str = request.COOKIES.get("carts") # 判断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") # 覆盖redis以前所有数据 new_data = {"count": count, "selected": selected} redis_client.hset(user.id, sku_id, json.dumps(new_data)) else: # 修改cookie # 指定cookie cart_str = request.COOKIES.get("carts") if cart_str: # 将cookie中的数据解密 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: # 链接redis数据库 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将cookie中的数据都提取出来 cookie_str = request.COOKIES.get("carts") # 判断cookie里是否有数据 if cookie_str: # 连接redis数据库 client = get_redis_connection("carts") # 将取出来的cookie数据解密 cookie_dict = CookieSecret.loads(cookie_str) # 覆盖redis里的数据 for sku_id in cookie_dict.keys(): client.hset(request.user.id, sku_id, json.dumps(cookie_dict[sku_id])) # 删除cookie 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