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 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 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 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 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): # 接收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 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 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 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 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 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): # 接收参数 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): # 判断用户是否登录 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 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 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 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 get(self, request): user = request.user if user.is_authenticated: # 连接redis client = get_redis_connection('carts') # redis取 carts_data = client.hgetall(request.user.id) # 转换格式-->和cookie一样的字典 方便后面构建数据 # cart_dict = {} # for key, value in carts_data.items(): # sku_id = int(key.decode()) # sku_dict = json.loads(value.decode()) # cart_dict[sku_id] = sku_dict carts_dict = { int(k.decode()): json.loads(v.decode()) for k, v in carts_data.items() } else: # 从cookie取 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 get(self, request): # 判断用户是否登录 user = request.user if user.is_authenticated: # 如果用户登录 操作redis # 1 连接redis clident_conn = get_redis_connection('carts') # 2 获取当前用户的redis数据 redis_dict = clident_conn.hgetall(user.id) # 3 转换成普通字典 carts_dict = {} for key, value in redis_dict.items(): stu_id = int(key.decode()) stu_dict = json.loads(value.decode()) carts_dict[stu_id] = stu_dict else: # 如果用户没登录 操作cookie # 1 接收cookie_str cookie_str = request.COOKIES.get('carts') # 2 判断是否有cookie_str if cookie_str: # 2.1 解密 carts_dict = CookieSecret.loads(cookie_str) else: # 2.2 空字典 carts_dict = {} # 构造简单的购物车json数据 cart_skus = [] # 获取键 sku_ids = carts_dict.keys() # 根据键获取表中商品信息 # skus = SKU.objects.filter(id__in = sku_ids) # 遍历商品信息 for sku_id in sku_ids: sku = SKU.objects.get(id=sku_id) cart_skus.append({ 'id': sku.id, 'name': sku.name, 'count': carts_dict.get(sku.id).get('count'), 'default_image_url': sku.default_image.url, }) # 响应json列表数据 return http.JsonResponse({ 'code': RETCODE.OK, 'errmsg': 'OK', 'cart_skus': cart_skus })
def get(self, request): """购物车展示""" user = request.user # 判断用户是否登陆 if user.is_authenticated: # 登陆 则返回 redis中的数据 # 链接数据库 carts_redis_client = get_redis_connection('carts') # 根据用户 user.id 获取用户的购物车数据 carts_data = carts_redis_client.hgetall(user.id) # 因为获取的数据都是bytes 类型,所以需要先转换类型 carts_dict = { int(sku[0].decode()): json.loads(sku[1].decode()) for sku in carts_data.items() } else: # 未登录返回 cookie 中的数据 cookie_data = request.COOKIES.get('carts') # 判断获取的值是否有数据 if cookie_data: # 获取道德数据进行解密 carts_dict = CookieSecret.loads(cookie_data) else: # 没有则赋值为空 carts_dict = {} # 获取 carts_dict 中的商品数据 sku_ids = carts_dict.keys() # 获取所有的 商品 sku 信息 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 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 merge_cart_cookie_to_redis(request, response): # 1.获取 cookie 所有数据 cookie_str = request.COOKIES.get('carts') # 2.如果有值--解密 if cookie_str: cookie_cart_dict = CookieSecret.loads(cookie_str) # 3.链接redis数据库 client = get_redis_connection('carts') # 4.遍历数据 -- 覆盖 redis的值 {'sku_id':{count:}} for sku_id, sku_value in cookie_cart_dict.items(): client.hset(request.user.id, sku_id, json.dumps(sku_value)) # 5.删除cookie的 购物车数据 response.delete_cookie('carts')
def get(self,request): # 判断用户是否登录 user = request.user if user.is_authenticated: # 如果用户登录 操作redis # 连接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 cookie_str = request.COOKIES.get('carts') # 判断 if cookie_str: # 解密 carts_dict = CookieSecret.loads(cookie_str) else: # 空字典 carts_dict = {} cart_skus = [] # 取出所有的键 sku_ids = carts_dict.keys() # 查询所有商品 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'), 'default_image_url':sku.default_image.url, }) # 响应结果 return http.JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'cart_skus': cart_skus})
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: client = get_redis_connection("carts") carts_data = client.hgetall(user.id) carts_dict = {} for key, value in carts_data.items(): sku_id = int(key.decode()) sku_dict = json.loads(value.decode()) carts_dict[sku_id] = sku_dict else: cookie_str = request.COOKIES.get("carts") if cookie_str: carts_dict = CookieSecret.loads(cookie_str) carts_dict = {} sku_ids = carts_dict.keys() skus = SKU.objects.filter(id__in=sku_ids) carts_skus = [] for sku in skus: carts_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': carts_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