订单表设计
# 订单板块需要写的接口
-写单接口---》没有支付的订单是待支付状态
-支付宝post回调接口---》修改订单状态成已支付
-前端get回调接口
# 订单板块表设计
-订单表
-订单详情表
# 新建oder的app,在models.py中写入表
from django.db import models
from django.db import models
from user.models import User
from course.models import Course
class Order(models.Model):
"""订单模型"""
status_choices = (
(0, '未支付'),
(1, '已支付'),
(2, '已取消'),
(3, '超时取消'),
)
pay_choices = (
(1, '支付宝'),
(2, '微信支付'),
)
# 订单标题
subject = models.CharField(max_length=150, verbose_name="订单标题")
# 订单总价格
total_amount = models.DecimalField(max_digits=10, decimal_places=2, verbose_name="订单总价", default=0)
# 订单号，咱们后端生成的，唯一：后期支付宝回调回来的数据会带着这个订单号，根据这个订单号修改订单状态
# 使用什么生成？ uuid（可能重复，概率很多） 【分布式id的生成】 雪花算法
out_trade_no = models.CharField(max_length=64, verbose_name="订单号", unique=True)
# 流水号：支付宝生成的，回调回来，会带着
trade_no = models.CharField(max_length=64, null=True, verbose_name="流水号")
# 订单状态
order_status = models.SmallIntegerField(choices=status_choices, default=0, verbose_name="订单状态")
# 支付类型，目前只有支付宝
pay_type = models.SmallIntegerField(choices=pay_choices, default=1, verbose_name="支付方式")
# 支付时间---》支付宝回调回来，会带着
pay_time = models.DateTimeField(null=True, verbose_name="支付时间")
# 跟用户一对多 models.DO_NOTHING
user = models.ForeignKey(User, related_name='order_user', on_delete=models.DO_NOTHING, db_constraint=False,
verbose_name="下单用户")
created_time = models.DateTimeField(auto_now_add=True, verbose_name='创建时间')
class Meta:
db_table = "luffy_order"
verbose_name = "订单记录"
verbose_name_plural = "订单记录"
def __str__(self):
return "%s - ￥%s" % (self.subject, self.total_amount)
class OrderDetail(models.Model):
"""订单详情"""
# related_name 反向查询替换表名小写_set
# on_delete 级联删除
# db_constraint=False ----》默认是True，会在表中为Order何OrderDetail创建外键约束
# db_constraint=False 没有外键约束，插入数据 速度快， 可能会产生脏数据【不合理】，所以咱们要用程序控制，以后公司惯用的
# 对到数据库上，它是不建立外键，基于对象的跨表查，基于连表的查询，继续用，跟之前没有任何区别
order = models.ForeignKey(Order, related_name='order_courses', on_delete=models.CASCADE, db_constraint=False,
verbose_name="订单")
course = models.ForeignKey(Course, related_name='course_orders', on_delete=models.DO_NOTHING, db_constraint=False,
verbose_name="课程")
price = models.DecimalField(max_digits=6, decimal_places=2, verbose_name="课程原价")
real_price = models.DecimalField(max_digits=6, decimal_places=2, verbose_name="课程实价")
class Meta:
db_table = "luffy_order_detail"
verbose_name = "订单详情"
verbose_name_plural = "订单详情"
def __str__(self):
try:
return "%s的订单：%s" % (self.course.name, self.order.out_trade_no)
except:
return super().__str__()
ForeignKey 中on_delete
-CASCADE 级联删除
-DO_NOTHING 啥也不做,没有外键约束才能用它,所以需要db_constraint=False
-SET_NULL 字段设置为空,字段null=True
-SET_DEFAULT 设置为默认值,需要default='xx'
-PROTECT 受保护的,很少用
-models.SET(可以放函数内存地址) 会设置成set内的值
db_constraint=False ----》默认是True，会在表中为Order何OrderDetail创建外键约束
db_constraint=False 没有外键约束，插入数据 速度快， 可能会产生脏数据【不合理】，所以咱们要用程序控制，以后公司惯用的
下单接口
# 登录后才能用---》前端立即点击购买---》post---》携带数据课程列表,总价,订单标题
{courses:[1,],total_amount:99.9,subject:'xx课程'}----》视图类中重写create方法---》主要逻辑写到序列化类中
主要逻辑：
1.取出所有课程对象，统计总价
2.跟传入的total_amount做比较,如果一样,继续往后
3.获取后买人信息,登录后才能访问的接口 request.user
4.生成订单号,支付链接需要在订单表中需要
5.生成支付链接,支付宝生成
6.生成订单记录,订单是待支付状态(order,order_detail)
7.返回前端支付链接
配置文件,配置路由
# 后台基URL
BACKEND_URL = 'http://127.0.0.1:8000'
# 前台基URL
LUFFY_URL = 'http://127.0.0.1:8080'
# 支付宝同步异步回调接口配置
# 后台异步回调接口
NOTIFY_URL = BACKEND_URL + "/api/v1/order/success/" # 如果这个接口不对，支付宝永远掉不回来，订单状态永远不会改
# 前台同步回调接口，没有 / 结尾
RETURN_URL = LUFFY_URL + "/pay/success"
序列化类
# 校验字段，反序列化 不会序列化的
class PaySerializer(serializers.ModelSerializer):
# courses 不是表的字段，需要重写--->新东西
# courses=serializers.ListField() # 咱们不用这种 courses=[1,2,3]
# 前端传入的 courses=[1,2,3]--->根据queryset对应的qs对象 做映射，映射成courses=[课程对象1，课程对象2，课程对象3]
courses = serializers.PrimaryKeyRelatedField(queryset=Course.objects.all(), many=True)
class Meta:
model = Order
fields = ['courses', 'total_amount', 'subject'] # 前端传入的字段是什么，这里就写什么
def _check_total_amount(self, attrs):
courses = attrs.get('courses') # 课程对象列表 [课程对象1，课程对象2]
total_amount = attrs.get('total_amount')
new_total_amount = 0
for course in courses:
new_total_amount += course.price
if total_amount == new_total_amount:
return new_total_amount
raise APIException('价格有误！！')
def _get_out_trade_no(self):
# uuid生成
return str(uuid.uuid4())
def _get_user(self):
user = self.context.get('request').user
return user
def _get_pay_url(self, out_trade_no, total_amount, subject):
# 生成支付链接
res = alipay.api_alipay_trade_page_pay(
total_amount=float(total_amount),
subject=subject,
out_trade_no=out_trade_no,
return_url=settings.RETURN_URL, # 前端的
notify_url=settings.NOTIFY_URL # 后端接口，写这个接口该订单状态
)
# return GATEWAY + res
self.context['pay_url'] = GATEWAY + res
def _before_create(self, attrs, user, out_trade_no):
# 剔除courses----》要不要剔除,要pop，但是不在这，在create方法中pop
# 订单号，加入到attrs中
attrs['out_trade_no'] = out_trade_no
# 把user加入到attrs中
attrs['user'] = user
def validate(self, attrs):
# 1）订单总价校验
total_amount = self._check_total_amount(attrs)
# 2）生成订单号
out_trade_no = self._get_out_trade_no()
# 3）支付用户：request.user
user = self._get_user()
# 4）支付链接生成
self._get_pay_url(out_trade_no, total_amount, attrs.get('subject'))
# 5）入库(两个表)的信息准备
self._before_create(attrs, user, out_trade_no)
return attrs
# 生成订单，存订单表，一定要重写create，存俩表
def create(self, validated_data):
# validated_data:{subject,total_amount,user,out_trade_no,courses}
courses = validated_data.pop('courses')
order = Order.objects.create(**validated_data)
# 存订单详情表，存几条，取决于courses有几个
for course in courses:
OrderDetail.objects.create(order=order, course=course, price=course.price, real_price=course.price)
return order
视图类
class PayView(GenericViewSet, CreateModelMixin):
queryset = Order.objects.all()
serializer_class = PaySerializer
authentication_classes = [OrderAuthentication]
def create(self, request, *args, **kwargs):
# 这句话调用序列化类的反序列化校验
serializer = self.get_serializer(data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
pay_url = serializer.context.get('pay_url')
print(pay_url)
return APIResponse(pay_url=pay_url)
认证类
from rest_framework_jwt.authentication import JSONWebTokenAuthentication
from rest_framework_jwt.settings import api_settings
import jwt
from rest_framework import exceptions
jwt_decode_handler = api_settings.JWT_DECODE_HANDLER
class OrderAuthentication(JSONWebTokenAuthentication):
def authenticate(self, request):
jwt_value = request.META.get('HTTP_TOKEN')
if jwt_value is None:
return None
try:
payload = jwt_decode_handler(jwt_value)
except jwt.ExpiredSignature:
raise exceptions.APIException('token已过期')
except jwt.DecodeError:
raise exceptions.APIException('没有携带token')
except jwt.InvalidTokenError:
raise exceptions.APIException('无效的token')
user = self.authenticate_credentials(payload)
return (user, jwt_value)
路由
# http://127.0.0.1:8000/api/v1/order/pay/pay/
router.register('pay',views.PayView,'pay')
前端支付页面
CourseDetail.vue
go_pay() {
// 判断是否登录
let token = this.$cookies.get('token')
if (token) {
this.$axios.post(this.$settings.BASE_URL + '/order/pay/', {
subject: this.course_info.name,
total_amount: this.course_info.price,
courses: [this.course_id]
}, {
headers: {
Authorization: `jwt ${token}`
}
}).then(res => {
if (res.data.code == 100) {
// 打开支付连接地址
open(res.data.pay_url, '_self');
} else {
this.$message(res.data.msg)
}
})
} else {
this.$message('您没有登录，请先登录')
}
}
PaySuccess.vue
<template>
<div class="pay-success">
<!--如果是单独的页面，就没必要展示导航栏(带有登录的用户)-->
<Header/>
<div class="main">
<div class="title">
<div class="success-tips">
<p class="tips">您已成功购买 1 门课程！</p>
</div>
</div>
<div class="order-info">
<p class="info"><b>订单号：</b><span>{{ result.out_trade_no }}</span></p>
<p class="info"><b>交易号：</b><span>{{ result.trade_no }}</span></p>
<p class="info"><b>付款时间：</b><span><span>{{ result.timestamp }}</span></span></p>
</div>
<div class="study">
<span>立即学习</span>
</div>
</div>
</div>
</template>
<script>
import Header from "@/components/Header"
export default {
name: "Success",
data() {
return {
result: {},
};
},
created() {
// 解析支付宝回调的url参数
let params = location.search.substring(1); // 去除? => a=1&b=2
let items = params.length ? params.split('&') : []; // ['a=1', 'b=2']
//逐个将每一项添加到args对象中
for (let i = 0; i < items.length; i++) { // 第一次循环a=1，第二次b=2
let k_v = items[i].split('='); // ['a', '1']
//解码操作，因为查询字符串经过编码的
if (k_v.length >= 2) {
// url编码反解
let k = decodeURIComponent(k_v[0]);
this.result[k] = decodeURIComponent(k_v[1]);
// 没有url编码反解
// this.result[k_v[0]] = k_v[1];
}
}
// 把地址栏上面的支付结果，再get请求转发给后端
this.$axios({
url: this.$settings.BASE_URL + '/order/success/' + location.search,
method: 'get',
}).then(response => {
if (response.data.code != 100) {
alert(response.data.msg)
}
}).catch(() => {
console.log('支付结果同步失败');
})
},
components: {
Header,
}
}
</script>
<style scoped>
.main {
padding: 60px 0;
margin: 0 auto;
width: 1200px;
background: #fff;
}
.main .title {
display: flex;
-ms-flex-align: center;
align-items: center;
padding: 25px 40px;
border-bottom: 1px solid #f2f2f2;
}
.main .title .success-tips {
box-sizing: border-box;
}
.title img {
vertical-align: middle;
width: 60px;
height: 60px;
margin-right: 40px;
}
.title .success-tips {
box-sizing: border-box;
}
.title .tips {
font-size: 26px;
color: #000;
}
.info span {
color: #ec6730;
}
.order-info {
padding: 25px 48px;
padding-bottom: 15px;
border-bottom: 1px solid #f2f2f2;
}
.order-info p {
display: -ms-flexbox;
display: flex;
margin-bottom: 10px;
font-size: 16px;
}
.order-info p b {
font-weight: 400;
color: #9d9d9d;
white-space: nowrap;
}
.study {
padding: 25px 40px;
}
.study span {
display: block;
width: 140px;
height: 42px;
text-align: center;
line-height: 42px;
cursor: pointer;
background: #ffc210;
border-radius: 6px;
font-size: 16px;
color: #fff;
}
</style>
支付成功回调接口
get 给自己用
post 给支付宝用
# 该接口不要加认证和权限
class PaySuccess(APIView):
def get(self, request): # 咱们用的
out_trade_no = request.query_params.get('out_trade_no')
order = Order.objects.filter(out_trade_no=out_trade_no, order_status=1).first()
if order: # 支付宝回调完， 订单状态改了
return APIResponse()
else:
return APIResponse(code=101, msg='暂未收到您的付款，请稍后刷新再试')
def post(self, request): # 给支付宝用的，项目需要上线后才能看到 内网中，无法回调成功【使用内网穿透】
try:
result_data = request.data.dict() # requset.data 是post提交的数据，如果是urlencoded格式，requset.data是QueryDict对象，方法dict()---》转成真正的字典
out_trade_no = result_data.get('out_trade_no')
signature = result_data.pop('sign')
# 验证签名的---》验签
result = alipay_v1.alipay.verify(result_data, signature)
if result and result_data["trade_status"] in ("TRADE_SUCCESS", "TRADE_FINISHED"):
# 完成订单修改：订单状态、流水号、支付时间
Order.objects.filter(out_trade_no=out_trade_no).update(order_status=1)
# 完成日志记录
logger.warning('%s订单支付成功' % out_trade_no)
return Response('success') # 都是支付宝要求的
else:
logger.error('%s订单支付失败' % out_trade_no)
except:
pass
return Response('failed') # 都是支付宝要求的
