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): 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 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 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 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 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 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 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): # 接收参数 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 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): # 接收参数 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 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 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
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 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 delete(self, request): # 接收参数 json_dict = json.loads(request.body.decode()) sku_id = json_dict.get('sku_id') # 判断sku_id是否存在 try: models.SKU.objects.get(id=sku_id) except models.SKU.DoesNotExist: return http.HttpResponseForbidden("商品不存在") # 判断用户是否登录 user = request.user if user is not None and user.is_authenticated: # 用户已登陆,删除redis购物车 carts_redis_client = get_redis_connection('carts') carts_redis_client.hdel(user.id, sku_id) # 删除结束后,没有响应的数据,只需要响应状态码即可 return JsonResponse({'code': RETCODE.OK, 'errmsg': '删除购物车成功'}) else: # 用户未登陆,删除cookie购物车 cart_str = request.COOKIES.get('carts') if cart_str: # 转成明文 cart_dict = CookieSecret.loads(cart_str) else: cart_dict = {} # 创建响应对象 response = JsonResponse({'code': RETCODE.OK, 'errmsg': "删除购物车成功"}) if sku_id in cart_dict: # 删除数据 del cart_dict[sku_id] # 将字典转成密文 cookie_cart_str = CookieSecret.dumps(cart_dict) # 响应结果并将购物车数据写入到cookie response.set_cookie('carts', cookie_cart_str, max_age=24 * 30 * 3600) return response
def delete(self, request): # 1.接收 sku_id sku_id = json.loads(request.body.decode()).get('sku_id') try: sku = SKU.objects.get(pk=sku_id) except: return render(request, '404.html') # 2.判断是否登录 user = request.user dumps_str = "" if user.is_authenticated: # redis # 1.链接数据库 client = get_redis_connection('carts') # 2.删除 client.hdel(user.id, sku_id) else: # cookie cookie_str = request.COOKIES.get('carts') if cookie_str: cart_dict = CookieSecret.loads(cookie_str) # 判断 sku_id 在在不在 购物车 if sku_id in cart_dict: del cart_dict[sku_id] # 加密 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) # 返回JSon return response
def delete(self, request): """删除购物车""" # 接受参数 json_dict = json.loads(request.body.decode()) sku_id = json_dict.get('sku_id') # 判断 sku_id 是否存在 try: models.SKU.objects.get(id=sku_id) except models.SKU.DoesNotExist: return http.HttpResponseForbidden('商品不存在') # 判断用户是否登陆 user = request.user if user is not None and user.is_authenticated: # 用户登录,删除redis购物车 client = get_redis_connection('carts') # 根据用户id 删除商品sku client.hdel(user.id, sku_id) # 删除结束后,没有响应的数据,只需要响应状态码即可 return http.JsonResponse({'code': 0, 'errmsg': '删除购物车成功'}) else: # 用户未登录,删除cookie购物车 cart_str = request.COOKIES.get('carts') if cart_str: # 解密 cart_dict = CookieSecret.loads(cart_str) else: cart_dict = {} # 创建响应对象 response = http.JsonResponse({'code': 0, 'errmsg': '删除购物车成功'}) if sku_id in cart_dict: # 删除数据 del cart_dict[sku_id] # 加密 cart_str = CookieSecret.dumps(cart_dict) # 响应结果并将购物车数据写入到cookie response.set_cookie('carts', cart_str, max_age=24 * 30 * 3600) return response
def put(self, request): # 接收参数 json_dict = json.loads(request.body.decode()) selected = json_dict.get('selected', True) # 校验参数 if selected: if not isinstance(selected, bool): return http.HttpResponseForbidden('参数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': 0, 'errmsg': '全选购物车成功'}) else: # 用户未登录,操作cookie购物车 carts_str = request.COOKIES.get('carts') response = http.JsonResponse({'code': 0, 'errmsg': '全选购物车成功'}) 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=14 * 24 * 3600) return response
def delete(self, request): """删除购物车""" # 接收参数 sku_id = json.loads(request.body.decode()).get('sku_id') # 判断商品是否存在 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_client.hdel(user.id, sku_id) return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '删除购物车成功'}) else: # 操作 cookie cookie_str = request.COOKIES.get('carts') # 判断是否有数据 if cookie_str: cookie_dict = CookieSecret.loads(cookie_str) else: cookie_dict = {} # 创建相应对象 response = http.JsonResponse({ 'code': RETCODE.OK, 'errmsg': '删除购物车成功' }) # 如果sku_id 存在则删除 if sku_id in cookie_dict: del cookie_dict[sku_id] cookie_secret = CookieSecret.dumps(cookie_dict) response.set_cookie('carts', cookie_secret, max_age=14 * 24 * 3600) return response
def delete(self, request): # 1.接收参数 sku_id = json.loads(request.body.decode()).get('sku_id') # 2.校验参数 # 判断sku_id是否存在 try: sku = SKU.objects.get(id=sku_id) except SKU.DoesNotExist: return http.HttpResponseForbidden('商品不存在') # 3.判断是否登录 response = http.JsonResponse({'code': RETCODE.OK, 'errmsg': '删除购物车成功'}) user = request.user if user.is_authenticated: # redis redis_client = get_redis_connection('carts') redis_client.hdel(user.id, sku_id) else: # cookie cookie_str = request.COOKIES.get('carts') if cookie_str: cart_dict = CookieSecret.loads(cookie_str) else: cart_dict = {} # 判断sku_id是否在字典里,不在删除会挂 if sku_id in cart_dict: del cart_dict[sku_id] # 删完的字典重新加密转成string dumps_cookie_str = CookieSecret.dumps(cart_dict) response.set_cookie('carts', dumps_cookie_str, max_age=24 * 15 * 3600) return response
def delete(self, request): # 1.接收参数 sku_id = json.loads(request.body.decode()).get('sku_id') # 2. 校验 sku # 3. 是否登录 user = request.user if user.is_authenticated: # redis # 1.链接 cart_redis_client = get_redis_connection('carts') # 2. hdel删除 cart_redis_client.hdel(user.id, sku_id) return 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 = JsonResponse({'code': RETCODE.OK, 'errmsg': '删除购物车成功'}) if sku_id in carts_dict: # 1.删除 del carts_dict[sku_id] # 2.加密 carts_secret_str = CookieSecret.dumps(carts_dict) # 3.set_cookie response.set_cookie('carts', carts_secret_str, max_age=30 * 24 * 3600) return response
def get(self,request,username): # 接收参数 (图形验证码) uuid = request.GET.get('image_code_id') image_code = request.GET.get('text') print("用户名:",username) print("用户输入的验证码:",image_code) # 连接redis数据库取出验证码 redis_conn = get_redis_connection('verify_image_code') redis_image_code = redis_conn.get('img_%s' % uuid) print(redis_image_code) # 校验验证码是否过期 if redis_image_code is None: return http.JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图形验证码已过期,点击图片换一个'}) # 立即删除redis中的图形验证码 redis_conn.delete('img_%s' % uuid) # 判断用户输入的验证码是否正确 if image_code.lower() != redis_image_code.decode().lower(): return http.JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图形验证码错误'}) # 校验用户名是否存在 try: user = User.objects.get(username=username) except: return http.JsonResponse({}, status=404) print("该用户的手机号:",user.mobile) # 加密 json_str = CookieSecret.dumps({'user_id':user.id,'mobile':user.mobile}) # 响应结果 return http.JsonResponse({'mobile': user.mobile, 'access_token': json_str})
def get(self, request, username): # 接收 uuid = request.GET.get('image_code_id') image_code = request.GET.get('text') # 2.图形验证码是否正确 # 2.1从redis中读取之前保存的图形验证码文本 redis_cli_image = get_redis_connection('verify_image_code') image_code_redis = redis_cli_image.get('img_%s' % uuid) # 2.2如果redis中的数据过期则提示 if image_code_redis is None: return JsonResponse({ 'code': RETCODE.IMAGECODEERR, 'errmsg': '图形验证码已过期,点击图片换一个' }) # 2.3立即删除redis中图形验证码,表示这个值不能使用第二次 redis_cli_image.delete(uuid) # 2.3对比图形验证码:不区分大小写 if image_code_redis.decode().lower() != image_code.lower(): return JsonResponse({ 'code': RETCODE.IMAGECODEERR, 'errmsg': '图形验证码错误' }) try: user = User.objects.get(username=username) except: return JsonResponse({}, status=404) # 处理 json_str = CookieSecret.dumps({ "user_id": user.id, 'mobile': user.mobile }) return JsonResponse({'mobile': user.mobile, 'access_token': json_str})
def post(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", True) # 校验 if not all([sku_id, count]): return http.HttpResponseForbidden('缺少必传参数') # 判断sku_id是否存在 try: sku = SKU.objects.get(id=sku_id) except Exception as e: return http.HttpResponseForbidden('商品不存在') # 判断count是否是数字 try: count = int(count) except: return http.HttpResponseForbidden('参数count有误') # 判断selected是否为bool值 if selected: if not isinstance(selected, bool): return http.HttpResponseForbidden('参数selected有误') # 判断用户是否登录 if request.user.is_authenticated(): # 以登录就用redis存储 # 链接redis数据库 cenlit = get_redis_connection('carts') # 获取以前数据库的值 cenlit_data = cenlit.hgetall(request.user.id) if str(sku_id).encode() in cenlit_data: # 根据sku_id 取出商品 child_dict = json.loads( cenlit_data[str(sku_id).encode()].decode()) # 个数累加 child_dict["count"] += count # 更新数据 cenlit.hset(request.user.id, sku_id, json.dumps(child_dict)) else: # 如果商品已经不存在--直接增加商品数据 cenlit.hset(request.user.id, sku_id, json.dumps({ 'count': count, 'selected': selected })) return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '添加购物车成功'}) else: # 未登录就用cooike存储 carts_str = request.COOKIES.get("carts") # 如果用户操作过cookie购物车 if carts_str: # 解密出明文 carts_dict = CookieSecret.loads(carts_str) else: carts_dict = {} # 判断要加入购物车的商品是否已经在购物车中,如有相同商品,累加求和,反之,直接赋值 if sku_id in carts_dict: # 累加求和 origin_count = carts_dict[sku_id]["count"] count += origin_count carts_dict[sku_id] = { "count": count, "selected": selected, } carts_dict_str = CookieSecret.dumps(carts_dict) response = http.JsonResponse({ 'code': RETCODE.OK, 'errmsg': '添加购物车成功' }) # 响应结果并将购物车数据写入到cookie response.set_cookie('carts', carts_dict_str, max_age=24 * 30 * 3600) return response
def post(self, request): # - 1.接收前端传递的参数 sku_id count selected --- 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,count 是 init, selected boolean try: sku = SKU.objects.get(pk=sku_id) except: return render(request, '404.html') try: count = int(count) except: return http.HttpResponseForbidden('count 类型必须是数字') if not isinstance(selected, bool): return http.HttpResponseForbidden('selected 类型必须是布尔类型') # - 3.判断是否登录 user.is_authenticated user = request.user response = http.JsonResponse({'code': 0, 'errmsg': '购物车添加成功'}) if user.is_authenticated: # - 1.链接数据库 redis client = get_redis_connection('carts') # - 2.获取当前用户 所有 购物车数据 --hgetall ==> dict redis_carts = client.hgetall(user.id) # - 3.判断 当前 sku商品 在不在购物车 # {b'5':b'{count:1,selected:true}'} if str(sku_id).encode() in redis_carts: # - 如果在 : count += count---hset # 取出 dict中 b'{count:1,selected:true}' bytes_dict = redis_carts[str(sku_id).encode()] # 将 bytes==>str json_str = bytes_dict.decode() # 将 str ==> dict sku_dict = json.loads(json_str) sku_dict['count'] += count client.hset(user.id, sku_id, json.dumps(sku_dict)) else: # 不存在: 新添加数据 hset new_sku = {'count': count, 'selected': selected} client.hset(user.id, sku_id, json.dumps(new_sku)) else: print('未登录状态') # - 1.从cookie取出 购物车的数据--request.COOKIES carts_str = request.COOKIES.get('carts') # - 2.判断 如果有值 --- 解码--解密 if carts_str: cart_dict = CookieSecret.loads(carts_str) else: cart_dict = {} # - 3.判断 商品 sku_id 在购物车 --将 老的购买个数 和 新的购买个数 sum求和 if sku_id in cart_dict: origin_count = cart_dict[sku_id]['count'] count = origin_count + count # - 4.无论是否有 购物车的 商品--都赋值 cart_dict[sku_id] = {'count': count, 'selected': selected} # 5. 加密--cookie dumps_str = CookieSecret.dumps(cart_dict) response.set_cookie('carts', dumps_str, max_age=24 * 3600 * 30) return response