目录

https://docs.open.alipay.com/270/105900/

在github上搜索alipay

https://docs.open.alipay.com/291/105972/

下载之后安装启动

  1. """
  2. 1）支付宝API：六大接口
  3. https://docs.open.alipay.com/270/105900/
  5. 2）支付宝工作流程(见下图)：
  6. https://docs.open.alipay.com/270/105898/
  8. 3）支付宝8次异步通知机制(支付宝对我们服务器发送POST请求，索要 success 7个字符)
  9. https://docs.open.alipay.com/270/105902/
  10. """
  1. # 1、在沙箱环境下实名认证：https://openhome.alipay.com/platform/appDaily.htm?tab=info
  3. # 2、电脑网站支付API：https://docs.open.alipay.com/270/105900/
  5. # 3、完成RSA密钥生成：https://docs.open.alipay.com/291/105971
  7. # 4、在开发中心的沙箱应用下设置应用公钥：填入生成的公钥文件中的内容
  9. # 5、Python支付宝开源框架：https://github.com/fzlee/alipay
  10. # >: pip install python-alipay-sdk --upgrade
  12. # 7、公钥私钥设置
  13. """
  14. # alipay_public_key.pem
  15. -----BEGIN PUBLIC KEY-----
  16. 支付宝公钥
  17. -----END PUBLIC KEY-----
  19. # app_private_key.pem
  20. -----BEGIN RSA PRIVATE KEY-----
  21. 用户私钥
  22. -----END RSA PRIVATE KEY-----
  23. """
  25. # 8、支付宝链接
  26. """
  27. 开发：https://openapi.alipay.com/gateway.do
  28. 沙箱：https://openapi.alipaydev.com/gateway.do
  29. """

  1. https://github.com/fzlee/alipay
  1. >: pip install python-alipay-sdk --upgrade
  2. # 如果抛ssl相关错误，代表缺失该包
  3. >: pip install pyopenssl
  1. libs
  2.     ├── iPay  							# aliapy二次封装包
  3.     │   ├── __init__.py 				# 包文件
  4.     │   ├── pem							# 公钥私钥文件夹
  5.     │   │   ├── alipay_public_key.pem	# 支付宝公钥文件
  6.     │   │   ├── app_private_key.pem		# 应用私钥文件
  7.     │   ├── pay.py						# 支付文件
  8.     └── └── settings.py  				# 应用配置  
  1. -----BEGIN PUBLIC KEY-----
  2. 拿应用公钥跟支付宝换来的支付宝公钥
  3. -----END PUBLIC KEY-----
  1. -----BEGIN RSA PRIVATE KEY-----
  2. 通过支付宝公钥私钥签发软件签发的应用私钥
  3. -----END RSA PRIVATE KEY-----
  1. import os
  2. # 应用私钥
  3. APP_PRIVATE_KEY_STRING = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), \'pem\', \'app_private_key.pem\')).read()
  5. # 支付宝公钥
  6. ALIPAY_PUBLIC_KEY_STRING = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), \'pem\', \'alipay_public_key.pem\')).read()
  8. # 应用ID
  9. APP_ID = \'2016093000631831\'
  11. # 加密方式
  12. SIGN = \'RSA2\'
  14. # 是否是支付宝测试环境(沙箱环境)，如果采用真是支付宝环境，配置False
  15. DEBUG = True
  17. # 支付网关
  18. GATEWAY = \'https://openapi.alipaydev.com/gateway.do\' if DEBUG else \'https://openapi.alipay.com/gateway.do\'
  1. from alipay import AliPay
  2. from . import settings
  4. # 支付对象
  5. alipay = AliPay(
  6.     appid=settings.APP_ID,
  7.     app_notify_url=None,
  8.     app_private_key_string=settings.APP_PRIVATE_KEY_STRING,
  9.     alipay_public_key_string=settings.ALIPAY_PUBLIC_KEY_STRING,
  10.     sign_type=settings.SIGN,
  11.     debug=settings.DEBUG
  12. )
  14. # 支付网关
  15. gateway = settings.GATEWAY
  1. # 包对外提供的变量
  2. from .pay import gateway, alipay
  1. # 上线后必须换成公网地址
  2. # 后台基URL
  3. BASE_URL = \'http://127.0.0.1:8000\'
  4. # 前台基URL
  5. LUFFY_URL = \'http://127.0.0.1:8080\'
  6. # 支付宝同步异步回调接口配置
  7. # 后台异步回调接口
  8. NOTIFY_URL = BASE_URL + "/order/success/"
  9. # 前台同步回调接口，没有 / 结尾
  10. RETURN_URL = LUFFY_URL + "/pay/success"
  1. from django.urls import path, include
  2. from utils.router import router
  3. from . import views
  5. """
  6. 1）支付接口(需要登录认证：是谁)：前台提交商品等信息，得到支付链接
  7.     post方法
  9. 分析：支付宝回调
  10.     同步：get给前台 => 前台可以在收到支付宝同步get回调时，ajax异步在给消息同步给后台，也采用get，后台处理前台的get请求
  11.     异步：post给后台 => 后台直接处理支付宝的post请求
  12. 2）支付回调接口(不需要登录认证：哪个订单(订单信息中有非对称加密)、支付宝压根不可能有你的token)：
  13.     get方法：处理前台来的同步回调（不一定能收得到，所有不能在该方法完成后台订单状态等信息操作）
  14.     post方法：处理支付宝来的异步回调
  15.     
  16. 3）订单状态确认接口：随你前台任何时候来校验订单状态的接口
  17. """
  18. # 支付接口(生成订单)
  19. router.register(\'pay\', views.PayViewSet, \'pay\')
  22. urlpatterns = [
  23.     path(\'\', include(router.urls)),
  25.     path(\'success/\', views.SuccessViewSet.as_view({\'get\': \'get\', \'post\': \'post\'}))
  26. ]
  1. """
  2. class Order(models.Model):
  3.     # 主键、总金额、订单名、订单号、订单状态、创建时间、支付时间、流水号、支付方式、支付人(外键) - 优惠劵(外键，可为空)
  4.     pass
  6. class OrderDetail(models.Model):
  7.     # 订单号(外键)、商品(外键)、实价、成交价 - 商品数量
  8.     pass
  9. """
  1. from django.db import models
  2. from user.models import User
  3. from course.models import Course
  6. class Order(models.Model):
  7.     """订单模型"""
  8.     status_choices = (
  9.         (0, \'未支付\'),
  10.         (1, \'已支付\'),
  11.         (2, \'已取消\'),
  12.         (3, \'超时取消\'),
  13.     )
  14.     pay_choices = (
  15.         (1, \'支付宝\'),
  16.         (2, \'微信支付\'),
  17.     )
  18.     subject = models.CharField(max_length=150, verbose_name="订单标题")
  19.     total_amount = models.DecimalField(max_digits=10, decimal_places=2, verbose_name="订单总价", default=0)
  20.     out_trade_no = models.CharField(max_length=64, verbose_name="订单号", unique=True)
  21.     trade_no = models.CharField(max_length=64, null=True, verbose_name="流水号")
  22.     order_status = models.SmallIntegerField(choices=status_choices, default=0, verbose_name="订单状态")
  23.     pay_type = models.SmallIntegerField(choices=pay_choices, default=1, verbose_name="支付方式")
  24.     pay_time = models.DateTimeField(null=True, verbose_name="支付时间")
  25.     user = models.ForeignKey(User, related_name=\'order_user\', on_delete=models.DO_NOTHING, db_constraint=False, verbose_name="下单用户")
  26.     created_time = models.DateTimeField(auto_now_add=True, verbose_name=\'创建时间\')
  28.     class Meta:
  29.         db_table = "luffy_order"
  30.         verbose_name = "订单记录"
  31.         verbose_name_plural = "订单记录"
  33.     def __str__(self):
  34.         return "%s - ￥%s" % (self.subject, self.total_amount)
  36.     @property
  37.     def courses(self):
  38.         data_list = []
  39.         for item in self.order_courses.all():
  40.             data_list.append({
  41.                 "id": item.id,
  42.                 "course_name": item.course.name,
  43.                 "real_price": item.real_price,
  44.             })
  45.         return data_list
  48. class OrderDetail(models.Model):
  49.     """订单详情"""
  50.     order = models.ForeignKey(Order, related_name=\'order_courses\', on_delete=models.CASCADE, db_constraint=False, verbose_name="订单")
  51.     course = models.ForeignKey(Course, related_name=\'course_orders\', on_delete=models.CASCADE, db_constraint=False, verbose_name="课程")
  52.     price = models.DecimalField(max_digits=6, decimal_places=2, verbose_name="课程原价")
  53.     real_price = models.DecimalField(max_digits=6, decimal_places=2, verbose_name="课程实价")
  55.     class Meta:
  56.         db_table = "luffy_order_detail"
  57.         verbose_name = "订单详情"
  58.         verbose_name_plural = "订单详情"
  60.     def __str__(self):
  61.         try:
  62.             return "%s的订单：%s" % (self.course.name, self.order.out_trade_no)
  63.         except:
  64.             return super().__str__()
  1. from rest_framework.viewsets import GenericViewSet, ViewSet
  2. from rest_framework.mixins import CreateModelMixin
  3. from rest_framework.permissions import IsAuthenticated
  4. from rest_framework.response import Response
  5. from . import models, serializers
  8. # 支付接口
  9. class PayViewSet(GenericViewSet, CreateModelMixin):
  10.     permission_classes = [IsAuthenticated]
  11.     queryset = models.Order.objects.all()
  12.     serializer_class = serializers.PaySerializer
  14.     # 重写create方法，返回pay_url，pay_url是在serializer对象中，所以要知道serializer
  15.     def create(self, request, *args, **kwargs):
  16.         serializer = self.get_serializer(data=request.data, context={\'request\': request})
  17.         serializer.is_valid(raise_exception=True)
  18.         self.perform_create(serializer)
  19.         return Response(serializer.context[\'pay_url\'])
  1. from rest_framework import serializers
  2. from . import models
  3. from course.models import Course
  4. from rest_framework.exceptions import ValidationError
  5. from django.conf import settings
  8. class PaySerializer(serializers.ModelSerializer):
  9.     # 要支持单购物和群购物(购物车)，前台要提交 课程主键(们)
  10.     courses = serializers.PrimaryKeyRelatedField(queryset=Course.objects.all(), write_only=True, many=True)
  12.     class Meta:
  13.         model = models.Order
  14.         fields = (\'subject\', \'total_amount\', \'pay_type\', \'courses\')
  15.         extra_kwargs = {
  16.             \'total_amount\': {
  17.                 \'required\': True
  18.             },
  19.             \'pay_type\': {
  20.                 \'required\': True
  21.             },
  22.         }
  24.     # 订单总结校验
  25.     def _check_total_amount(self, attrs):
  26.         courses = attrs.get(\'courses\')
  27.         total_amount = attrs.get(\'total_amount\')
  28.         total_price = 0
  29.         for course in courses:
  30.             total_price += course.price
  31.         if total_price != total_amount:
  32.             raise ValidationError(\'total_amount error\')
  33.         return total_amount
  35.     # 生成订单号
  36.     def _get_out_trade_no(self):
  37.         import uuid
  38.         code = \'%s\' % uuid.uuid4()
  39.         return code.replace(\'-\', \'\')
  41.     # 获取支付人
  42.     def _get_user(self):
  43.         return self.context.get(\'request\').user
  45.     # 获取支付链接
  46.     def _get_pay_url(self, out_trade_no, total_amount, subject):
  47.         from libs import iPay
  48.         order_string = iPay.alipay.api_alipay_trade_page_pay(
  49.             out_trade_no=out_trade_no,
  50.             total_amount=float(total_amount),  # 只有生成支付宝链接时，不能用Decimal
  51.             subject=subject,
  52.             return_url=settings.RETURN_URL,
  53.             notify_url=settings.NOTIFY_URL,
  54.         )
  55.         pay_url = iPay.gateway + \'?\' + order_string
  56.         # 将支付链接存入，传递给views
  57.         self.context[\'pay_url\'] = pay_url
  59.     # 入库(两个表)的信息准备
  60.     def _before_create(self, attrs, user, out_trade_no):
  61.         attrs[\'user\'] = user
  62.         attrs[\'out_trade_no\'] = out_trade_no
  64.     def validate(self, attrs):
  65.         # 1）订单总价校验
  66.         total_amount = self._check_total_amount(attrs)
  67.         # 2）生成订单号
  68.         out_trade_no = self._get_out_trade_no()
  69.         # 3）支付用户：request.user
  70.         user = self._get_user()
  71.         # 4）支付链接生成
  72.         self._get_pay_url(out_trade_no, total_amount, attrs.get(\'subject\'))
  73.         # 5）入库(两个表)的信息准备
  74.         self._before_create(attrs, user, out_trade_no)
  76.         # 代表该校验方法通过，进入入库操作
  77.         return attrs
  81.     # 重写入库方法的目的：完成订单与订单详情两个表入库操作
  82.     def create(self, validated_data):
  83.         courses = validated_data.pop(\'courses\')
  84.         # 订单表入库，不需要courses
  85.         order = models.Order.objects.create(**validated_data)
  87.         # 订单详情表入库：只需要订单对象，课程对象(courses要拆成一个个course)
  88.         for course in courses:
  89.             models.OrderDetail.objects.create(order=order, course=course, price=course.price, real_price=course.price)
  91.         # 先循环制造数据列表[{}, ..., {}]，用群增完成入库 bulk_create()，效率高
  93.         return order
  1. <template>
  2. 	...
  3. 	<span class="buy-now" @click="buy_course(course)">立即购买</span>
  4. </template>
  5. <script>
  6.  	export default {
  7.     	methods: {
  8.             // 购买课程
  9.             buy_course(course) {
  10.                 // es6语法下，变量必须定义才能使用
  11.                 let token = this.$cookies.get(\'token\');
  12.                 if (!token) {
  13.                     this.$message({
  14.                         message: \'请先登录\',
  15.                         type: \'warning\'
  16.                     });
  17.                     return false
  18.                 }
  19.                 this.$axios({
  20.                     url: this.$settings.base_url + \'/order/pay/\',
  21.                     method: \'post\',
  22.                     headers: {
  23.                         authorization: \'luffy \' + token,
  24.                     },
  25.                     data: {
  26.                         subject: course.name,
  27.                         total_amount: course.price,
  28.                         pay_type: 1,  // 现在只能默认1，为支付宝
  29.                         courses: [course.id]  // 后台完成的是基于购物车情况下的接口，所以单购物为群购1个
  30.                     }
  31.                 }).then(response => {
  32.                     let pay_url = response.data;
  33.                     // console.log(pay_url)
  34.                     // 本页面标签调整：可以选择 _self 或 _blank
  35.                     open(pay_url, \'_self\');
  36.                 }).catch(error => {
  37.                     console.log(error.response.data)
  38.                 })
  39.             },
  40.         }
  41.     }
  42. </script>
  1. import PaySuccess from \'../views/PaySuccess.vue\'
  2. // ...
  3. const routes = [
  4.     // ...
  5.     {
  6.         path: \'/pay/success\',
  7.         name: \'pay-success\',
  8.         component: PaySuccess
  9.     },
  10. ];
  1. `
  2. charset=utf-8&
  4. out_trade_no=7f7c7d12d57d45b693e1b49a6b01e1dd&
  6. method=alipay.trade.page.pay.return&
  8. total_amount=39.00&
  10. sign=FUmceqiNMWvxcD%2BUPCHiOTaEwlJ%2FXIXL5UwZWOSI1TwRjPIZVzjRLB4j2G5CQpn472JO8X%2BwMx04dHqjLxqLcY3TRu0XurQ%2FwKTNpyfDrtNuNv0rfGPuVHw52y3blbS7%2FKFVsWryw4%2BBuF2fCrJ4qWH8Zg14Rct7qoMbu73N74WkQtDyzXefiKDbkMMRMfLbelE9TFyeIeygeMId8%2B58mcJMUOh6aQqwpr9bzuBbfJ17fkqU%2F0ys9zGr%2FlDtLL7aAh6BPViqZN%2F9T7byCoferD1BhcSzJNR6V6VuhOdTq8iEaH2XgJT9aIiyHgg3GT1taBBvZX2gK41FSmkguk%2BfsA%3D%3D&
  12. trade_no=2020030722001464020500585462&
  14. auth_app_id=2016093000631831&
  16. version=1.0&
  18. app_id=2016093000631831&
  20. sign_type=RSA2&
  22. seller_id=2088102177958114&
  24. timestamp=2020-03-07%2014%3A47%3A48
  25. `
  26. // 同步回调没与订单状态
  1. <template>
  2.     <div class="pay-success">
  3.         <!--如果是单独的页面，就没必要展示导航栏(带有登录的用户)-->
  4.         <Header/>
  5.         <div class="main">
  6.             <div class="title">
  7.                 <div class="success-tips">
  8.                     <p class="tips">您已成功购买 1 门课程！</p>
  9.                 </div>
  10.             </div>
  11.             <div class="order-info">
  12.                 <p class="info"><b>订单号：</b><span>{{ result.out_trade_no }}</span></p>
  13.                 <p class="info"><b>交易号：</b><span>{{ result.trade_no }}</span></p>
  14.                 <p class="info"><b>付款时间：</b><span><span>{{ result.timestamp }}</span></span></p>
  15.             </div>
  16.             <div class="study">
  17.                 <span>立即学习</span>
  18.             </div>
  19.         </div>
  20.     </div>
  21. </template>
  23. <script>
  24.     import Header from "@/components/Header"
  26.     export default {
  27.         name: "Success",
  28.         data() {
  29.             return {
  30.                 result: {},
  31.             };
  32.         },
  33.         created() {
  34.             // url后拼接的参数：?及后面的所有参数 => ?a=1&b=2
  35.             // console.log(location.search);
  37.             // 解析支付宝回调的url参数
  38.             let params = location.search.substring(1);  // 去除? => a=1&b=2
  39.             let items = params.length ? params.split(\'&\') : [];  // [\'a=1\', \'b=2\']
  40.             //逐个将每一项添加到args对象中
  41.             for (let i = 0; i < items.length; i++) {  // 第一次循环a=1，第二次b=2
  42.                 let k_v = items[i].split(\'=\');  // [\'a\', \'1\']
  43.                 //解码操作，因为查询字符串经过编码的
  44.                 if (k_v.length >= 2) {
  45.                     // url编码反解
  46.                     let k = decodeURIComponent(k_v[0]);
  47.                     this.result[k] = decodeURIComponent(k_v[1]);
  48.                     // 没有url编码反解
  49.                     // this.result[k_v[0]] = k_v[1];
  50.                 }
  52.             }
  53.             // 解析后的结果
  54.             // console.log(this.result);
  57.             // 把地址栏上面的支付结果，再get请求转发给后端
  58.             this.$axios({
  59.                 url: this.$settings.base_url + \'/order/success/\' + location.search,
  60.                 method: \'get\',
  61.             }).then(response => {
  62.                 console.log(response.data);
  63.             }).catch(() => {
  64.                 console.log(\'支付结果同步失败\');
  65.             })
  66.         },
  67.         components: {
  68.             Header,
  69.         }
  70.     }
  71. </script>
  73. <style scoped>
  74.     .main {
  75.         padding: 60px 0;
  76.         margin: 0 auto;
  77.         width: 1200px;
  78.         background: #fff;
  79.     }
  81.     .main .title {
  82.         display: flex;
  83.         -ms-flex-align: center;
  84.         align-items: center;
  85.         padding: 25px 40px;
  86.         border-bottom: 1px solid #f2f2f2;
  87.     }
  89.     .main .title .success-tips {
  90.         box-sizing: border-box;
  91.     }
  93.     .title img {
  94.         vertical-align: middle;
  95.         width: 60px;
  96.         height: 60px;
  97.         margin-right: 40px;
  98.     }
  100.     .title .success-tips {
  101.         box-sizing: border-box;
  102.     }
  104.     .title .tips {
  105.         font-size: 26px;
  106.         color: #000;
  107.     }
  110.     .info span {
  111.         color: #ec6730;
  112.     }
  114.     .order-info {
  115.         padding: 25px 48px;
  116.         padding-bottom: 15px;
  117.         border-bottom: 1px solid #f2f2f2;
  118.     }
  120.     .order-info p {
  121.         display: -ms-flexbox;
  122.         display: flex;
  123.         margin-bottom: 10px;
  124.         font-size: 16px;
  125.     }
  127.     .order-info p b {
  128.         font-weight: 400;
  129.         color: #9d9d9d;
  130.         white-space: nowrap;
  131.     }
  133.     .study {
  134.         padding: 25px 40px;
  135.     }
  137.     .study span {
  138.         display: block;
  139.         width: 140px;
  140.         height: 42px;
  141.         text-align: center;
  142.         line-height: 42px;
  143.         cursor: pointer;
  144.         background: #ffc210;
  145.         border-radius: 6px;
  146.         font-size: 16px;
  147.         color: #fff;
  148.     }
  149. </style>
  1. from utils.logging import logger
  2. # 支付回调接口
  3. class SuccessViewSet(ViewSet):
  4.     authentication_classes = ()
  5.     permission_classes = ()
  7.     # 支付宝同步回调给前台，在同步通知给后台处理
  8.     def get(self, request, *args, **kwargs):
  9.         # return Response(\'后台已知晓，Over！！！\')
  11.         # 不能在该接口完成订单修改操作
  12.         # 但是可以在该接口中校验订单状态(已经收到支付宝post异步通知，订单已修改)，告诉前台
  13.         # print(type(request.query_params))  # django.http.request.QueryDict
  14.         # print(type(request.query_params.dict()))  # dict
  16.         out_trade_no = request.query_params.get(\'out_trade_no\')
  17.         try:
  18.             models.Order.objects.get(out_trade_no=out_trade_no, order_status=1)
  19.             return APIResponse(result=True)
  20.         except:
  21.             return APIResponse(1, \'error\', result=False)
  24.     # 支付宝异步回调处理
  25.     def post(self, request, *args, **kwargs):
  26.         try:
  27.             result_data = request.data.dict()
  28.             out_trade_no = result_data.get(\'out_trade_no\')
  29.             signature = result_data.pop(\'sign\')
  30.             from libs import iPay
  31.             result = iPay.alipay.verify(result_data, signature)
  32.             if result and result_data["trade_status"] in ("TRADE_SUCCESS", "TRADE_FINISHED"):
  33.                 # 完成订单修改：订单状态、流水号、支付时间
  34.                 models.Order.objects.filter(out_trade_no=out_trade_no).update(order_status=1)
  35.                 # 完成日志记录
  36.                 logger.warning(\'%s订单支付成功\' % out_trade_no)
  37.                 return Response(\'success\')
  38.             else:
  39.                 logger.error(\'%s订单支付失败\' % out_trade_no)
  40.         except:
  41.             pass
  42.         return Response(\'failed\')

版权声明：本文为guyouyin123原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/guyouyin123/p/12459398.html