Django项目--路飞学城08
1 支付宝支付二次封装
# 包结构
iPay
__init__.py # 包文件
pem # 文件夹
-app_private_key.pem # 私钥
-alipay_public_key.pem # 支付宝公钥
pay.py # 支付核心
settings.py # 配置
#__init__.py
from .pay import alipay, gateway
# pay.py
from alipay import AliPay
from . import settings
# 支付对象
alipay = AliPay(
appid=settings.APP_ID,
app_notify_url=None,
app_private_key_string=settings.APP_PRIVATE_KEY_STRING,
alipay_public_key_string=settings.ALIPAY_PUBLIC_KEY_STRING,
sign_type=settings.SIGN,
debug=settings.DEBUG
)
# 支付网关
gateway = settings.GATEWAY
# settings.py
import os
# 应用私钥
APP_PRIVATE_KEY_STRING = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'pem', 'app_private_key.pem')).read()
# 支付宝公钥
ALIPAY_PUBLIC_KEY_STRING = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'pem', 'alipay_public_key.pem')).read()
# 应用ID
APP_ID = '2016092000554611'
# 加密方式
SIGN = 'RSA2'
# 是否是支付宝测试环境(沙箱环境)，如果采用真实支付宝环境，配置False
DEBUG = True
# 支付网关
GATEWAY = 'https://openapi.alipaydev.com/gateway.do' if DEBUG else 'https://openapi.alipay.com/gateway.do'
2 后台支付功能
# 0 支付相关表
-订单表
-订单详情表 ：跟订单表是一对多关系，关联字段写在多的一方
"""
class Order(models.Model):
# 主键、总金额、订单名、订单号、订单状态、创建时间、支付时间、流水号（支付宝）、支付方式（支付宝和微信）、支付人(外键) - 优惠劵(外键，可为空)
class OrderDetail(models.Model):
# 订单号(外键)、商品(外键)、实价、成交价 - 商品数量
"""
# 1 支付接口
2.1 支付相关表
# 创建订单app
# python ../../manage.py startapp order
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)
# 订单号，必须唯一
'''
1 当前时间 字符串形式--->分布式情况下重复概率很高
2 uuid----->生成一个不重复的串 （也有重复概率）
3 雪花算法（Twitter ）
4 美团雪花LEAF算法
'''
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="支付时间")
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)
@property
def courses(self):
data_list = []
for item in self.order_courses.all():
data_list.append({
"id": item.id,
"course_name": item.course.name,
"real_price": item.real_price,
})
return data_list
class OrderDetail(models.Model):
"""订单详情"""
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.CASCADE, 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__()
2.2 支付接口
# 1 前端提交数据格式
-{subject:'xx课程',total_amount:99,pay_type:1,courses:[1,2]}
# 2 后端视图类（生成订单）
-校验：价格是否合法，用户是否登录...
-入库：存两个表（订单，订单详情表）
-重写序列化类的create方法
-返回：支付链接 (前端跳转支付页面)
2.2.1 视图类
from .models import Order
from utils.response import APIResponse
from rest_framework_jwt.authentication import JSONWebTokenAuthentication
from rest_framework.permissions import IsAuthenticated
# 登录才能使用，认证类:自己写一个认证类 或使用jwt内置的认证类，但需要配合一个权限类
from .serializer import PaySerializer
# 支付接口：生成订单，返回支付链接
class PayViewSet(GenericViewSet, CreateModelMixin):
authentication_classes = [JSONWebTokenAuthentication,]
permission_classes = [IsAuthenticated]
queryset = Order.objects.all()
serializer_class = PaySerializer
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['pay_url']
return APIResponse(pay_url=pay_url)
2.2.2 序列化类
from . import models
from course.models import Course
from rest_framework import serializers
from rest_framework.exceptions import ValidationError
from lib.iPay import alipay, gateway
import uuid
from django.conf import settings
# 只用来做反序列化, 创建订单
class PaySerializer(serializers.ModelSerializer):
# courses 不是表的字段，重写
# 前端传入的是[1,2]---》[id为1的课程对象，id为2的课程对象]
# 把id，id的列表，映射成对象或对象列表，是queryset指定的对象
courses = serializers.PrimaryKeyRelatedField(queryset=Course.objects.all(), many=True)
# 使用下面方式，courses得到的还是课程列表，后期通过课程列表再做查询，查成课程对象列表
# courses = serializers.ListField()
class Meta:
model = models.Order
# {subject:'xx课程',total_amount:99,pay_type:1,courses:[1,2]}
fields = ['subject', 'total_amount', 'pay_type', 'courses']
extra_kwargs = {
'subject': {'required': True},
'total_amount': {'required': True}
}
def _check_total_amount(self, attrs):
# 取出总价格，取出所有课程累加，比较俩值
total_amount = attrs.get('total_amount')
real_amount = 0
for course in attrs.get('courses'):
real_amount += course.price
if not total_amount == real_amount:
raise ValidationError(detail='价格不合法')
def _get_user(self):
# 从request.user中获取
# 在序列化类中取不到request对象,在视图类中初始化序列化类的时候self.get_serializer(data=request.data,context={'request':request})
return self.context['request'].user
def _get_out_trade_no(self):
return str(uuid.uuid4())
def _get_pay_url(self, attrs, out_trade_no):
# 导入自定义的包中alipay对象，调用对象的api_alipay_trade_page_pay方法
res = alipay.api_alipay_trade_page_pay(
subject=attrs.get('subject'),
total_amount=attrs.get('total_amount'),
out_trade_no=out_trade_no,
# 回调地址跟ipay没有关系，放到项目配置文件
return_url=settings.RETURN_URL, # get回调
notify_url=settings.NOTIFY_URL, # post回调
)
return gateway + res
def _before_create(self, attrs, user, out_trade_no, pay_url):
# 把user，放到attrs中
attrs['user'] = user
# 把订单号，放到attrs中
attrs['out_trade_no'] = out_trade_no
# 把支付连接放到context中
self.context['pay_url'] = pay_url
def validate(self, attrs):
'''
1 校验价格是否合法，不合法抛异常
2 获取当前登录用户，从request中获取
3 生成不重复的订单号，uuid生成
4 生成支付连接，支付宝支付的包
5 入库前准备，把user放入attrs中，把支付连接放到self.context中
'''
self._check_total_amount(attrs)
user = self._get_user()
out_trade_no = self._get_out_trade_no()
pay_url = self._get_pay_url(attrs, out_trade_no)
self._before_create(attrs, user, out_trade_no, pay_url) # 试试，该函数没有返回attrs, 看看attrs改变没
return attrs
# 重写，因为存了两个表
def create(self, validated_data):
courses = validated_data.pop('courses')
# 存订单表
order = models.Order.objects.create(**validated_data)
# 存订单详情表
for course in courses:
models.OrderDetail.objects.create(order=order, course=course, price=course.price, real_price=course.price)
return order
2.2.3 路由
from django.contrib import admin
from django.urls import path, include
from rest_framework.routers import SimpleRouter
from . import views
router = SimpleRouter()
# api/v1/order/pay----->post请求---》生成订单，返回支付连接
router.register('pay', views.PayViewSet, 'pay')
urlpatterns = [
]
urlpatterns += router.urls
3 前台支付页面
PaySuccess.vue
您已成功购买 1 门课程！
订单号：{{ result.out_trade_no }}
交易号：{{ result.trade_no }}
付款时间：{{ result.timestamp }}
立即学习
4 前台支付成功回调页面
支付宝的get回调()，没有自动回调到前端页面
# 原因：get和post回调的地址是一个本地的ip项目地址，支付宝访问不到
# 解决：内网穿透 或 部署在云服务器上
# http://127.0.0.1:8080/pay/success?订单号=xx&时间=xx&sign=xsdsadf
5 支付成功回调接口（get，post）
# 回调流程：
支付成功后，支付宝同时发送
-post回调：项目后台(根据回调信息，修改订单状态)
-get回调：项目前端(显示支付成功的页面)
但防止一些恶心篡改之类的，get回调到项目前端时，前端主动发一个get请求到项目后端，从订单状态上校验是否支付成功
# 支付宝get回调成功，调回咱们的前端，只要来到咱们前端，咱们向后端发送一个get请求验证
-用来校验，看看这个订单的状态是否是 已支付，如果是已支付，就不管了
-如果订单未支付，返回错误信息
# 支付宝会直接post请求回调咱们的地址（后端）
-需要登录？不需要，支付宝没有咱们的token，但是要保证安全，签名，需要验签
-验签完成，修改订单状态为已支付状态
-返回：成功-->'success'， 失败-->'failed'
# 支付宝只接受这样的返回，若不是这个格式，支付宝会默认没有成功回调给你，会继续在一天回调给你几次，后续就不管你了
# get请求验证，只用来做二次校验，不用来修改订单状态
# post请求回调，验签过后，修改订单状态
class AliPayView(APIView):
def post(self, request):
# 支付宝post回调，内网测不了
try:
# request.data：QueryDict对象（前端数据格式：urlencoded、formdata）或者dict对象(json格式)，
result_data = request.data.dict() # 对象.dict()：QueryDict--》转成dict
# 订单号，我们给的
out_trade_no = result_data.get('out_trade_no')
# 流水号 支付宝生成的
trade_no = result_data.get('trade_no')
# 签名
signature = result_data.pop('sign')
from lib.iPay import alipay
# sdk的验证签名方法
result = alipay.verify(result_data, signature)
if result and result_data["trade_status"] in ("TRADE_SUCCESS", "TRADE_FINISHED"):
# 完成订单修改：订单状态、流水号、支付时间
models.Order.objects.filter(out_trade_no=out_trade_no).update(order_status=1`, trade_no=trade_no`)
# 完成日志记录
logger.warning('%s订单支付成功' % out_trade_no)
return Response('success')
else:
logger.error('%s订单支付失败' % out_trade_no)
except:
pass
return Response('failed')
def get(self, request):
# 项目前端访问该get请求，验证订单状态是否成功
out_trade_no = request.query_params.get('out_trade_no')
try:
models.Order.objects.get(out_trade_no=out_trade_no, order_status=1)
return APIResponse(result=True)
except:
return APIResponse(code=101, msg='error', result=False)
上线流程
# 上线前端
-静态html，css，js
-vue项目编译成静态文件
-cnpm run build
# 上线后端
-uwsgi+django