路飞学城项目-支付相关-购物车接口

"""
支付相关的需求：
购物车需求：
1，在课程详情页面，点击加入购物车可以把课程加入到购物车
2，点击导航条的购物车按钮可以进入购物车页面
3，在购物车页面点击删除可以把购物车删除，
4，点击购物车的有效期，可以更改价格策略，然后去购物车的数据进行修改，
5，点击购物车底部左侧的全选，可以全选，然后全选按钮旁边有删除，可以批量删除，
6，购物车底部右侧的有全部的金额合计，右侧有一个去结算按钮，点击可以到结算页面
实现购物车的新增，删除，修改，查询，


结算需求：
1，结算页面的价格策略是不能修改的，但是可以选择优惠券，使用贝里，
2，优惠券分为两种一种是绑定课程的和课程在一栏，没有绑定课程的是通用优惠券，在底部可以选择，
3，结算页面右下角显示使用优惠券之后的价格，显示使用贝里之后的价格，
4，最下面显示支付方式，应付金额，和立即支付按钮，点击按钮可以进入支付流程，
实现结算信息的新增，查看，修改，没有删除，你回去购物车之后就把结算信息情况了，可以再次新增，


支付需求：
1，点击立即支付进入支付流程，需要生成订单，然后调支付宝接口，
2，支付成功之后调回调接口，修改订单的状态，但是没有这么简单，
2.1修改订单的状态
2.2有优惠券修改优惠券的状态
2.2使用了贝里需要修改贝里的金额，
2.3你买的如果是普通课程，你就可以看了，如果是学位课，你要开通模块，配备老师，


技术使用redis数据库，
原因有两个
1，购物车和结算是临时状态，
2，需要频繁的修改购物车信息，



"""

"""

购物车的设计思路：
一，需要保持什么字段

1，用户id
2，课程名称，图片，
3，价格策略：你需要这个课程的价格策略都取出来，
    3.1 id
    3.2 有效期，
    3.3 价格
4，默认选中的价格策略，

二，数据结构
注意，redis只允许有一层字典结构，所以多余一层的，需要进行序列化，变成字符串放进去，然后反序列化拿出来，
第一种数据结构：
shapping_car : {
    user_id : {
        course_id : {
        　　title:XX
        　　course_img:XX
        　　price_policy_dict: {
        　　　　　　1:{'name':有效期1个月,price:799} # 价格策略会有多个
            　　}
        　　default_price_policy_dict: 1
        }
    }
}

第二种数据结构
shapping_car_userid_courseid : {
      id:XX
      title:XX
      course_img:XX
      price_policy_dict: {
          1:{name:有效期1个月,price:99 }
      }
      default_price_policy_dict:XX
 }

三，开始实现加入购物车：
前端：
传过来course_id ， price_policy_id ，不需要传递user_id因为已经登录了，
后端：
1，获取前端传过来的值，如何取到user_id ? 直接request里面就会有，
2，对存过来的数据进行校验，一定要校验，把这个校验深深刻进脑子
      1，验证course_id 验证是否合法
      2，price_policy_id 验证是否合法
3，构建我们想要的数据结构
4，写入redis
5，返回数据，

四，开始实现查看购物车
前端：进入购物车页面，发送get请求，
后端逻辑：
1，获取到userid，
2，根据userid拼接购物车的key，
3，去redis里面把这个人所有的购物车信息都拿出来，
4，然后返回给前端，
注意，redis的操作是重中之重

五，更新购物车逻辑
前端发过来字段：{
　　course_id:1,
　　default_policy_id:2
}
后端逻辑:
1，获取前端传过来的课程id，策略id
2，校验数据,
3，更新数据，
4，返回数据，

六，删除购物车信息
前端传过来字典：{
　　course_id:[1,2,3]  # 支持删除单个，和多个，
　　 }
后端逻辑：
1，获取前端传过来的课程id
2，拼接购物车的key，
3，验证key是否存在，
4，如果存在，就删除，
5，返回成功，



"""

from rest_framework.views import APIView
from rest_framework.viewsets import GenericViewSet, ViewSetMixin
from rest_framework.response import Response
from django_redis import get_redis_connection
from utils.response import BaseResponse
from utils.auth import LuffyAuth
from api import models
from django.core.exceptions import ObjectDoesNotExist
from utils.exception import PricePolicyInvalid
from django.conf import settings
import json

class ShoppingCarViewSet(APIView):
    authentication_classes = [LuffyAuth,]
    conn = get_redis_connection("default") # 在这个地方穿件连接池，下面在函数中连接redis的时候，需要self.conn

    def post(self, request, *args, **kwargs):
        """
        将课程添加到购物车
        :param request:
        :param args:
        :param kwargs:
        :return:
        """
        ret = BaseResponse()
        try:
            # 1. 获取用户提交的课程ID和价格策略ID
            course_id = int(request.data.get('courseid'))
            policy_id = int(request.data.get('policyid'))

            # 2. 通过课程id获取专题课信息，如果找不多会报异常，需要处理ObjectDoesNotExist
            course = models.Course.objects.get(id=course_id)

            # 3. 获取该课程相关的所有价格策略
            price_policy_list = course.price_policy.all()  # all返回queryset对象，可以遍历
            price_policy_dict = {}
            for item in price_policy_list:
                price_policy_dict[item.id] = {
                    "period":item.valid_period,
                    "period_display":item.get_valid_period_display(),
                    "price":item.price,
                }

            # 4. 判断用户提交的价格策略是否合法
            if policy_id not in price_policy_dict:
                # 价格策略不合法
                raise PricePolicyInvalid('价格策略不合法')

            # 5. 将购物信息添加到redis中
            # self.conn
            # car_key = "luffy_shopping_car_%s_%s"
            car_key = settings.SHOPPING_CAR_KEY %(request.auth.user_id,course_id,)
            car_dict = {
                'title':course.name,
                'img':course.course_img,
                'default_policy':policy_id,
                'policy':json.dumps(price_policy_dict)
            }
            # conn = get_redis_connection("default")
            self.conn.hmset(car_key,car_dict)
            ret.data = '添加成功'

        except PricePolicyInvalid as e:
            ret.code = 2001
            ret.error = e.msg
        except ObjectDoesNotExist as e:
            ret.code = 2001
            ret.error = '课程不存在'
        except Exception as e:
            ret.code = 1001
            ret.error = '获取购物车失败'
        return Response(ret.dict)

    def delete(self, request, *args, **kwargs):
        """
        购物车中删除课程
        :param request:
        :param args:
        :param kwargs:
        :return:
        """
        ret = BaseResponse()
        try:
            course_id_list = request.data.get('courseids')
            key_list = [ settings.SHOPPING_CAR_KEY %(request.auth.user_id,course_id,) for course_id in course_id_list]
            self.conn.delete(*key_list)
        except Exception as e:
            ret.code = 1002
            ret.error = "删除失败"

        return Response(ret.dict)

    def patch(self, request, *args, **kwargs):
        """
        修改课程的价格策略
        :param request:
        :param args:
        :param kwargs:
        :return:
        """
        ret = BaseResponse()
        try:
            # 1. 获取价格策略ID和课程ID
            course_id = int(request.data.get('courseid'))
            policy_id = str(request.data.get('policyid'))  # 因为你load回来之后，是一个字符串，

            # 2. 拼接课程的key
            key = settings.SHOPPING_CAR_KEY %(request.auth.user_id,course_id,)
            if not self.conn.exists(key):
                ret.code = 1002
                ret.error = "购物车中不存在此课程"
                return Response(ret.dict)
            # 3. redis中获取所有的价格策略
            policy_dict = json.loads(str(self.conn.hget(key,'policy'),encoding='utf-8'))
            if policy_id not in policy_dict:
                ret.code = 1003
                ret.error = "价格策略不合法"
                return Response(ret.dict)

            # 4. 在购物车中修改该课程的默认价格策略
            self.conn.hset(key,'default_policy',policy_id)

            ret.data = "修改成功"

        except Exception as e:
            ret.code = 1004
            ret.error = "修改失败"

        return Response(ret.dict)

    def get(self,request, *args, **kwargs):
        """
        查看购物车中所有的商品
        :param request:
        :param args:
        :param kwargs:
        :return:
        """
        ret = BaseResponse()
        try:
            key_match = settings.SHOPPING_CAR_KEY %(request.auth.user_id,"*")

            course_list = []

            for key in self.conn.scan_iter(key_match,count=10):
                info = {
                    "title":self.conn.hget(key,'title').decode('utf-8'),
                    "img":self.conn.hget(key,'img').decode('utf-8'),
                    "policy":json.loads(self.conn.hget(key,'policy').decode('utf-8')),
                    "default_policy":self.conn.hget(key,'default_policy').decode('utf-8')
                }
                course_list.append(info)
            ret.data = course_list
        except Exception as e:
            ret.code = 1002
            ret.error = "获取失败"
        return Response(ret.dict)

class ShoppingCar(APIView):
    conn = get_redis_connection('default')
    authentication_classes = [TokenAuth]

    def post(self,request):
        res = BaseException()
        # 1，获取前端传过来的数据
        course_id = int(request.data.get('course_id',''))
        price_policy_id = int(request.data.get('price_policy_id',''))
        user_id = request.user.id
        print(course_id,price_policy_id,user_id)

        # 2，获取课程信息
        course_obj = Course.objects.filter(id=course_id).first()
        if not course_obj:
            res.code=1021
            res.error= '课程不存在'
            return Response(res.dict)
        # 3，获取课程所有的价格策略
        price_policy_list = course_obj.price_policy.all()
        price_dict = {}
        for i in price_policy_list:
            price_dict[i.id]= {
            "text":i.get_valid_period_display(),
            "price":i.price
            }
        print(price_dict)
        print(price_dict.keys())
        print(price_policy_id)
        # 判断策略是否存在
        if price_policy_id not in price_dict:
            res.code=1022
            res.error='策略不存在'
            return  Response(res.dict)
        # 存入redis
        redis_car_key = settings.SHOPPING_CART_KEY.format(user_id,course_id)
        self.conn.hmset(redis_car_key,{
            "title": course_obj.name,
            "course_img": course_obj.course_img,
            "price": json.dumps(price_dict),
            "default_price_id": price_policy_id
        })
        res.data='加入成功'
        return Response(res.dict)


    def get(self,request):

        res = BaseException()
        try:
            # 1，获取userid
            user_id = request.user.id
            # 2，拼接购物车的key，
            shopping_car_key = settings.SHOPPING_CART_KEY.format(user_id,"*")
            print(shopping_car_key)
            # 3，根据key，获取所有的购物车列表
            all_key = self.conn.scan_iter(shopping_car_key)
            print('all_key',all_key)
            # 4，构造返回数据
            shopping_car_list = []
            for key in all_key:
                course_id = str(key, encoding='utf-8').rsplit("_", maxsplit=1)[1]  # str 类型
                # print(course_id, type(course_id))
                course_info = {
                    course_id: {
                        "title": self.conn.hget(key, "title").decode('utf-8'),
                        "img": self.conn.hget(key, "course_img").decode('utf-8'),
                        "default_policy": self.conn.hget(key, "default_price_id").decode('utf-8'),
                        "policy": json.loads(self.conn.hget(key, "price").decode('utf-8')),  # 转换成 字符串
                    }
                }
                shopping_car_list.append(course_info)

            res.data=shopping_car_list

        except Exception as e:
            print(e)
            res.error=10031
            res.error='获取失败'

        return Response(res.dict)


    def put(self,request):
        res = BaseException()

        try:

            # 1，获取前端传过来的数据，课程id，策略id。
            course_id = request.data.get('course_id')
            price_id = request.data.get('default_price_id')
            user_id = request.user.id

            # 2，判断课程是否存在
            # 逻辑，拼接shoppingkey，然后判断是否存在
            shopping_car_key = settings.SHOPPING_CART_KEY.format(user_id,course_id)
            if not self.conn.exists(shopping_car_key):
                res.code=1033
                res.error="课程不存在"
                return Response(res.data)
            # 3，判断策略是否存在
            # 先获取到这个课程下面的价格策略
            # course_info = self.conn.hgetall(shopping_car_key)
            price_dict= json.loads(str(self.conn.hget(shopping_car_key,'price'),encoding='utf-8'))
            print(price_dict)
            if price_id not in price_dict:
                res.code=1034
                res.error='策略不存在'
                return Response(res.dict)
            self.conn.hset(shopping_car_key,'default_price_id',price_id)
            res.data='修改成功'
        except Exception as e:
            print(e)
            res.code=1034
            res.error='更新失败'
        return Response(res.dict)

    def delete(self,request):
        res = BaseException()

        try:
            # 1，获取前端的 courseid
            course_id = request.data.get('course_id')
            user_id = request.user.id

            # 2，判断courseid是否存在
            shopping_car_key = settings.SHOPPING_CART_KEY.format(user_id,course_id)
            if not self.conn.exists(shopping_car_key):
                res.code=1035
                res.error='课程不存在'
            # 3，删除记录
            self.conn.delete(shopping_car_key)
            res.data='删除成功'
        except Exception as e:
            res.code=1036
            res.error='删除失败'
        return Response(res.dict)

from rest_framework.authentication import BaseAuthentication
from api import models
from rest_framework.exceptions import AuthenticationFailed

class LuffyAuth(BaseAuthentication):

    def authenticate(self, request):
        """
        用户请求进行认证
        :param request:
        :return:
        """
        # http://wwwww...c0ovmadfasd/?token=adfasdfasdf
        token = request.query_params.get('token')
        obj = models.UserAuthToken.objects.filter(token=token).first()
        if not obj:
            raise AuthenticationFailed({'code':1001,'error':'认证失败'})

        return (obj.user.username,obj)

class PricePolicyInvalid(Exception):
    def __init__(self,msg):
        self.msg = msg

# django-redis 配置
CACHES = {
    "default": {  # 一个redis连接
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://192.168.100.128:6379",  # redis的IP和端口
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {"max_connections": 1000},  # 连接池最大连接数
            "PASSWORD": "ji10201749"  # 密码
        },
    },
}

# 购物车的 redis 中的key
SHOPPING_CART_KEY = "shopping_car_{0}_{1}"
PAYMENT_COURSE_KEY = "payment_{0}_{1}"  # redis 中 结算中心关于课程信息+优惠券信息
PAYMENT_GLOBAL_COUPON_KEY = "payment_global_coupon_{}"  # 通用优惠券信息

class BaseResponse(object):
    def __init__(self):
        self.data = None
        self.code = 1000
        self.error=None

    @property
    def dict(self):
        return self.__dict__