Accept-Charset:  用于告诉浏览器，客户机采用的编码

Host: 客户机通过这个头告诉服务器，想访问的主机名

User-Agent: 客户机通过这个头告诉服务器，客户机的软件环境

Cookie: 客户机通过这个头可以向服务器带数据

200 请求已成功

301 永久重定向

302 临时重定向

304 未修改。所请求的资源未修改，服务器返回此状态码时，不会返回任何资源

404 资源找不到

500 服务器内部错误，无法完成请求

cookie是保存在客户端浏览器的，每次请求网页，会携带cookie

session是保存在服务器上面的，用来判断请求客户端的cookie是否合法

get 返回一个object。当返回结果，有且只有一条时，才会返回。否则报错

filter 返回一个queryset对象。即使没有匹配到条件，不会报错，返回一个空的queryset对象

1. 路由编写

2. ORM中，外键一定要有on_delete属性

3. 中间件

4. 模板配置

用来解决一个对和多个表做外键关联，并且关联的字段，不会在表中产生新的字段

用来做一些复杂查询，比如or

order.object.filter(id__gte=12)

order.object.filter(id__exclude=12)

order.object.filter(id__in=[1,3,4])

order.object.filter(id__range([20,100])

# 注意：Q(id__gt=20)是一组查询，&表示and，| 表示or

# Q(Q(num__lt=60)|Q(num__gt=70)) 是另外一组查询

order.object.filter(Q(id__gt=20) & Q(Q(num__lt=60)|Q(num__gt=70)))

# 默认使用asc(升序)，-id表示以id字段，进行desc(降序)来排序

order.object.all().order_by('-id','age')

# 注意：一定要以Student为基准表

# 当filter字段有其他表时，使用inner join。当使用values时，它是left join

# 一个班级在创建的时候，是没有学生的。所以以classes为基础表时,会造成数据不准确

Student.objects.all().values('name','classes__name')

Classes.object.filter(name="全栈12期").value("student__name")

# 当班级表的学生记录为空时，使用student__isnull=True

Classes.objects.filter(student__isnull=True).values('id','name')

1. 根据connections['default'].cursor()，最接近于pymysql操作

2. 使用extra

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.sqlite3',

        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),

    }

}

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.sqlite3',

        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),

    },

    'default2': {

        'ENGINE': 'django.db.backends.sqlite3',

        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),

    }

}

# ############深科技相关 ###################

class ArticleSource(models.Model):

    """文章来源"""

    name = models.CharField(max_length=64, unique=True)

    class Meta:

        verbose_name_plural = "16. 文章来源"

    def __str__(self):

        return self.name

class Article(models.Model):

    """文章资讯"""

    title = models.CharField(max_length=255, unique=True, db_index=True, verbose_name="标题")

    source = models.ForeignKey("ArticleSource", verbose_name="来源")

    article_type_choices = ((0, '资讯'), (1, '视频'))

    article_type = models.SmallIntegerField(choices=article_type_choices, default=0)

    brief = models.TextField(max_length=512, verbose_name="摘要")

    head_img = models.CharField(max_length=255)

    pub_date = models.DateTimeField(verbose_name="上架日期")

    offline_date = models.DateTimeField(verbose_name="下架日期")

    status_choices = ((0, '在线'), (1, '下线'))

    status = models.SmallIntegerField(choices=status_choices, default=0, verbose_name="状态")

    order = models.SmallIntegerField(default=0, verbose_name="权重", help_text="文章想置顶，可以把数字调大，不要超过1000")

    vid = models.CharField(max_length=128, verbose_name="视频VID", help_text="文章类型是视频, 则需要添加视频VID", blank=True, null=True)

    comment_num = models.SmallIntegerField(default=0, verbose_name="评论数")

    agree_num = models.SmallIntegerField(default=0, verbose_name="点赞数")

    view_num = models.SmallIntegerField(default=0, verbose_name="观看数")

    collect_num = models.SmallIntegerField(default=0, verbose_name="收藏数")

    date = models.DateTimeField(auto_now_add=True, verbose_name="创建日期")

    position_choices = ((0, '信息流'), (1, 'banner大图'), (2, 'banner小图'))

    position = models.SmallIntegerField(choices=position_choices, default=0, verbose_name="位置")

    comment = GenericRelation("Comment")  # 用于GenericForeignKey反向查询， 不会生成表字段，切勿删除，如有疑问请联系老村长

    class Meta:

        verbose_name_plural = "17. 文章"

    def __str__(self):

        return "%s-%s" % (self.source, self.title)

class ArticleDetail(models.Model):

    """文章详细"""

    article = models.OneToOneField(to='Article')

    content = models.TextField(verbose_name="文章正文")

class Collection(models.Model):

    """通用收藏表"""

    content_type = models.ForeignKey(ContentType)

    object_id = models.PositiveIntegerField()

    content_object = GenericForeignKey('content_type', 'object_id')

    account = models.ForeignKey("Account")

    date = models.DateTimeField(auto_now_add=True)

    class Meta:

        unique_together = ('content_type', 'object_id', 'account')

        verbose_name_plural = "18. 通用收藏表"

class Comment(models.Model):

    """通用的评论表"""

    content_type = models.ForeignKey(ContentType, blank=True, null=True, verbose_name="类型")

    object_id = models.PositiveIntegerField(blank=True, null=True)

    content_object = GenericForeignKey('content_type', 'object_id')

    p_node = models.ForeignKey("self", blank=True, null=True, verbose_name="父级评论")

    content = models.TextField(max_length=1024)

    account = models.ForeignKey("Account", verbose_name="会员名")

    disagree_number = models.IntegerField(default=0, verbose_name="踩")

    agree_number = models.IntegerField(default=0, verbose_name="赞同数")

    date = models.DateTimeField(auto_now_add=True)

    def __str__(self):

        return self.content

    class Meta:

        verbose_name_plural = "19. 通用评论表"

# ################# 订单相关 #################

class EnrolledCourse(models.Model):

    """已报名课程,不包括学位课程"""

    account = models.ForeignKey("Account")

    course = models.ForeignKey("Course", limit_choices_to=~Q(course_type=2))

    enrolled_date = models.DateTimeField(auto_now_add=True)

    valid_begin_date = models.DateField(verbose_name="有效期开始自")

    valid_end_date = models.DateField(verbose_name="有效期结束至")

    status_choices = ((0, '已开通'), (1, '已过期'))

    status = models.SmallIntegerField(choices=status_choices, default=0)

    order_detail = models.OneToOneField("OrderDetail")  # 使订单购买后支持 课程评价

    def __str__(self):

        return "%s:%s" % (self.account, self.course)

    class Meta:

        verbose_name_plural = "34. 报名专题课"

class ScoreRule(models.Model):

    """积分规则"""

    score_rule_choices = (

        (0, '未按时交作业'),

        (1, '未及时批改作业'),

        (2, '作业成绩'),

        (3, '未在规定时间内对学员进行跟进'),

        (4, '未在规定时间内回复学员问题'),

        (5, '收到学员投诉'),

        (6, '导师相关'),

        (7, '学位奖学金'),

    )

    rule = models.SmallIntegerField(choices=score_rule_choices, verbose_name="积分规则")

    score_type_choices = ((0, '奖励'), (1, '惩罚'), (2, '初始分配'))

    score_type = models.SmallIntegerField(choices=score_type_choices, verbose_name="奖惩", default=0)

    score = models.IntegerField(help_text="扣分数与贝里相等,若为0则代表规则的值可以从别处取得")

    # maturity_days = models.IntegerField("成熟周期", help_text="自纪录创建时开始计算")

    memo = models.TextField(blank=True, null=True)

    def __str__(self):

        return "%s-%s:%s" % (self.get_rule_display(), self.get_score_type_display(), self.score)

    class Meta:

        unique_together = ('rule', 'score_type')

        verbose_name_plural = "29. 奖惩规则"

class ScoreRecord(models.Model):

    """积分奖惩记录"""

    content_type = models.ForeignKey(ContentType, blank=True, null=True)

    object_id = models.PositiveIntegerField(blank=True, null=True)

    content_object = GenericForeignKey('content_type', 'object_id')

    degree_course = models.ForeignKey("DegreeCourse", blank=True, null=True, verbose_name="关联学位课程")

    score_rule = models.ForeignKey("ScoreRule", verbose_name="关联规则")

    account = models.ForeignKey("Account", verbose_name="被执行人")

    score = models.IntegerField(

        verbose_name="金额(贝里)")  # 这里单独有一个字段存积分而不是从score_rule里引用的原因是考虑到如果引用的话， # 一旦score_rule里的积分有变更，那么所有用户的历史积分也会被影响

    received_score = models.IntegerField("实际到账金额贝里)", help_text="仅奖励用", default=0)

    # balance = models.PositiveIntegerField(verbose_name="奖金余额(贝里)")

    maturity_date = models.DateField("成熟日期(可提现日期)")

    applied = models.BooleanField(default=False, help_text="奖赏纪录是否已被执行", verbose_name="是否已被执行")

    applied_date = models.DateTimeField(blank=True, null=True, verbose_name="事件生效日期")

    date = models.DateTimeField(auto_now_add=True, verbose_name="事件触发日期")

    memo = models.TextField(blank=True, null=True)

    def __str__(self):

        return "%s-%s - %s - %s" % (self.id, self.score_rule, self.account, self.score,)

    class Meta:

        verbose_name_plural = "30. 奖惩记录"

class CourseSchedule(models.Model):

    """课程进度计划表,针对学位课程，每开通一个模块，就为这个学员生成这个模块的推荐学习计划表，后面的奖惩均按此表进行"""

    study_record = models.ForeignKey("StudyRecord")

    homework = models.ForeignKey("Homework")

    recommend_date = models.DateField("推荐交作业日期")

    def __str__(self):

        return "%s - %s - %s " % (self.study_record, self.homework, self.recommend_date)

    class Meta:

        unique_together = ('study_record', 'homework')

        verbose_name_plural = "33. 课程模块计划表（学位课）"

class StudyRecord(models.Model):

    """学位课程的模块学习进度，报名学位课程后，每个模块会立刻生成一条学习纪录"""

    enrolled_degree_course = models.ForeignKey("EnrolledDegreeCourse")

    course_module = models.ForeignKey("Course", verbose_name="学位模块", limit_choices_to={'course_type': 2})

    open_date = models.DateField(blank=True, null=True, verbose_name="开通日期")

    end_date = models.DateField(blank=True, null=True, verbose_name="完成日期")

    status_choices = ((2, '在学'), (1, '未开通'), (0, '已完成'))

    status = models.SmallIntegerField(choices=status_choices, default=1)

    class Meta:

        verbose_name_plural = "39. 学习记录表（报名学位课程后，每个模块会立刻生成一条学习纪录）"

        unique_together = ('enrolled_degree_course', 'course_module')

    def __str__(self):

        return '%s-%s' % (self.enrolled_degree_course, self.course_module)

    def save(self, *args, **kwargs):

        if self.course_module.degree_course_id != self.enrolled_degree_course.degree_course_id:

            raise ValueError("学员要开通的模块必须与其报名的学位课程一致！")

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

class DegreeRegistrationForm(models.Model):

    """学位课程报名表"""

    enrolled_degree = models.OneToOneField("EnrolledDegreeCourse")

    current_company = models.CharField(max_length=64, )

    current_position = models.CharField(max_length=64, )

    current_salary = models.IntegerField()

    work_experience_choices = ((0, "应届生"),

                               (1, "1年"),

                               (2, "2年"),

                               (3, "3年"),

                               (4, "4年"),

                               (5, "5年"),

                               (6, "6年"),

                               (7, "7年"),

                               (8, "8年"),

                               (9, "9年"),

                               (10, "10年"),

                               (11, "超过10年"),

                               )

    work_experience = models.IntegerField()

    open_module = models.BooleanField("是否开通第1模块", default=True)

    stu_specified_mentor = models.CharField("学员自行指定的导师名", max_length=32, blank=True, null=True)

    study_plan_choices = ((0, "1-2小时/天"),

                          (1, "2-3小时/天"),

                          (2, "3-5小时/天"),

                          (3, "5小时+/天"),

                          )

    study_plan = models.SmallIntegerField(choices=study_plan_choices, default=1)

    why_take_this_course = models.TextField("报此课程原因", max_length=1024)

    why_choose_us = models.TextField("为何选路飞", max_length=1024)

    your_expectation = models.TextField("你的期待", max_length=1024)

    memo = models.CharField(max_length=255, blank=True, null=True)

    class Meta:

        verbose_name_plural = "35. 报名表（学位课）"

    def __str__(self):

        return "%s" % self.enrolled_degree

class EnrolledDegreeCourse(models.Model):

    """已报名的学位课程"""

    account = models.ForeignKey("Account")

    degree_course = models.ForeignKey("DegreeCourse")

    enrolled_date = models.DateTimeField(auto_now_add=True)

    valid_begin_date = models.DateField(verbose_name="有效期开始自", blank=True, null=True)  # 开通第一个模块时，再添加课程有效期，2年

    valid_end_date = models.DateField(verbose_name="有效期结束至", blank=True, null=True)

    status_choices = (

        (0, '在学中'),

        (1, '休学中'),

        (2, '已毕业'),

        (3, '超时结业'),

        (4, '未开始'),

        # (3, '其它'),

    )

    study_status = models.SmallIntegerField(choices=status_choices, default=0)

    mentor = models.ForeignKey("Account", verbose_name="导师", related_name='my_students',

                               blank=True, null=True, limit_choices_to={'role': 1})

    mentor_fee_balance = models.PositiveIntegerField("导师费用余额", help_text="这个学员的导师费用，每有惩罚，需在此字段同时扣除")

    order_detail = models.OneToOneField("OrderDetail")  # 使订单购买后支持填写报名表

    def __str__(self):

        return "%s:%s" % (self.account, self.degree_course)

    class Meta:

        unique_together = ('account', 'degree_course')

        verbose_name_plural = "36. 报名学位课"

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)  # 考虑到订单合并支付的问题

    account = models.ForeignKey("Account")

    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')

class TransactionRecord(models.Model):

    """贝里交易纪录"""

    account = models.ForeignKey("Account")

    amount = models.IntegerField("金额")

    balance = models.IntegerField("账户余额")

    transaction_type_choices = ((0, '收入'), (1, '支出'), (2, '退款'), (3, "提现"))  # 2 为了处理 订单过期未支付时，锁定期贝里的回退

    transaction_type = models.SmallIntegerField(choices=transaction_type_choices)

    content_type = models.ForeignKey(ContentType, blank=True, null=True)

    object_id = models.PositiveIntegerField(blank=True, null=True, verbose_name="关联对象")

    content_object = GenericForeignKey('content_type', 'object_id')

    transaction_number = models.CharField(unique=True, verbose_name="流水号", max_length=128)

    date = models.DateTimeField(auto_now_add=True)

    memo = models.CharField(max_length=128, blank=True, null=True)

    class Meta:

        verbose_name_plural = "40. 贝里交易记录"

    def __str__(self):

        return "%s" % self.transaction_number

class HomeworkRecord(models.Model):

    """学员作业记录及成绩"""

    homework = models.ForeignKey("Homework")

    student = models.ForeignKey("EnrolledDegreeCourse", verbose_name="学生")

    score_choices = ((100, 'A+'),

                     (90, 'A'),

                     (85, 'B+'),

                     (80, 'B'),

                     (70, 'B-'),

                     (60, 'C+'),

                     (50, 'C'),

                     (40, 'C-'),

                     (-1, 'D'),

                     (0, 'N/A'),

                     (-100, 'COPY'),

                     )

    score = models.SmallIntegerField(verbose_name="分数", choices=score_choices, null=True, blank=True)

    mentor = models.ForeignKey("Account", related_name="my_stu_homework_record", limit_choices_to={'role': 1},

                               verbose_name="导师")

    mentor_comment = models.TextField(verbose_name="导师批注", blank=True, null=True)  # 导师

    status_choice = (

        (0, '待批改'),

        (1, '已通过'),

        (2, '不合格'),

    )

    status = models.SmallIntegerField(verbose_name='作业状态', choices=status_choice, default=0)

    submit_num = models.SmallIntegerField(verbose_name='提交次数', default=0)

    correct_date = models.DateTimeField('备注日期', blank=True, null=True)

    note = models.TextField(blank=True, null=True)

    date = models.DateTimeField("作业提交日期", auto_now_add=True)

    check_date = models.DateTimeField("批改日期", null=True, blank=True)

    update_time = models.DateTimeField(auto_now=True, verbose_name="提交日期")

    # homework_path = models.CharField(verbose_name='作业路径', max_length=256,blank=True,null=True) 作业路径可以动态拿到，没必要存

    reward_choice = ((0, '新提交'),

                     (1, '按时提交'),

                     (2, '未按时提交'),

                     (3, '成绩已奖励'),

                     (4, '成绩已处罚'),

                     (5, '未作按时检测'),

                     )

    reward_status = models.SmallIntegerField(verbose_name='作业记录奖惩状态', default=0)

    def __str__(self):

        return "%s %s" % (self.homework, self.student)

    class Meta:

        verbose_name_plural = "41. 作业"

        unique_together = ("homework", "student")

class StuFollowUpRecord(models.Model):

    """学员跟进记录"""

    enrolled_degree_course = models.ForeignKey("EnrolledDegreeCourse", verbose_name="学生")

    mentor = models.ForeignKey("Account", related_name='mentor', limit_choices_to={'role': 1}, verbose_name="导师")

    followup_tool_choices = ((0, 'QQ'), (1, '微信'), (2, '电话'), (3, '系统通知'))

    followup_tool = models.SmallIntegerField(choices=followup_tool_choices, default=1)

    record = models.TextField(verbose_name="跟进记录")

    attachment_path = models.CharField(max_length=128, blank=True, null=True, verbose_name="附件路径", help_text="跟进记录的截图等")

    date = models.DateTimeField(auto_now_add=True)

    class Meta:

        verbose_name_plural = "42. 学员跟进记录"

    def __str__(self):

        return "%s --%s --%s" % (self.enrolled_degree_course, self.record, self.date)

后端接收：

    贝里的数量和付款金额 

a. 去结算中心获取要支付课程

b. 生成订单

c. 生成 订单详细，专题课购买表（如果优惠券>实际金额，则按照实际扣款）

d. 如果使用了贝里，在贝里交易表中，记录一下；

e. 优惠券表更新

f. 计算规则：

    前端发送的金额和后端计算的金额 --> 相同，跳转到支付宝支付；

    后端计算规则:

    先计算绑定课程的优惠券

    总价再使用未绑定课程优惠券

    贝里抵扣

    最终得到，实际付款金额

注意：多个表操作，使用事务 

import json

import redis

from django.conf import settings

from rest_framework.views import APIView

from rest_framework.viewsets import ViewSetMixin

from rest_framework.response import Response

from api.utils.auth import LuffyAuthentication

from api import models

from api.utils.response import BaseResponse

from django_redis import get_redis_connection

CONN = get_redis_connection("default")  # 使用redis连接池

class PaymentView(ViewSetMixin, APIView):

    authentication_classes = [LuffyAuthentication, ]

    def create(self, request, *args, **kwargs):

        """

        在结算中添加课程

        :param request:

        :param args:

        :param kwargs:

        :return:

        """

        # 1.接收用户选择的要结算的课程ID列表

        choice_list = request.data.get('course_id')

        # print(choice_list)

        # 2.清空当前用户request.user.id结算中心的数据

        #   key = payment_1*

        CONN.delete('payment_1*')

        # 3.循环要加入结算中的所有课程ID列表

        """

        for course_id in 用户提交课程ID列表:

            3.1 根据course_id,request.user.id去购物车中获取商品信息：商品名称、图片、价格（id,周期,显示周期,价格）

            3.2 根据course_id,request.user.id获取

                    - 当前用户

                    - 当前课程

                    - 可用的优惠券

            加入结算中心

            提示：可以使用contenttypes

        """

        '''

        # 2.1 课程是否存在？

        temp = {

                    'id': CONN.hget(key, 'id').decode('utf-8'),

                    'name': CONN.hget(key, 'name').decode('utf-8'),

                    'img':CONN.hget(key, 'img').decode('utf-8'),

                    'default_price_id':CONN.hget(key, 'default_price_id').decode('utf-8'),

                    'price_policy_dict': json.loads(CONN.hget(key, 'price_policy_dict').decode('utf-8'))

                }

        '''

        user_id = request.user.id

        print('用户id', user_id)

        # 从购物车中获取数据

        pattern = "shopping_car_%s_%s" % (request.user.id, '*',)

        # print(pattern)

        user_key_list = CONN.keys(pattern)

        for course_id in choice_list:  # 用户选择的要结算的课程ID列表

            for key in user_key_list:  # 当前用户购物车列表

                id = CONN.hget(key, 'id').decode('utf-8')  # 获取购物车课程id

                if id == course_id:  # 判断用户选择课程id和购物车课程id相等

                    name = CONN.hget(key, 'name').decode('utf-8')  # 课程名

                    default_price_id = CONN.hget(key, 'default_price_id').decode('utf-8')  # 默认价格策略id

                    # 所有价格策略

                    price_policy_dict = json.loads(CONN.hget(key, 'price_policy_dict').decode('utf-8'))

                    print('课程id',id)

                    print('课程名',name)

                    print('默认价格策略',default_price_id)

                    valid_period = price_policy_dict[default_price_id].get('valid_period_display')

                    print('有效期', valid_period)

                    print('原价',price_policy_dict[default_price_id].get('price'))

                    print('折后价', price_policy_dict[default_price_id].get('price'))

                    print('所有价格策略',price_policy_dict)

                    # 加入结算中心redis

                    j_key = "payment_%s_%s" % (user_id, id,)

                    CONN.hset(j_key, 'id', course_id)

                    CONN.hset(j_key, 'name', name)

                    CONN.hset(j_key, 'price_id', default_price_id)

                    CONN.hset(j_key, 'price', price_policy_dict[default_price_id].get('price'))

                    CONN.hset(j_key, 'valid_period', valid_period)

                    CONN.hset(j_key, 'discount_price', price_policy_dict[default_price_id].get('price'))

                    # 查询当前课程的 绑定课程优惠券

                    obj1 = models.Course.objects.filter(id=id).first()

                    if obj1.coupon.all():  # 反向查询该课程的所有优惠券

                        print("绑定课程优惠券#########################")

                        for i in obj1.coupon.all():  # 循环每一个优惠券

                            print('绑定课程优惠券个数',len(obj1.coupon.all()))

                            coupon_dict = {}  # 空字典

                            for j in range(len(obj1.coupon.all())):  # for循环长度

                                if i.coupon_type == 0:  # 类型为立减

                                    coupon_dict[j] = '{}{}'.format(i.get_coupon_type_display(), i.money_equivalent_value)

                                    # 增加到redis中

                                    CONN.hset(j_key, 'coupon_dict', coupon_dict)

                                    # print(111)

                                    print(

                                        '{}{}'.format(i.get_coupon_type_display(), i.money_equivalent_value))

                                elif i.coupon_type == 1:

                                    coupon_dict[j] = '满{}减{}'.format(i.minimum_consume, i.money_equivalent_value)

                                    CONN.hset(j_key, 'coupon_dict', coupon_dict)

                                    print('满{}减{}'.format(i.minimum_consume, i.money_equivalent_value))

                                else:

                                    # print(i.id)

                                    coupon_dict[j] = '{}折'.format(i.off_percent)

                                    CONN.hset(j_key, 'coupon_dict', coupon_dict)

                                    print('{}折'.format(i.off_percent))

        # 绑定课程的优惠券

        # obj = models.CouponRecord.objects.filter(account=user_id, coupon__object_id__isnull=False)

        # print('绑定课程优惠券#################')

        # if obj:

        #     for i in obj:

        #         if i.coupon.coupon_type == 0:

        #             print('{}{}'.format(i.coupon.get_coupon_type_display(), i.coupon.money_equivalent_value))

        #         elif i.coupon.coupon_type == 1:

        #             print('满{}减{}'.format(i.coupon.minimum_consume, i.coupon.money_equivalent_value))

        #         else:

        #             # print(i.coupon.id)

        #             print('{}折'.format(i.coupon.off_percent))

        # 4.获取当前用户所有未绑定课程优惠券

        #       - 未使用

        #       - 有效期内

        #       - 加入结算中心：glocal_coupon_用户ID

        # 当前用户未绑定课程的优惠券

        obj2 = models.CouponRecord.objects.filter(account=user_id, coupon__object_id__isnull=True)

        print('未绑定课程优惠券#################')

        if obj2:

            # 通用优惠券redis key

            coupon_key = "general_coupon_%s" % (user_id)

            for i in obj2:

                general_coupon_dict = {}  # 空字典

                print('未绑定课程优惠券个数 %s' % (len(obj2)))

                for j in range(len(obj2)):

                    if i.coupon.coupon_type == 0:  # 类型为立减

                        general_coupon_dict[j] = '{}{}'.format(i.coupon.get_coupon_type_display(), i.coupon.money_equivalent_value)

                        CONN.hset(coupon_key, 'coupon_dict', general_coupon_dict)

                        print('{}{}'.format(i.coupon.get_coupon_type_display(), i.coupon.money_equivalent_value))

                    elif i.coupon.coupon_type == 1:

                        general_coupon_dict[j] = '满{}减{}'.format(i.coupon.minimum_consume, i.coupon.money_equivalent_value)

                        CONN.hset(coupon_key, 'coupon_dict', general_coupon_dict)

                        print('满{}减{}'.format(i.coupon.minimum_consume, i.coupon.money_equivalent_value))

                    else:

                        general_coupon_dict[j] = '{}折'.format(i.coupon.off_percent)

                        CONN.hset(coupon_key, 'coupon_dict', general_coupon_dict)

                        print('{}折'.format(i.coupon.off_percent))

        return Response('ok')

    def list(self, request, *args, **kwargs):

        """

        查看结算中心

        :param request:

        :param args:

        :param kwargs:

        :return:

        """

        # 1. 根据用户ID去结算中心获取该用户所有要结算课程

        course_id = request.query_params.get('course_id')

        print('课程id',course_id)

        obj = models.Course.objects.filter(id=course_id).first()

        print('结算课程',obj.name)

        # 2. 根据用户ID去结算中心获取该用户所有可用未绑定课程的优惠券

        user_id =request.user.id

        print('用户id', user_id)

        obj2 = models.CouponRecord.objects.filter(account=user_id, coupon__object_id__isnull=True)

        if obj2:

            for i in obj2:

                if i.coupon.coupon_type == 0:

                    print('{}{}'.format(i.coupon.get_coupon_type_display(), i.coupon.money_equivalent_value))

                elif i.coupon.coupon_type == 1:

                    print('满{}减{}'.format(i.coupon.minimum_consume, i.coupon.money_equivalent_value))

                else:

                    print(i.coupon.id)

                    print('{}折'.format(i.coupon.off_percent))

        # 3. 用户表中获取贝里余额

        beili = models.Account.objects.filter(id=user_id).first()

        print('用户贝里',beili.balance)

        # 4. 以上数据构造成一个字典

        return Response('...')

    def update(self, request, *args, **kwargs):

        """

        更新优惠券

        :param request:

        :param args:

        :param kwargs:

        :return:

        """

        # 1. 获取用户提交：

        #       course_id=1,coupon_id=3

        #       course_id=0,coupon_id=6

        # 2. course_id=1 --> 去结算中心获取当前用户所拥有的绑定当前课程优惠，并进行校验

        #       - 成功：defaul_coupon_id=3

        #       - 否则：非法请求

        # 3. course_id=0 --> 去结算中心获取当前用户所拥有的未绑定课程优惠，并进行校验

        #       - 成功：defaul_coupon_id=3

        #       - 否则：非法请求

用户id 1

课程id 1

课程名 Python开发入门7天特训营

默认价格策略 1

有效期 1周

原价 10.0

折后价 10.0

所有价格策略 {'': {'valid_period': 30, 'id': 2, 'price': 50.0, 'valid_period_display': '1个月'}, '': {'valid_period': 7, 'id': 1, 'price': 10.0, 'valid_period_display': '1周'}}

绑定课程优惠券#########################

绑定课程优惠券个数 2

8折

8折

绑定课程优惠券个数 2

满50减10

满50减10

未绑定课程优惠券#################

未绑定课程优惠券个数 1

立减10

课程id 1

结算课程 Python开发入门7天特训营

用户id 1

立减10

用户贝里 100.0