去支付相关表结构
# ########################### 5. 支付相关 ################################
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=100
off_percent=null
minimum_consume=0
满减：
money_equivalent_value=100
off_percent=null
minimum_consume=1000
折扣：
money_equivalent_value=0
off_percent=79
minimum_consume=0
"""
money_equivalent_value = models.IntegerField(verbose_name="等值货币")
off_percent = models.PositiveSmallIntegerField("折扣百分比", help_text="只针对折扣券，例7.9折，写79", blank=True, null=True)
minimum_consume = models.PositiveIntegerField("最低消费", default=0, help_text="仅在满减券时填写此字段")
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)
account = models.ForeignKey("Account", 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.account, self.number, self.status)
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 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") # 使订单购买后支持 课程评价
# order = models.ForeignKey("Order",blank=True,null=True)
def __str__(self):
return "%s:%s" % (self.account, self.course)
class Meta:
verbose_name_plural = "34. 报名专题课"
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 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 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)
Order
订单表，payment_number表示支付第3方订单号。比如：用户使用支付宝付款后，支付宝会发送一条POST请求，访问你的服务器，它会携带一个支付宝产生的订单号。这个就是payment_number的作用，用来进行后续的查询是否到账了！
actual_amount 表示抛开使用优惠券，贝里之后，实际付款的金额！
OrderDetail
订单详细表，content表示备注，用来给运营人员来加一些备注信息！
TransactionRecord
贝里交易纪录，当付款使用贝里时，这里会产生一条记录！
DegreeRegistrationForm
学位课程报名表，当用户购买学位课程后，是不能直接观看视频的。需要添加报名表才行，需要填写一些相关信息。有了这些信息后，才能给用户分配导师，促进学习！
ScoreRule
积分规则，主要约束导师的。初始分配：学员分配到某位导师后，这位导师的账户就会多一些积分，比如1500贝里。
如果学员未交作业，导师没有批改作业，受到学员投诉.... 都是要扣贝里的。这些贝里，到一定时间是可以提现的！
成熟周期这里注释掉了，意思就是学员毕业，就可以提现了！
在linux上面做了一个任务计划，每天凌晨2点跑一个脚本，用来更新成熟周期。
EnrolledCourse
已报名课程，不包括学位课程。也就是说，它只负责专题课。
当用户购买一个专题课后，需要在EnrolledCourse，Order，OrderDetail。这3个表产生记录即可
如果使用贝里支付，还需要操作TransactionRecord表。
设计到优惠券，还需要操作优惠券相关的表
如果是购买了学位课，除了EnrolledCourse表之外，其他表都要操作！
当点击立即支付时，会向后端发送一些数据。发送哪些数据呢？
将页面的课程相关信息都发送过去？没有必要！为什么呢？
因为结算中心的数据，是存放在redis中的。所以发送时，只需要发送2个数据。
使用的贝里数，以及经过计算后的金额。后端接收到这2个数据时，再根据结算中心的数据，做计算。
当前端发送的金额和后端计算的金额一致时，跳转到支付宝页面，否则提示计算错误！
为什么呢？因为用户页面看到的是498，结果跳转到支付宝页面时，要付款510块，用户肯定不干了！
计算规则是这样的，先计算使用绑定课程的优惠券，然后将所有计算后的所有课程，做一个总价。
最后使用未绑定课程的优惠券，对总价进行计算。再使用贝里抵扣，最终得到实际付款金额！
注意：如果优惠券的金额大于实际课程的金额，则按照实际扣除。那么这个优惠券就不能使用了！没有返现的功能！
多个表操作时，要基于事务来做
实现代码
class OrderViewSet(APIView):
def post(self,request,*args,**kwargs):
"""
立即支付
:param request:
:param args:
:param kwargs:
:return:
"""
"""
1. 获取用户提交数据
{
balance:1000,
money:900
}
balance = request.data.get("balance")
money = request.data.get("money")
2. 数据验证
- 大于等于0
- 个人账户是否有1000贝里
if user.auth.user.balance < balance:
账户贝里余额不足
优惠券ID_LIST = [1,3,4]
总价
实际支付
3. 去结算中获取课程信息
for course_dict in redis的结算中获取：
# 获取课程ID
# 根据course_id去数据库检查状态
# 获取价格策略
# 根据policy_id去数据库检查是否还依然存在
# 获取使用优惠券ID
# 根据优惠券ID检查优惠券是否过期
# 获取原价+获取优惠券类型
- 立减
0 = 获取原价 - 优惠券金额
或
折后价格 = 获取原价 - 优惠券金额
- 满减：是否满足限制
折后价格 = 获取原价 - 优惠券金额
- 折扣：
折后价格 = 获取原价 * 80 / 100
4. 全站优惠券
- 去数据库校验全站优惠券的合法性
- 应用优惠券：
- 立减
0 = 实际支付 - 优惠券金额
或
折后价格 =实际支付 - 优惠券金额
- 满减：是否满足限制
折后价格 = 实际支付 - 优惠券金额
- 折扣：
折后价格 = 实际支付 * 80 / 100
- 实际支付
5. 贝里抵扣
6. 总金额校验
实际支付 - 贝里 = money:900
7. 为当前课程生成订单
基于事务
- 订单表创建一条数据 Order
- 订单详细表创建一条数据 OrderDetail EnrolledCourse
- 订单详细表创建一条数据 OrderDetail EnrolledCourse
- 订单详细表创建一条数据 OrderDetail EnrolledCourse
- 如果有贝里支付
- 贝里金额扣除 Account
- 交易记录 TransactionRecord
- 优惠券状态更新 CouponRecord
注意：
如果支付宝支付金额0， 表示订单状态：已支付
如果支付宝支付金额110，表示订单状态：未支付
- 生成URL（含订单号）
- 回调函数：更新订单状态
"""
pass
去支付代码的实现
class OrderViewSet(APIView):
conn = get_redis_connection("default")
def post(self,request,*args,**kwargs):
try:
self.ret = BaseResponse
# 获取用户抵用的贝里
balance =request.data.get('balance')
# 获取用户提交的金额
money=request.data.get('money')
self.check_valid(request,balance,money)
if self.ret.code !=1000:
return Response(self.ret.dict)
self.create_model(request)
self.ret.data='支付成功'
except ObjectDoesNotExist as e:
self.ret.code=1008
self.ret.error='获取model不存在'
except IndexError as e:
self.ret.code=1009
self.ret.error='index错误'
except Exception as e:
self.ret.code=1010
self.ret.error='错误'
return Response(self.ret.dict)
def check_valid(self,request,balance,money):
'''校验合法性'''
# 如果提交的结算金额小于0
if money < 0 :
self.ret.code=1001
self.ret.error='结算金额必须大于等于0'
return
# 如果用户拥有的贝里小于优惠的贝里
if request.auth.user.balance < balance:
self.ret.code=1002
self.ret.error='客户的贝里不足'
return
# 构建查找该用户结算所有的信息key
payment_key=settings.PAMENT_KEY%(request.auth.user_id,'*')
# 需要更新的状态优惠券id
self.coupon_list=[]
go_pay_dict={}
for key in self.conn.scan_iter(payment_key):
# 获取结算课程的id、使用的优惠券、课程价格策略
course_id=self.conn.hget(key,'course_id').decode('utf-8')
use_coupon=self.conn.hget(key,'default_coupon').decode('utf-8')
policy_id=self.conn.hget(key,'prolicy_id').decode('utf-8')
coupon_dict=json.loads(str(self.conn.hget(key,'coupon')),encoding='utf-8').get(use_coupon)
# 判断课程是否已经下载
if not models.Course.objects.filter(id=course_id,status=0).exists():
self.ret.code=1003
self.ret.error='课程已经下架'
return
# 判断价格策略是否合法
if not models.PricePolicy.objects.filter(id=policy_id,object_id=course_id).exists():
self.ret.code=1005
self.ret.error='价格策略不合法'
return
# 判断优惠券是否合法
coupon_obj=models.CouponRecord.objects.filter(id=use_coupon,status=0,account=request.auth.user,
coupon__object_id=course_id).first()
# 使用了优惠券,但是优惠券不存在
if use_coupon!='0' and not coupon_obj:
self.ret.code=1004
self.ret.error='使用的优惠券不存在'
return
# 如果没有使用优惠券
if use_coupon=='0':
go_pay_dict[course_id] = {}
# 如果使用了课程优惠券
else:
go_pay_dict[course_id] = coupon_dict
self.coupon_list.append({'id':use_coupon,'coupon':coupon_obj.coupon_id})
# 构建购数据
go_pay_dict[course_id]['price'] = self.conn.hget(key,'price').decode('utf-8')
go_pay_dict[course_id]['valid_period']=self.conn.hget(key,'valid_period').decode('utf-8')
# 计算课程类优惠券
course_money=0
for key,values in go_pay_dict.items():
#获取该优惠券类型
coupon_type=values.get('coupon_type')
price=int(values.get('price'))
if not coupon_type:
course_money+=price
continue
if coupon_type =='0':
course_money+=price-int(values.get('money_equivalent_value'))
elif coupon_type=='1':
minimum_consume=int(values.get('minimum_consume'))
if not minimum_consume < price:
self.ret.code=1005
self.ret.error='该课程没有达到满减要求'
course_money+=price-int(values.get('money_equivalent_value'))
else:
course_money=course_money+price*int(values.get('off_percent'))/100
go_pay_dict[key]['coupon_money']=course_money
price = self.handler_galbal(request,course_money)
self.handler_order(request.auth.user_id,price)
self.handler_order_detail(go_pay_dict,)
def handler_galbal(self,request,course_money):
# 构造获取该用户全局的key
global_default_key = settings.PAMENT_COUPON_KEY % (request.auth.user_id,)
global_default_coupon = self.conn.hget(global_default_key, 'default_key')
# 如果没有使用优惠券
if global_default_coupon == '0':
return course_money
# 全站使用优惠券
else:
# 判断全站优惠券是否合法
coupon_obj = models.CouponRecord.objects.filter(id=global_default_coupon, status=0,
account=request.auth.user).first()
if not coupon_obj:
self.ret.code = 1006
self.ret.error = '全站优惠券不合法'
#获取使用的全站优惠券信息
self.coupon_list.append(({'id':global_default_coupon,'coupon':coupon_obj.coupon_id}))
global_coupon_dict = json.loads(str(self.conn.hget(global_default_key, 'coupon')), encoding='utf-8'). \
get(global_default_coupon)
# 获取全站优惠券的类型
glo_bal_coupon_type = global_coupon_dict.get('coupon_type')
# 如果全站优惠券是通用券
if glo_bal_coupon_type == '0':
global_money =course_money-int(global_coupon_dict.get('money_equivalent_value'))
# 如果全站优惠券是满减卷
elif glo_bal_coupon_type == '1':
minimum_consume = int(global_coupon_dict.get('minimum_consume'))
if not minimum_consume < course_money:
self.ret.code = 1005
self.ret.error = '该课程没有达到满减要求'
global_money = course_money - int(global_coupon_dict.get('money_equivalent_value'))
# 如果全站优惠券是折扣券
else:
global_money = course_money * int(global_coupon_dict.get('off_percent')) / 100
#如果减到为负数
if global_money<0:
global_money=0
return global_money
def handler_order(self,account_id,actual_amount):
'''构造生成订单的字典'''
self.order_dict={
'payment_type':1,
'order_number':str(uuid.uuid4()),
'account':account_id,
'actual_amount':actual_amount,
'status':1,
}
def handler_order_detail(self,pay_dict):
self.order_list=[]
for key,values in pay_dict.items():
info={
'content_object':models.Course.objects.get(id=key),
'original_price':values.get('price'),
'price':values.get('coupon_money'),
'valid_period_display':values.get('valid_period'),
'valid_period':values.get('valid_period'),
}
self.order_list.append(info)
def create_model(self,request):
with transaction.atomic():
order_obj=models.Order.objects.create(**self.order_dict)
temp=[]
for item in self.order_list:
item['order']=order_obj
obj=models.OrderDetail(**item)
temp.append(obj)
models.OrderDetail.objects.bulk_create(temp)
now=datetime.datetime.now()
for obj in self.coupon_list:
obj['account_id']=request.auth.user_id
obj['status']=0
models.CouponRecord.objects.filter(**obj).update(status=1,used_time=now)