基于rest_framework和redis实现购物车的操作，结算，支付

前奏：

　　首先，要在主机中安装redis，windows中安装，下载一个镜像，直接进行下一步的安装，安装成功后，在cmd中输入redis-cli

　　安装python的依赖库： redis     和   django-redis

　　redis是一个python的库，用来操作redis。

　　django默认支持的缓存是memcache，使用redis作为django的缓存,就需要django-redis了，django-redis是一个开源的库。

只需要在全局settings中配置即可。

django-redis的配置使用

在settings.py中的配置：

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {"max_connections": 100}
            # "PASSWORD": "密码",
        }
    }
　　"可自定义配置":{...}
}

from django_redis import get_redis_connection
conn = get_redis_connection("default")

　　安装配置后就可以使用了，但是据说性能不够高，官方文档见https://niwinz.github.io/django-redis/latest/

 异常错误信息的自定义

# 自定义一个类名，这个类继承Exception即可
class PriceNoExistsError(Exception):

    def __init__(self,msg):
        self.msg = msg

模型表数据存储的校验

models.py中模型表可以在数据保存前做数据校验，重写save方法即可

比如：校验优惠券存储的开始和结束时间

class Coupon(models.Model):
    """优惠券生成规则"""
    name = models.CharField(max_length=64, verbose_name="活动名称")
    brief = models.TextField(blank=True, null=True, verbose_name="优惠券介绍")
    coupon_type_choices = ((0, '通用券'), (1, '满减券'), (2, '折扣券'))
    coupon_type = models.SmallIntegerField(choices=coupon_type_choices, default=0, verbose_name="券类型")

    money_equivalent_value = models.IntegerField(verbose_name="等值货币",blank=True,null=True)
    off_percent = models.PositiveSmallIntegerField("折扣百分比", help_text="只针对折扣券，例7.9折，写79", blank=True, null=True)
    minimum_consume = models.PositiveIntegerField("最低消费", default=0, help_text="仅在满减券时填写此字段",blank=True,null=True)

    content_type = models.ForeignKey(ContentType, blank=True, null=True)
    object_id = models.PositiveIntegerField("绑定课程", blank=True, null=True, help_text="可以把优惠券跟课程绑定")
    content_object = GenericForeignKey('content_type', 'object_id')

    quantity = models.PositiveIntegerField("数量(张)", default=1)
    open_date = models.DateField("优惠券领取开始时间")
    close_date = models.DateField("优惠券领取结束时间")
    valid_begin_date = models.DateField(verbose_name="有效期开始时间", blank=True, null=True)
    valid_end_date = models.DateField(verbose_name="有效结束时间", blank=True, null=True)
    coupon_valid_days = models.PositiveIntegerField(verbose_name="优惠券有效期（天）", blank=True, null=True,
                                                    help_text="自券被领时开始算起")
    date = models.DateTimeField(auto_now_add=True)

    class Meta:
        verbose_name_plural = "31. 优惠券生成记录"

    def __str__(self):
        return "%s(%s)" % (self.get_coupon_type_display(), self.name)

    def save(self, *args, **kwargs):
        if not self.coupon_valid_days or (self.valid_begin_date and self.valid_end_date):
            if self.valid_begin_date and self.valid_end_date:
                if self.valid_end_date <= self.valid_begin_date:
                    raise ValueError("valid_end_date 有效期结束日期必须晚于 valid_begin_date ")
            if self.coupon_valid_days == 0:
                raise ValueError("coupon_valid_days 有效期不能为0")
        if self.close_date < self.open_date:
            raise ValueError("close_date 优惠券领取结束时间必须晚于 open_date优惠券领取开始时间 ")

        super(Coupon, self).save(*args, **kwargs)

对于购物车的操作，结算，支付等部分视图函数做登录认证的处理

借助rest_framework的局部认证功能

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


class LoginAuth(BaseAuthentication):

    def authenticate(self, request):
        token = request.query_params.get('token')
        token_obj = models.Token.objects.filter(name=token).first()
        if token_obj:
            return token_obj.user,token_obj
        else:
            raise AuthenticationFailed('认证失败')

封装响应数据的结构

可以将所有视图函数返回给前端的响应信息封装到一个类中，什么时候需要直接实例化对象使用。

class StatusRet(object):
    '''构建返回响应的结构''

    def __init__(self):
        self.code = 1000
        self.msg = ''
        self.data = None

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

借助admin快速添加数据

from django.contrib import admin

# Register your models here.

from django.apps import apps

all_model_gene =apps.get_app_config('api').get_models()   # 将所有的模型类放在生成器中
for model_cls in all_model_gene:
    admin.site.register(model_cls)

from django.contrib import admin

from django.apps import apps
app_models =apps.get_app_config("api").get_models()

from django.contrib.admin.sites import AlreadyRegistered

for i in app_models:
    try:
        admin.site.register(i)
    except AlreadyRegistered:
        pass

购物车的增删改查：

1.url的设计

　　url(r'^shopping_car/',views.ShoppingCar.as_view()),2.视图类的处理

redis中数据的存储格式：  通过这种name的形式来存储 哪个用户的哪门课程信息

SHOP_CAR_COURSE_KEY = 'shop_car_%s_%s'     # 第一个%s 代表当前的用户的主键id   第二个%s 代表某个课程的主键id

具体的视图函数逻辑：

class ShoppingCar(APIView):
    '''购物车的增删改查'''

    #  购物车的登录认证
    authentication_classes = [LoginAuth]
　　
    conn = get_redis_connection('default')

    def get(self,request):

        '''获取当前用户在购物车中的所有记录'''

        # 获取返回值对象
        ret = StatusRet()
        # 从redis中获取当前用户所有的key
        shop_car_key = settings.SHOP_CAR_COURSE_KEY % (request.user.pk, '*')
        # 利用scan_iter 将当前用户所有的keys生成一个生成器
        price_policy_gene = self.conn.scan_iter(shop_car_key)
        # 构建接口数据
        '''
        [
        { key1:{ title:...,price:... }},
        { key2:{... }},...
        ]
        '''
        price_policy_list = []
        for keys in price_policy_gene:
            data_dict = {
                'title': self.conn.hget(keys,'title').decode(),
                'price': self.conn.hget(keys,'price').decode(),
                'course_img': self.conn.hget(keys,'course_img').decode(),
                'price_policy': json.loads(self.conn.hget(keys,'price_policy').decode()),   # 直接json反序列化
                'checked_price_policy_id': self.conn.hget(keys,'checked_price_policy_id').decode()
            }

            price_policy_list.append(data_dict)
        # 将查询的所有数据返回
        ret.data = price_policy_list
        return Response(ret.dict)

    def post(self,request):
        '''添加购物车记录'''
        ret = StatusRet()
        # 获取从前端发来的数据   course_id : 课程的pk值    price_policy_id : 价格策略的pk值
        course_id = request.data.get('course_id')
        price_policy_id = request.data.get('price_policy_id')
        # 校验前端传来数据的合法性
        try:
            course_obj = models.Courses.objects.get(pk=course_id)
            price_policy_list = course_obj.price_policy.all()

            price_policy_dict = {}
            for item in price_policy_list:
                price_policy_dict[item.pk] = {"name":item.name,"price":float(item.price)}

            if int(price_policy_id) not in price_policy_dict:
                raise PriceNoExistsError('价格策略不存在')
            shop_car_key = settings.SHOP_CAR_COURSE_KEY%(request.user.pk,course_id)
            # 构建数据
            val_dict = {
                "title":course_obj.title,
                "price":course_obj.price,
                "course_img":course_obj.course_img,
                "price_policy":json.dumps(price_policy_dict,ensure_ascii=False),   #提前将数据json序列化，便于后期的取值
                "checked_price_policy_id":price_policy_id
            }
            # 将数据添加到redis中
            self.conn.hmset(shop_car_key,val_dict)

            ret.data = val_dict

        except PriceNoExistsError as e:
            ret.code = 2000
            ret.msg = str(e)

        except ObjectDoesNotExist as e:
            ret.code = 2000
            ret.msg = '课程不存在'

        except Exception as e:
            ret.code = 2000
            ret.msg = '出错了'

        return Response(ret.dict)

    def put(self,request):
        '''修改购物车记录'''
        ret = StatusRet()
        # 获取前端传来的数据
        course_id = request.data.get('course_id')
        price_policy_id = request.data.get('price_policy_id')
        # 校验数据的合法性
        try:
            shop_car_key = settings.SHOP_CAR_COURSE_KEY % (request.user.pk, course_id)
            if not self.conn.exists(shop_car_key):
                raise CourseNoExistsErrot('修改课程不存在')
            course_data = self.conn.hgetall(shop_car_key)
            course_policy = json.loads(self.conn.hget(shop_car_key,"price_policy").decode())

            if str(price_policy_id) not in course_policy:
                raise PriceNoExistsError('价格策略不存在')
            # 将redis中的值进行修改
            self.conn.hset(shop_car_key,'checked_price_policy_id',price_policy_id)
            # 构建返回给前端的数据
            return_data = {}
            for k,v in course_data.items():
                if k == b"price_policy":
                    val = json.loads(v.decode())
                else:
                    val = v.decode()
                return_data[k.decode()] = val
            ret.data = return_data

        except CourseNoExistsErrot as e:
            ret.code = 2000
            ret.msg = str(e)

        except PriceNoExistsError as e:
            ret.code = 2000
            ret.msg = str(e)

        except Exception as e:
            ret.code = 2000
            ret.msg = '更新失败'

        return Response(ret.dict)

    def delete(self,request):
        '''删除购物车记录'''
        ret = StatusRet()
        # 校验前端传来数据的合法性
        try:
            course_id_list = request.data.get('course_id')

            shop_key_list =[]
            for course_id in course_id_list:
                shop_car_key = settings.SHOP_CAR_COURSE_KEY % (request.user.pk, course_id)
                if not self.conn.exists(shop_car_key):
                    raise CourseNoExistsErrot('删除课程不存在')
                else:
                    # 将所有校验合法的key存在列表中
                    shop_key_list.append(shop_car_key)
            # 从redis中删除记录
            self.conn.delete(*shop_key_list)
            ret.data = ''
        except CourseNoExistsErrot as e:
            ret.code = 2000
            ret.msg = str(e)

        return Response(ret.dict)

 备注：使用json进行序列化时，如果字段类型为decimal时，要先将数据转为float类型，否则json无法序列化，json不支持decimal的数据类型。

结算页面

购物车中增删改查实现后，就是结算页面了，结算包含两种情况，一种是购物车中选中商品后的直接结算，是post请求，将该商品的所有信息和所有可用的优惠券（包含专用的和通用的），以及其他，比如散币（腾讯的Q币，淘宝的积分，等等）查询出来后存入redis中，并将数据构建后返回。另一种是用户选择结算后的延迟，在此使用时，可以通过未支付页面的get请求，直接从redis中取数据，并返回给前端的展示。

1.url的构建

    url(r'^settle_center/',views.SettlementView.as_view()),

2.redis中的存储方式：

PAYMENT_COURSE_KEY = 'payment_%s_%s'  #课程专用优惠券
PAYMENT_COMMON_KEY = 'pay_common_%s'    #通用优惠券

USER_BALANCE_COUNT = 'balance_count_%s'   #用户贝里数

3.视图逻辑

class SettlementView(APIView):
    '''结算的逻辑操作'''
    authentication_classes = [LoginAuth]  #登录认证
    conn = get_redis_connection('default')   #redis的连接

    def get_return_data(self,request):
        '''构建返回给前端的数据'''

        #获取用户pk值
        user_id = request.user.pk
        #获取redis中该用户的贝里数
        user_balance_key = settings.USER_BALANCE_COUNT
        user_balance_count = user_balance_key % user_id
        balance_data = self.conn.hgetall(user_balance_count)
        # 获取redis中该用户的所有课程专用优惠券
        payment_key = settings.PAYMENT_COURSE_KEY % (user_id, '*')
        keys = self.conn.scan_iter(payment_key)
        #获取redis中该用户的通用优惠券
        common_key = settings.PAYMENT_COMMON_KEY % user_id
        common_data = self.conn.hgetall(common_key)

        return_data = []
        # 构建贝里数数据
        balance_dict = {}
        for k,v in balance_data.items():
            balance_dict[k.decode()] = v.decode()
        # 构建通用优惠券的信息
        common_show_dict = {}
        for com_k, com_v in common_data.items():
            common_show_dict[com_k.decode()] = json.loads(com_v.decode())

        # 处理普通优惠券的数据
        coupon_dict = {}
        for key in keys:
            course_id = key.decode().split('_')[-1]
            coupon_dict[course_id] = {}
            course_coupon_data = self.conn.hgetall(key)
            for cou_k, cou_v in course_coupon_data.items():
                if cou_k == b'coupons':
                    coupons_data = {}
                    for coup_k, coup_v in json.loads(cou_v.decode()).items():
                        coupons_data[coup_k] = json.loads(coup_v)
                    coupon_dict[course_id][cou_k.decode()] = coupons_data
                else:
                    coupon_dict[course_id][cou_k.decode()] = json.loads(cou_v.decode())

        return_data.append(balance_dict)
        return_data.append(common_show_dict)
        return_data.append(coupon_dict)

        return return_data

    def get(self,request):
        '''获取redis中当前登录用户的所有的待支付信息'''
        ret = StatusRet()
        return_data = self.get_return_data(request)

        ret.data = return_data

        return Response(ret.dict)

    def post(self,request):
        '''将用户选择的商品信息存储到redis中'''
        ret = StatusRet()

        # 获取前端发送的所有选中的数据
        course_id_list = request.data.get('course_id')
        for course_id in course_id_list:
            shop_car_key = settings.SHOP_CAR_COURSE_KEY%(request.user.pk,course_id)
            # 校验数据是不是在购物车中
            if not self.conn.exists(shop_car_key):
                ret.code = 2000
                ret.msg = '课程不存在'
                return Response(ret.dict)
            else:
                # 校验通过后  获取当前的时间
                now = datetime.datetime.now()
                # 获取选中课程在购物车中的详细信息
                course_price_data = self.conn.hgetall(shop_car_key)
                # 将取出的数据进行重新构建
                course_detail = {}
                for key,val in course_price_data.items():
                    if key == b'price_policy':
                        course_detail[key.decode()] = json.loads(val.decode())
                    else:
                        course_detail[key.decode()]=val.decode()
                # 构建存进redis中的数据
                coupon_dict = {}
                common_dict = {}
                # 设置全局的存储name的格式
                pay_course_settings = settings.PAYMENT_COURSE_KEY
                payment_key =pay_course_settings%(request.user.pk,course_id)
                # 获取当前用户在优惠券领取记录表中所有的未使用，并且未过期的优惠券
                couponrecord_list = models.CouponRecord.objects.filter(user=request.user,status=0,coupon__valid_begin_date__lte=now,coupon__valid_end_date__gte=now,number__gte=1,coupon__object_id=course_id)

                for coupon_record_obj in couponrecord_list:
                    coupon_obj = coupon_record_obj.coupon
                    temp = {
                        'name':coupon_obj.name,
                        'coupon_type':coupon_obj.coupon_type,
                        'money_equivalent_value':coupon_obj.money_equivalent_value,
                        'off_percent':coupon_obj.off_percent,
                        'minimum_consume':coupon_obj.minimum_consume,
                        'object_id':coupon_obj.object_id
                    }
                    # 判断是通用优惠券还是某个课程的专用优惠券
                    if not coupon_obj.object_id:
                        common_dict[coupon_record_obj.pk] = json.dumps(temp,ensure_ascii=False)
                    else:
                        coupon_dict[coupon_record_obj.pk] = json.dumps(temp,ensure_ascii=False)
                val_dict = {}
                val_dict['course_detail'] = json.dumps(course_detail,ensure_ascii=False)

                val_dict['coupons'] = json.dumps(coupon_dict,ensure_ascii=False)
                self.conn.hmset(payment_key,val_dict)
                common_settint_key = settings.PAYMENT_COMMON_KEY
                common_key = common_settint_key%(request.user.pk)
                # 如果没有通用优惠券，在存储redis时会报错，因为存储的value不能为一个空字典
                if common_dict:
                    self.conn.hmset(common_key,common_dict)
        #
        # 获取当前用户的贝里数
        balance = request.user.beli_count
        balance_dict = {'balance': balance}
        user_balance_key = settings.USER_BALANCE_COUNT
        user_balance_count = user_balance_key%request.user.pk
        self.conn.hmset(user_balance_count,balance_dict)

        # 获取返回前端的数据
        return_data = self.get_return_data(request)
        ret.data = return_data

        return Response(ret.dict)

支付页面

结算完毕就该支付页面了，用户点击支付后，会将所有要支付的数据发回来，进行数据的校验，校验通过后，生成order订单表（或订单详情表），然后就可以调用支付的接口

1.url的构建

url(r'^payment/',views.PaymentViewSet.as_view()),

2.逻辑的实现

　　数据取出可以是从redis中取，也可以从数据库中取，进行校验，具体的实现粒度视情况

class PaymentViewSet(APIView):
    authentication_classes = [LoginAuth]
    conn = get_redis_connection('default')
    now = datetime.datetime.now()

    def post(self,request):
        '''
        前端发送的数据结构：
        {
            "money":87.12,  # 总价格
            "balance":0,    # 贝里数
            "course_detail":  #课程详细   包含该课程选中的优惠券pk值，价格id，价格
                {
                    "1":{"coupon_id":1,"policy_id":1,"price":99},
                    "2":{"coupon_id":5,"policy_id":4,"price":0}
                },
            "common_coupon_id":4   # 通用优惠券的pk值
        }
        
        '''
        #获取数据
        ret = StatusRet()

        user_id = request.user.pk
        _balance = models.UserInfo.objects.filter(pk=user_id).first().beli_count
        course_detail = request.data.get("course_detail")
        money = request.data.get('money')
        currency_coupon_id = request.data.get('common_coupon_id')
        balance = request.data.get('balance')
        # 数据处理
        try:
            if balance>_balance:
                raise OrderError('贝利数异常,支付失败')
            course_price_list = []
            for course_id,course_info in course_detail.items():
                # 从redis中购物车中取数据校验
                # pay_key = settings.PAYMENT_COURSE_KEY%(user_id,course_id)
                # pay_ret = self.conn.hgetall(pay_key)
                # print(pay_ret,'pay_key')
                # for key,value in pay_ret.items():
                #     # key = key.decode()
                #     value = json.loads(value.decode())
                #     print(key,value)
                #     if key == b'coupons':
                #         if course_info['coupon_id'] not in value:
                #             raise OrderError('优惠券不存在')
                #     elif key == b'course_detail':
                #         for key_course,value_course in value.items():
                #             if key_course == 'title':
                #                 pass
                #             elif key_course == 'checked_price_policy_id':
                #                 if value_course != str(course_info['policy_id']):
                #                     raise OrderError('选中的价格策略异常')
                #             elif key_course == 'price_policy':
                #                 # print(value_course,type(value_course))
                #                 course_price = value_course[str(course_info['policy_id'])]['price']
                #                 if course_price != course_info['price']:
                #                     raise OrderError('课程价格异常')
                #                 course_price_list.append(course_price)

                                
                # 数据库中取数据校验
                course_obj = models.Courses.objects.filter(pk=course_id).first()
                if not course_obj:
                    raise OrderError('课程不存在')
                if course_obj.status !=0:
                    raise OrderError('课程已下架')
                policy_list = list(course_obj.price_policy.all().values('pk','price'))
                # print(type(course_info['policy_id']))
                if course_info['policy_id'] not in [i['pk'] for i in policy_list]:
                    raise OrderError('价格策略不存在')
                print(policy_list, '价格策略列表')
                print([float(i['price']) for i in policy_list if i['pk'] ==course_info['policy_id'] ])
                policy_price = [float(i['price']) for i in policy_list if i['pk'] ==course_info['policy_id']][0]
                if policy_price != course_info['price']:
                    raise OrderError('价格异常')

                # 更细粒度的校验实现
                # xxx = models.CouponRecord.objects.filter(pk=course_info['coupon_id'],user_id=user_id).first()
                # if not xxx:
                #     raise OrderError('优惠券不存在')
                # if xxx.status !=0:
                #     raise OrderError('优惠券未上架')
                # if int(xxx.number) <1:
                #     raise OrderError('优惠券数量不够')
                #  ...

                if course_info['coupon_id']:
                    coupon_obj = models.CouponRecord.objects.filter(pk=course_info['coupon_id'],user_id=user_id,status=0,number__gte =1,coupon__valid_begin_date__lte=self.now,coupon__valid_end_date__gte=self.now,coupon__object_id=course_id).first()
                    if not coupon_obj:
                        raise OrderError('优惠券异常，支付失败')
                # 获取每个课程的价格
                    price_course = self.account_price(coupon_obj,policy_price)
                else:
                    price_course = policy_price
            
                course_price_list.append(price_course)
           
            # 获取价格总和
            course_price_total = sum(course_price_list)
            # 通用优惠券的校验和使用
            if currency_coupon_id:
                currency_coupon_obj = models.CouponRecord.objects.filter(pk=currency_coupon_id,user_id=user_id,status=0,number__gte =1,coupon__valid_begin_date__lte=self.now,coupon__valid_end_date__gte=self.now).first()
                if not currency_coupon_obj:
                    raise OrderError('通用优惠卷异常')
                course_total = self.account_price(currency_coupon_obj,course_price_total)
            else:
                course_total = course_price_total
            # 贝里数的扣减
            if balance>0:
                _finally_price = course_total- balance/100
            else:
                _finally_price = course_total
            finally_price = round(_finally_price,2)
            # 总价格的校验
            if finally_price != money:
                raise OrderError('总价格异常')

            # 生成订单信息

            order_obj = models.Order.objects.create(payment_type=1,order_number=self.get_random_order(),actual_amount=finally_price,user_id=user_id,status=1)
            # models.OrderDetail.objects.create(order=order_obj,original_price=course_price_total,price=finally_price,valid_period_display='课程有效期',valid_period=100,content_type=)

            # 调用支付接口
            # xxxxxxxxxxxxxxxxxxxxx

        except OrderError as e:
            ret.code = 2000
            ret.msg = str(e)

        return Response(ret.dict)

    def account_price(self, coupon_record_obj, price):
        """
        根据优惠券记录对象，以及优惠前的价格 计算出使用优惠券的价格
        """
        coupon_type = coupon_record_obj.coupon.coupon_type
        if coupon_type == 0:
            money_equivalent_value = coupon_record_obj.coupon.money_equivalent_value
            # --立减
            # 0 = 获取原价 - 优惠券金额   或
            # 折后价格 = 获取原价 - 优惠券金额
            if price - money_equivalent_value >= 0:
                rebate_price = price - money_equivalent_value
            else:
                rebate_price = 0
        elif coupon_type == 1:
            # -- 满减 是否满足限制
            minimum_consume = coupon_record_obj.coupon.minimum_consume
            if price >= minimum_consume:
                # 折后价格 = 获取原价 - 优惠券金额
                money_equivalent_value = coupon_record_obj.coupon.money_equivalent_value
                rebate_price = price - money_equivalent_value
            else:
                return price
        elif coupon_type == 2:
            # -- 折扣
            off_percent = coupon_record_obj.coupon.off_percent
            # 折后价格 = 获取原价* 80/100
            rebate_price = price * (off_percent / 100)
        else:
            rebate_price = price
        return rebate_price

    def get_random_order(self):
        '''生成随机订单号'''
        import random
        time_current = self.now.strftime('%Y%m%d%H%M%S')
        random_str = ''.join([str(random.randint(0,9)) for i in range(4)])
        return f'{time_current}{random_str}'

附表信息：

from datetime import datetime
from django.db import models

from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes.fields import GenericRelation,GenericForeignKey


# Create your models here.



class Courses(models.Model):
    title = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=8,decimal_places=2)
    classes = ((1,'初级'),(2,'中级'),(3,'高级'))
    course_class = models.SmallIntegerField(choices=classes)
    course_img = models.CharField(max_length=128)
    status_choices = ((0, '上线'), (1, '下线'), (2, '预上线'))
    status = models.SmallIntegerField(choices=status_choices, default=0,help_text='课程的状态')

    price_policy = GenericRelation(to='PricePolicy')

    questions = GenericRelation(to='OftenQuestion')

    coupons = GenericRelation(to='Coupon')

    def __str__(self):
        return self.title


class CourseDetail(models.Model):
    course = models.OneToOneField(to='Courses')
    slogen = models.CharField(max_length=128)
    desc = models.CharField(max_length=512)
    hours = models.IntegerField('课时',default=10)
    recommend_courses = models.ManyToManyField(to='Courses',related_name="recourse")

    def __str__(self):
        return self.course.title


class ChapterList(models.Model):
    '''课程章节'''
    num = models.SmallIntegerField()
    name = models.CharField(max_length=64)
    course = models.ForeignKey(to='Courses',on_delete=models.CASCADE)

    def __str__(self):
        return "%s:(第%s章)%s"%(self.course,self.num,self.name)

    class Meta:
        unique_together = ('num','course')


class CourseSection(models.Model):
    '''课时目录'''
    name = models.CharField(max_length=64)
    charpter = models.ForeignKey(to='ChapterList')

    def __str__(self):
        return self.name


class UserInfo(models.Model):
    name = models.CharField(max_length=16)
    password = models.CharField(max_length=32)

    beli_count = models.IntegerField(default=0)


    def __str__(self):
        return self.name


class Token(models.Model):
    name = models.CharField(max_length=128)
    user = models.OneToOneField(to='UserInfo')

    def __str__(self):
        return self.name


class PricePolicy(models.Model):
    '''价格策略表'''

    name = models.CharField(max_length=128)
    price = models.DecimalField(max_digits=6,decimal_places=2,default=199)

    content_type = models.ForeignKey(to=ContentType)
    object_id = models.PositiveIntegerField()
    content_obj = GenericForeignKey('content_type','object_id')

    def __str__(self):
        return self.name

    class Meta:
        unique_together = ('content_type','object_id','name')


class OftenQuestion(models.Model):
    question = models.CharField(max_length=128)
    answer = models.TextField()

    content_type = models.ForeignKey(to=ContentType)
    object_id = models.PositiveIntegerField()
    content_obj = GenericForeignKey('content_type','object_id')

    def __str__(self):
        return self.question

    class Meta:
        unique_together = ('content_type','object_id','question')


class Coupon(models.Model):
    """优惠券生成规则"""
    name = models.CharField(max_length=64, verbose_name="活动名称")
    brief = models.TextField(blank=True, null=True, verbose_name="优惠券介绍")
    coupon_type_choices = ((0, '通用券'), (1, '满减券'), (2, '折扣券'))
    coupon_type = models.SmallIntegerField(choices=coupon_type_choices, default=0, verbose_name="券类型")

    money_equivalent_value = models.IntegerField(verbose_name="等值货币",blank=True,null=True)
    off_percent = models.PositiveSmallIntegerField("折扣百分比", help_text="只针对折扣券，例7.9折，写79", blank=True, null=True)
    minimum_consume = models.PositiveIntegerField("最低消费", default=0, help_text="仅在满减券时填写此字段",blank=True,null=True)

    content_type = models.ForeignKey(ContentType, blank=True, null=True)
    object_id = models.PositiveIntegerField("绑定课程", blank=True, null=True, help_text="可以把优惠券跟课程绑定")
    content_object = GenericForeignKey('content_type', 'object_id')

    quantity = models.PositiveIntegerField("数量(张)", default=1)
    open_date = models.DateField("优惠券领取开始时间")
    close_date = models.DateField("优惠券领取结束时间")
    valid_begin_date = models.DateField(verbose_name="有效期开始时间", blank=True, null=True)
    valid_end_date = models.DateField(verbose_name="有效结束时间", blank=True, null=True)
    coupon_valid_days = models.PositiveIntegerField(verbose_name="优惠券有效期（天）", blank=True, null=True,
                                                    help_text="自券被领时开始算起")
    date = models.DateTimeField(auto_now_add=True)

    class Meta:
        verbose_name_plural = "31. 优惠券生成记录"

    def __str__(self):
        return "%s(%s)" % (self.get_coupon_type_display(), self.name)

    def save(self, *args, **kwargs):
        if not self.coupon_valid_days or (self.valid_begin_date and self.valid_end_date):
            if self.valid_begin_date and self.valid_end_date:
                if self.valid_end_date <= self.valid_begin_date:
                    raise ValueError("valid_end_date 有效期结束日期必须晚于 valid_begin_date ")
            if self.coupon_valid_days == 0:
                raise ValueError("coupon_valid_days 有效期不能为0")
        if self.close_date < self.open_date:
            raise ValueError("close_date 优惠券领取结束时间必须晚于 open_date优惠券领取开始时间 ")

        super(Coupon, self).save(*args, **kwargs)


class CouponRecord(models.Model):
    """优惠券发放、消费纪录"""
    coupon = models.ForeignKey("Coupon")
    number = models.CharField(max_length=64, unique=True)
    user = models.ForeignKey("UserInfo", verbose_name="拥有者")
    status_choices = ((0, '未使用'), (1, '已使用'), (2, '已过期'))
    status = models.SmallIntegerField(choices=status_choices, default=0)
    get_time = models.DateTimeField(verbose_name="领取时间", help_text="用户领取时间")
    used_time = models.DateTimeField(blank=True, null=True, verbose_name="使用时间")
    order = models.ForeignKey("Order", blank=True, null=True, verbose_name="关联订单")  # 一个订单可以有多个优惠券

    class Meta:
        verbose_name_plural = "32. 用户优惠券"

    def __str__(self):
        return '%s-%s-%s' % (self.user, self.number, self.status)


class Order(models.Model):
    """订单"""
    payment_type_choices = ((0, '微信'), (1, '支付宝'), (2, '优惠码'), (3, '贝里'))
    payment_type = models.SmallIntegerField(choices=payment_type_choices)
    payment_number = models.CharField(max_length=128, verbose_name="支付第3方订单号", null=True, blank=True)
    order_number = models.CharField(max_length=128, verbose_name="订单号", unique=True)  # 考虑到订单合并支付的问题
    user = models.ForeignKey("UserInfo")
    actual_amount = models.FloatField(verbose_name="实付金额")

    status_choices = ((0, '交易成功'), (1, '待支付'), (2, '退费申请中'), (3, '已退费'), (4, '主动取消'), (5, '超时取消'))
    status = models.SmallIntegerField(choices=status_choices, verbose_name="状态")
    date = models.DateTimeField(auto_now_add=True, verbose_name="订单生成时间")
    pay_time = models.DateTimeField(blank=True, null=True, verbose_name="付款时间")
    cancel_time = models.DateTimeField(blank=True, null=True, verbose_name="订单取消时间")

    class Meta:
        verbose_name_plural = "37. 订单表"

    def __str__(self):
        return "%s" % self.order_number


class OrderDetail(models.Model):
    """订单详情"""
    order = models.ForeignKey("Order")


    content_type = models.ForeignKey(ContentType)  # 可关联普通课程或学位
    object_id = models.PositiveIntegerField()
    content_object = GenericForeignKey('content_type', 'object_id')

    original_price = models.FloatField("课程原价")
    price = models.FloatField("折后价格")
    content = models.CharField(max_length=255, blank=True, null=True)  # ？
    valid_period_display = models.CharField("有效期显示", max_length=32)  # 在订单页显示
    valid_period = models.PositiveIntegerField("有效期(days)")  # 课程有效期
    memo = models.CharField(max_length=255, blank=True, null=True)

    def __str__(self):
        return "%s - %s - %s" % (self.order, self.content_type, self.price)

    class Meta:
        verbose_name_plural = "38. 订单详细"
        unique_together = ("order", 'content_type', 'object_id')