购物车

Posted 2021-01-22 xdlzs

from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from course import models
from utils.authentication import MyAuth #认证
from utils.base_response import BaseResponse #记录错误信息
import redis  #放内存
from  utils.redis_pool import POOL #连接池
import json

#用于存放内存的格式
SHOPPING_CAR_KEY=‘shopping_car_%s_%s‘
REDIS_CONN=redis.Redis(connection_pool=POOL)


"""
shopping_car_ %s_ %s: {   #传当前用户的id 和课程id
    id: 1,
    title: CMDB,
    course_img: xxxxx,
    price_policy_dict: {
        1: {有效期1个月， 99}

      }，
    default_price_policy_id: 3  #选中的当前的价格id

}

"""
                          
#购物车接口
class ShoppingCarView(APIView):
    #认证
    authentication_classes=[MyAuth,]
    #加入购物车
    def post(self,request):
        ret=BaseResponse()
        try:
            #1. 获取当前的前端传过来的course_id ,price_policy_id,user_id
            course_id=request.data.get(‘course_id‘,‘‘)
            price_policy_id=request.data.get(‘price_policy_id‘,‘‘)
            user_id=request.user.id
            #2. 验证course_id 是否合法
            course_obj=models.Course.objects.filter(id=course_id).first()
            if not course_obj :
                ret.code=1031
                ret.error=‘课程不存在‘
                return Response(ret.dict)
            #3.验证价格策略是否合法
            #找到该课程的所有的价格策略对象
            price_policy_queryset=course_obj.price_policy.all()
            #循环 每个价格的详细信息 以字典形式构建
            price_policy_dict={}
            for price_policy_obj in price_policy_queryset:
                price_policy_dict[price_policy_obj.id]={
                    #显示汉字
                    ‘valid_period_text‘:price_policy_obj.get_valid_period_display(),
                    ‘price‘:price_policy_obj.price
                }
            #判断价格策略是否在字典里
            if price_policy_id not in price_policy_dict:
                ret.code=1032
                ret.error=‘价格策略不存在‘
                return  Response(ret.dict)
            #4. 构建要存放内存的数据结构
            course_info={
                ‘id‘:course_id,
                ‘title‘:course_obj.title,
                # ‘course_img‘: course_obj.course_img,
                ‘price_policy_dict‘:json.dumps(price_policy_dict,ensure_ascii=False),
                ‘default_policy_id‘:price_policy_id
            }
             #5.写入 redis
            #先写 购物车的key
            shopping_car_key=SHOPPING_CAR_KEY %(user_id,course_id)
            #写入 redis
            REDIS_CONN.hmset(shopping_car_key,course_info)
            ret.data=‘加入购物车成功‘
        except Exception as e:
            ret.code=1030
            ret.error=‘加入购物车失败‘
        return Response(ret.dict)
    #显示购物车
    def get(self,request):
        ret=BaseResponse()
        try:
            #取到当前用户的id
            user_id=request.user.id
            #拼接购物车的key
            shopping_car_key=SHOPPING_CAR_KEY %(user_id,‘*‘)
            # shopping_car_1_*
            # shopping_car_1_asdgnlaksdj
            # 3 去redis读取该用户的所有加入购物车的课程
            # 3.1 先去模糊匹配出所有符合要求的key  .scan_iter模糊匹配
            all_keys=REDIS_CONN.scan_iter(shopping_car_key)
            #循环所有的keys
            shopping_car_list=[]
            for key in all_keys:
                course_info=REDIS_CONN.hgetall(key)
                course_info[‘price_policy_dict‘]=json.loads(course_info[‘price_policy_dict‘])
                shopping_car_list.append(course_info)
            ret.data=shopping_car_list
        except Exception as e:
            ret.code=1033
            ret.error="获取购物车失败"
        return Response(ret.dict)

    #更新 购物车
    def put(self,request):
        ret=BaseResponse()
        try:
            #获取当前的course_id ,user_id及price_policy_id
            course_id=request.data.get(‘course_id‘,‘‘)
            price_policy_id=request.data.get(‘price_policy_id‘,‘‘)
            user_id=request.user.id
            #校验course_id 是否合法
            shopping_car_key=SHOPPING_CAR_KEY %(user_id,course_id)
            if not REDIS_CONN.exists(shopping_car_key):
                ret.code=1035
                ret.error=‘课程不存在‘
                return Response(ret.dict)
            #判断价格是否合法
            course_info=REDIS_CONN.hgetall(shopping_car_key)
            price_policy_dict=json.loads(course_info["price_policy_dict"])
            #前端传来的都是字符串  用str
            if str(price_policy_id) not in price_policy_dict:
                ret.code=1036
                ret.error=‘所选价格策略不存在‘
                return Response(ret.dict)
            #修改redis中的default_policy_id
            course_info[‘price_policy_id‘]=price_policy_id
            # 4 修改信息后写入redis
            REDIS_CONN.hmset(shopping_car_key,course_info)
            ret.data=‘更新成功‘
        except Exception as e:
            ret.code=1034
            ret.error=‘更新价格策略失败‘
        return Response(ret.dict)

    #删除  购物车
    def delete(self,request):
        ret=BaseResponse()
        try:
            #找到删除的course_id ,user_id
            course_id=request.data.get(‘course_id‘,‘‘)
            user_id=request.user.id
            #判断id是否合法
            shopping_car_keys=SHOPPING_CAR_KEY %(user_id,course_id)
            if not REDIS_CONN.exists(shopping_car_keys):
                ret.code=1039
                ret.error="删除的课程不存在"
                return Response(ret.dict)
            #删除redis中的数据
            REDIS_CONN.delete(shopping_car_keys)
            ret.data=‘删除成功‘
        except Exception as e:
            ret.code=1037
            ret.error=‘删除失败‘
        return Response(ret.dict)