支付的实现一般我们开发中都是通过第三方支付平台来实现的！

目前国内外比较常见的第三方支付平台：

  1. 小额支付
  2. 1. 国内
  3.    微信支付，支付宝，京东支付，百度钱包，贝宝[paypal中文版]
  4. 2. 国外
  5.    apple pay，paypal[贝宝国际版]，万事达信用卡
  7. 大额支付
  8.    银联支付

支付宝

支付宝开发平台登录

官网：https://open.alipay.com/platform/home.htm

公司以企业账号进行支付签约：https://b.alipay.com/signing/productDetailV2.htm?productId=I1011000290000001000

目前我们是作为开发者给项目测试支付功能，所以我们先采用支付平台提供的测试服务端使用测试账号进行功能测试。将来等企业账号申请支付签约通过以后，则可以直接修改代码中的配置信息，就可以在线上运营使用了。

chapter7.3-支付 - 图1

沙箱环境

  1. 真实的支付宝网关: https://openapi.alipay.com/gateway.do
  2. 沙箱的支付宝网关: https://openapi.alipaydev.com/gateway.do

支付宝开发者文档

电脑网站支付产品介绍：https://opendocs.alipay.com/open/270

电脑网站支付流程的时序图：

chapter7.3-支付 - 图2

chapter7.3-支付 - 图3

开发支付功能

终端下创建新的git分支，并创建新的子应用。

  1. cd /home/moluo/Desktop/luffycity
  2. git checkout -b feature/payments
  4. cd luffycityapi/luffycityapi/apps
  5. python ../../manage.py startapp payments

注册子应用，settings/dev.py，代码：

  1. INSTALLED_APPS = [
  2.     。。。。
  3.     'payments',
  4. ]

子应用路由，payments/urls.py，代码：

  1. from django.urls import path,re_path
  2. from . import views
  3. urlpatterns = [
  5. ]

总路由，luffycityapi/urls.py，代码：

  1.     path("payments/", include("payments.urls")),

配置秘钥

  1. RSA2算法：非对称加密算法。一般加密的密钥是成对出现的。
  2. 私钥用于解密，自己保存，
  3. 公钥用于加密，提供给别人。
  4. 目前所有的第三方支付基本都是使用RSA2算法加密。所以要开发支付宝这种第三方支付平台的支付接口基本都有2对密钥。
  5. 支付宝密钥对：支付宝公钥，支付宝密钥。
  6. 商户（应用）密钥对：应用公钥，应用私钥。
  8. 往往我们需要从支付宝的官网上获取支付宝的公钥，把自己的应用公钥填写到支付宝官网。

1. 生成应用的私钥和公钥

支付宝公钥

获取支付宝公钥：https://openhome.alipay.com/platform/appDaily.htm?tab=info

第一次需要启用RSA2秘钥( 公钥模式 )

chapter7.3-支付 - 图4

点击启用了以后，就可以新窗口下看到支付宝提供的公钥。

chapter7.3-支付 - 图5

得到了公钥以后，复制保存到luffycityapi/apps/payments/keys/alipay_public_key.pem，这个pem文件一般就直接保存到当前子应用目录下的keys目录下。

内容格式如下：

  1. -----BEGIN PUBLIC KEY-----
  2. 支付宝公钥信息[不能手动调整，复制下来就原样不动]
  3. -----END PUBLIC KEY-----

效果如下：

chapter7.3-支付 - 图6

应用私钥

应用的公钥和私钥，支付宝本身已经提供了。所以，我们直接复制到本地保存起来即可。

注意：我们使用的是非java语言，所以不要选错了！

chapter7.3-支付 - 图7

luffycityapi/apps/payments/keys/app_private_key.pem，代码：

  1. -----BEGIN RSA PRIVATE KEY-----
  2. 应用私钥信息[不能手动调整，复制下来就原样不动]
  3. -----END RSA PRIVATE KEY-----

效果如下：

chapter7.3-支付 - 图8

如果要保留公钥到本地将来作为备份，或者用着其他的支付方式，可以保存，但是不推荐。

luffycityapi/apps/payments/keys/app_public_key.pem，代码：

  1. -----BEGIN PUBLIC KEY-----
  2. 应用公钥信息[不能手动调整，复制下来就原样不动]
  3. -----END PUBLIC KEY-----

效果：

chapter7.3-支付 - 图9

4. 使用支付宝的sdk开发支付接口

SDK：https://opendocs.alipay.com/open/54/103419

python版本的支付宝SDK文档：https://github.com/fzlee/alipay/blob/master/README.zh-hans.md

安装命令：

  1. pip install python-alipay-sdk --upgrade

使用文档：https://github.com/fzlee/alipay/blob/master/docs/apis_new.zh-hans.md

调整原来下单的序列化器，不在序列化器中返回支付信息，而是由客户端根据订单号请求服务端生成支付信息。

orders/serializers.py，代码：

  1. import logging
  2. import constants
  4. from datetime import datetime
  5. from rest_framework import serializers
  6. from django_redis import get_redis_connection
  7. from django.db import transaction
  8. from .models import Order, OrderDetail, Course
  9. from coupon.models import CouponLog
  11. logger = logging.getLogger("django")
  14. class OrderModelSerializer(serializers.ModelSerializer):
  15.     user_coupon_id = serializers.IntegerField(write_only=True, default=-1)
  17.     class Meta:
  18.         model = Order
  19.         fields = ["pay_type", "id", "order_number", "user_coupon_id", "credit"]
  20.         read_only_fields = ["id", "order_number"]
  21.         extra_kwargs = {
  22.             "pay_type": {"write_only": True},
  23.             "credit": {"write_only": True},
  24.         }
  26.     def create(self, validated_data):
  27.         """创建订单"""
  28.         redis = get_redis_connection("cart")
  29.         user = self.context["request"].user
  30.         user_id = user.id
  32.         # 判断用户如果使用了优惠券，则优惠券需要判断验证
  33.         user_coupon_id = validated_data.get("user_coupon_id")
  34.         # 本次下单时，用户使用的优惠券
  35.         user_coupon = None
  36.         if user_coupon_id != -1:
  37.             user_coupon = CouponLog.objects.filter(pk=user_coupon_id, user_id=user_id).first()
  39.         # 本次下单时使用的积分数量
  40.         use_credit = validated_data.get("credit", 0)
  41.         if use_credit > 0 and use_credit > user.credit:
  42.             raise serializers.ValidationError(detail="您拥有的积分不足以抵扣本次下单的积分，请重新下单！")
  44.         # 开启事务操作，保证下单过程中的所有数据库的原子性
  45.         with transaction.atomic():
  46.             # 设置事务的回滚点标记
  47.             t1 = transaction.savepoint()
  48.             try:
  49.                 # 创建订单记录
  50.                 order = Order.objects.create(
  51.                     name="购买课程",  # 订单标题
  52.                     user_id=user_id,  # 当前下单的用户ID
  53.                     # order_number = datetime.now().strftime("%Y%m%d%H%M%S") + ("%08d" % user_id) + "%08d" % random.randint(1,99999999) # 基于随机数生成唯一订单号
  54.                     order_number=datetime.now().strftime("%Y%m%d") + ("%08d" % user_id) + "%08d" % redis.incr("order_number"), # 基于redis生成分布式唯一订单号
  55.                     pay_type=validated_data.get("pay_type"),  # 支付方式
  56.                 )
  58.                 # 记录本次下单的商品列表
  59.                 cart_hash = redis.hgetall(f"cart_{user_id}")
  60.                 if len(cart_hash) < 1:
  61.                     raise serializers.ValidationError(detail="购物车没有要下单的商品")
  63.                 # 提取购物车中所有勾选状态为b'1'的商品
  64.                 course_id_list = [int(key.decode()) for key, value in cart_hash.items() if value == b'1']
  66.                 # 添加订单与课程的关系
  67.                 course_list = Course.objects.filter(pk__in=course_id_list, is_deleted=False, is_show=True).all()
  68.                 detail_list = []
  69.                 total_price = 0 # 本次订单的总价格
  70.                 real_price = 0  # 本次订单的实付总价
  72.                 # 用户使用优惠券或积分以后，需要在服务端计算本次使用优惠券或积分的最大优惠额度
  73.                 total_discount_price = 0    # 总优惠价格
  74.                 max_discount_course = None  # 享受最大优惠的课程
  76.                 # 本次下单最多可以抵扣的积分
  77.                 max_use_credit = 0
  79.                 for course in course_list:
  80.                     discount_price = course.discount.get("price", None)  # 获取课程原价
  81.                     if discount_price is not None:
  82.                         discount_price = float(discount_price)
  83.                     discount_name = course.discount.get("type", "")
  84.                     detail_list.append(OrderDetail(
  85.                         order=order,
  86.                         course=course,
  87.                         name=course.name,
  88.                         price=course.price,
  89.                         real_price=course.price if discount_price is None else discount_price,
  90.                         discount_name=discount_name,
  91.                     ))
  93.                     # 统计订单的总价和实付总价
  94.                     total_price += float(course.price)
  95.                     real_price += float(course.price if discount_price is None else discount_price)
  97.                     # 在用户使用了优惠券，并且当前课程没有参与其他优惠活动时，找到最佳优惠课程
  98.                     if user_coupon and discount_price is None:
  99.                         if max_discount_course is None:
  100.                             max_discount_course = course
  101.                         else:
  102.                             if course.price >= max_discount_course.price:
  103.                                 max_discount_course = course
  105.                     # 添加每个课程的可用积分
  106.                     if use_credit > 0 and course.credit > 0:
  107.                         max_use_credit += course.credit
  109.                 # 在用户使用了优惠券以后，根据循环中得到的最佳优惠课程进行计算最终抵扣金额
  110.                 if user_coupon:
  111.                     # 优惠公式
  112.                     sale = float(user_coupon.coupon.sale[1:])
  113.                     if user_coupon.coupon.discount == 1:
  114.                         """减免优惠券"""
  115.                         total_discount_price = sale
  116.                     elif user_coupon.coupon.discount == 2:
  117.                         """折扣优惠券"""
  118.                         total_discount_price = float(max_discount_course.price) * (1 - sale)
  120.                 if use_credit > 0:
  121.                     if max_use_credit < use_credit:
  122.                         raise serializers.ValidationError(detail="本次使用的抵扣积分数额超过了限制！")
  124.                     # 当前订单添加积分抵扣的数量
  125.                     order.credit = use_credit
  126.                     total_discount_price = float(use_credit / constants.CREDIT_TO_MONEY)
  128.                     # todo 扣除用户拥有的积分，后续在订单超时未支付，则返还订单中对应数量的积分给用户。如果订单成功支付，则添加一个积分流水记录。
  129.                     user.credit = user.credit - use_credit
  130.                     user.save()
  132.                 # 一次性批量添加本次下单的商品记录
  133.                 OrderDetail.objects.bulk_create(detail_list)
  135.                 # 保存订单的总价格和实付价格
  136.                 order.total_price = real_price
  137.                 order.real_price =  float(real_price - total_discount_price)
  138.                 order.save()
  140.                 # 删除购物车中被勾选的商品，保留没有被勾选的商品信息
  141.                 cart = {key: value for key, value in cart_hash.items() if value == b'0'}
  142.                 pipe = redis.pipeline()
  143.                 pipe.multi()
  144.                 # 删除原来的购物车
  145.                 pipe.delete(f"cart_{user_id}")
  146.                 # 重新把未勾选的商品记录到购物车中
  147.                 if cart:
  148.                     pipe.hmset(f"cart_{user_id}", cart)
  149.                 pipe.execute()
  151.                 # 如果有使用了优惠券，则把优惠券和当前订单进行绑定
  152.                 if user_coupon:
  153.                     user_coupon.order = order
  154.                     user_coupon.save()
  155.                     # 把优惠券从redis中移除
  156.                     redis = get_redis_connection("coupon")
  157.                     redis.delete(f"{user_id}:{user_coupon_id}")
  159.                 return order
  160.             except Exception as e:
  161.                 # 1. 记录日志
  162.                 logger.error(f"订单创建失败：{e}")
  163.                 # 2. 事务回滚
  164.                 transaction.savepoint_rollback(t1)
  165.                 # 3. 抛出异常，通知视图返回错误提示
  166.                 raise serializers.ValidationError(detail="订单创建失败！")

后端提供发起支付的api接口

payments/views.py，代码:

  1. from django.conf import settings
  2. from rest_framework.viewsets import ViewSet
  3. from rest_framework.response import Response
  4. from orders.models import Order
  5. from alipay import AliPay
  6. from alipay.utils import AliPayConfig
  9. # Create your views here.
  10. class AlipayAPIViewSet(ViewSet):
  11.     """支付宝接口"""
  13.     def link(self, request, order_number):
  14.         """生成支付宝支付链接信息"""
  15.         try:
  16.             order = Order.objects.get(order_number=order_number)
  17.             if order.order_status > 0:
  18.                 return Response({"message": "对不起，当前订单不能重复支付或订单已超时！"})
  19.         except Order.DoesNotExist:
  20.             return Response({"message": "对不起，当前订单不存在！"})
  22.         # 读取支付宝公钥与商户私钥
  23.         app_private_key_string = open(settings.ALIPAY["app_private_key_path"]).read()
  24.         alipay_public_key_string = open(settings.ALIPAY["alipay_public_key_path"]).read()
  26.         # 创建alipay SDK操作对象
  27.         alipay = AliPay(
  28.             appid=settings.ALIPAY["appid"],
  29.             app_notify_url=settings.ALIPAY["notify_url"],  # 默认全局回调 url
  30.             app_private_key_string=app_private_key_string,
  31.             # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
  32.             alipay_public_key_string=alipay_public_key_string,
  33.             sign_type=settings.ALIPAY["sign_type"],  # RSA2
  34.             debug=settings.ALIPAY["debug"],  # 默认 False，沙箱模式下必须设置为True
  35.             verbose=settings.ALIPAY["verbose"],  # 输出调试数据
  36.             config=AliPayConfig(timeout=settings.ALIPAY["timeout"])  # 可选，请求超时时间，单位：秒
  37.         )
  39.         # 生成支付信息
  40.         order_string = alipay.client_api(
  41.             "alipay.trade.page.pay",  # 接口名称
  42.             biz_content={
  43.                 "out_trade_no": order_number,  # 订单号
  44.                 "total_amount": float(order.real_price),  # 订单金额 单位：元
  45.                 "subject": order.name,  # 订单标题
  46.                 "product_code": "FAST_INSTANT_TRADE_PAY",  # 产品码，目前只能支持 FAST_INSTANT_TRADE_PAY
  47.             },
  48.             return_url=settings.ALIPAY["return_url"],  # 可选，同步回调地址，必须填写客户端的路径
  49.             notify_url=settings.ALIPAY["notify_url"]   # 可选，不填则使用采用全局默认notify_url，必须填写服务端的路径
  50.         )
  52.         # 拼接完整的支付链接
  53.         link = f"{settings.ALIPAY['gateway']}?{order_string}"
  55.         return Response({
  56.             "pay_type": 0, # 支付类型
  57.             "get_pay_type_display": "支付宝", # 支付类型的提示
  58.             "link": link  # 支付连接地址
  59.         })

在配置文件中编辑支付宝的配置信息[实际的值根据自己的账号而定]

setttins/dev.py，代码：

  1. # 支付宝相关配置
  2. ALIPAY = {
  3.     # 'gateway': 'https://openapi.alipay.com/gateway.do',   # 真实网关地址
  4.     'gateway': 'https://openapi.alipaydev.com/gateway.do',  # 沙箱网关地址
  5.     'appid': '2016091600523592',  # 支付应用ID
  6.     'sign_type': 'RSA2',  # 签证的加密算法
  7.     'debug': True,  # 沙箱模式下必须设置为True
  8.     'verbose': True,  # 是否在调试模式下输出调试数据
  9.     'timeout': 15,  # 请求超时时间，单位：秒
  10.     "app_private_key_path": BASE_DIR / "apps/payments/keys/app_private_key.pem",  # 应用私钥路径
  11.     "alipay_public_key_path": BASE_DIR / "apps/payments/keys/alipay_public_key.pem",  # 支付宝公钥路径
  12.     "return_url": "http://www.luffycity.cn:3000/alipay",  # 同步回调结果通知地址
  13.     "notify_url": "http://api.luffycity.cn:8000/payments/alipay/notify",  # 异步回调结果通知地址
  14. }

payments.urls，代码：

  1. from django.urls import path,re_path
  2. from . import views
  3. urlpatterns = [
  4.     re_path("^alipay/(?P<order_number>[0-9]+)/$", views.AlipayAPIViewSet.as_view({"get":"link"})),
  5. ]

提交代码版本：

  1. cd /home/moluo/Desktop/luffycity
  2. git add .
  3. git commit -m "feature: 服务端提供生成支付宝支付链接的api接口"
  4. git push --set-upstream origin feature/payments

前端生成订单以后发起支付

views/Order.vue，代码：

  1. <script setup>
  3. // ... 代码省略
  5. const commit_order = ()=>{
  6.     // 生成订单
  7.     let token = sessionStorage.token || localStorage.token;
  8.     let user_coupon_id = -1;
  9.     if(order.select !== -1){
  10.         user_coupon_id = order.coupon_list[order.select].user_coupon_id;
  11.     }
  12.     order.create_order(user_coupon_id, token).then(response=>{
  13.         // 成功提示
  14.         ElMessage.success("下单成功！马上跳转到支付页面，请稍候~")
  15.         // 扣除掉被下单的商品数量，更新购物车中的商品数量
  16.         store.commit("set_cart_total", store.state.cart_total - cart.select_course_list.length);
  17.         // 根据订单号到服务端获取支付链接，并打开支付页面。
  18.         order.alipay_page_pay(response.data.order_number).then(response=>{
  19.             window.open(response.data.link,"_blank");
  20.         })
  21.     })
  22. }
  24. // ... 代码省略
  26. </script>

src/api/order.js，代码：

  1. import http from "../utils/http";
  2. import {reactive} from "vue";
  4. const order = reactive({
  5.     // ... 代码省略
  6.     alipay_page_pay(order_number){
  7.         // 获取订单的支付宝支付链接信息
  8.         return http.get(`/payments/alipay/${order_number}`)
  9.     }
  10. });
  12. export default order;

完成了上面的功能以后,我们就可以在沙箱环境中进行支付宝的付款了，我们会接受到支付宝界面那边通过前端js跳转回来的同步通知支付结果，跳转回到我们的客户端页面,

支付结果参数说明：https://docs.open.alipay.com/api_1/alipay.trade.page.pay

  1. http://www.luffycity.cn:3000/alipay?charset=utf-8&out_trade_no=202207120000000100000022&method=alipay.trade.page.pay.return&total_amount=1579.00&sign=YqSmTxOPfaXV%2BTSMv8Lg1dOx71JulfaYL6Ab34LSy57Y%2BCvVAb895jPrxpqMeODxiLi65DRLLAJYK%2FQO1m6ykWuTbeQf1FpPhqTkH5LeipJ1LfPy3efj0KJFJFLVJ9pkIGs3tTD7tg%2FL9X70EVmzCxXruWtlM5pAh%2B2%2FsUVbZ4l1tMwDAt4%2FhNoPlc3jvQ07X1r7B17PPBa8Qk%2FF9PbXbIQBsoOkFa78l%2Fs5GBpLB7OTDoOCv16ijV7vTegqi9riucbJkxbk%2F%2FNR7yvLysKUkPMbkcY6uvXz9LD%2F6DQ%2BNKCz694fe0NLXgovVlhyA8l8FA9cSCYunWNELNK0MF%2FPMQ%3D%3D&trade_no=2022071222001439880503951070&auth_app_id=2016091600523592&version=1.0&app_id=2016091600523592&sign_type=RSA2&seller_id=2088102175868026&timestamp=2022-07-12+12%3A50%3A02

支付成功的模板

提供一个接受支付结果的页面，展示支付成功的信息。

views/AliPaySuccess.vue,代码:

  1. <template>
  2.   <div class="success" v-if="order.is_show">
  3.     <Header/>
  4.     <div class="main">
  5.         <div class="title">
  6.           <i class="el-icon-chat-dot-round"></i>
  7.           <div class="success-tips">
  8.               <p class="tips1">您已成功购买 1 门课程！</p>
  9.               <p class="tips2">你还可以加入QQ群 <span>747556033</span> 学习交流</p>
  10.           </div>
  11.         </div>
  12.         <div class="order-info">
  13.             <p class="info1"><b>付款时间：</b><span>2019/04/02 10:27</span></p>
  14.             <p class="info2"><b>付款金额：</b><span >0</span></p>
  15.             <p class="info3"><b>课程信息：</b><span><span>《Pycharm使用秘籍》</span></span></p>
  16.         </div>
  17.         <div class="wechat-code">
  18.           <img src="../assets/wechat.jpg" alt="" class="er">
  19.           <p><i class="el-icon-warning"></i>重要！微信扫码关注获得学习通知&amp;课程更新提醒！否则将严重影响学习进度和课程体验！</p>
  20.         </div>
  21.         <div class="study">
  22.           <span>立即学习</span>
  23.         </div>
  24.     </div>
  25.     <Footer/>
  26.   </div>
  27. </template>
  29. <script setup>
  30. import Header from "../components/Header.vue"
  31. import Footer from "../components/Footer.vue"
  32. import {ElMessage} from "element-plus";
  33. import order from "../api/order";
  35. </script>
  36. <style scoped>
  37. .success{
  38.   padding-top: 80px;
  39. }
  40. .main{
  41.     height: 100%;
  42.     padding-top: 25px;
  43.     padding-bottom: 25px;
  44.     margin: 0 auto;
  45.     width: 1200px;
  46.     background: #fff;
  47. }
  48. .main .title{
  49.     display: flex;
  50.     -ms-flex-align: center;
  51.     align-items: center;
  52.     padding: 25px 40px;
  53.     border-bottom: 1px solid #f2f2f2;
  54. }
  55. .main .title .success-tips{
  56.     box-sizing: border-box;
  57. }
  58. .title img{
  59.     vertical-align: middle;
  60.     width: 60px;
  61.     height: 60px;
  62.     margin-right: 40px;
  63. }
  64. .title .success-tips{
  65.     box-sizing: border-box;
  66. }
  67. .title .tips1{
  68.     font-size: 22px;
  69.     color: #000;
  70. }
  71. .title .tips2{
  72.     font-size: 16px;
  73.     color: #4a4a4a;
  74.     letter-spacing: 0;
  75.     text-align: center;
  76.     margin-top: 10px;
  77. }
  78. .title .tips2 span{
  79.     color: #ec6730;
  80. }
  81. .order-info{
  82.     padding: 25px 48px;
  83.     padding-bottom: 15px;
  84.     border-bottom: 1px solid #f2f2f2;
  85. }
  86. .order-info p{
  87.     display: -ms-flexbox;
  88.     display: flex;
  89.     margin-bottom: 10px;
  90.     font-size: 16px;
  91. }
  92. .order-info p b{
  93.   font-weight: 400;
  94.   color: #9d9d9d;
  95.   white-space: nowrap;
  96. }
  97. .wechat-code{
  98.     display: flex;
  99.     -ms-flex-align: center;
  100.     align-items: center;
  101.     padding: 25px 40px;
  102.     border-bottom: 1px solid #f2f2f2;
  103. }
  104. .wechat-code>img{
  105.     width: 180px;
  106.     height: 180px;
  107.     margin-right: 15px;
  108. }
  109. .wechat-code p{
  110.     font-size: 14px;
  111.     color: #d0021b;
  112.     display: -ms-flexbox;
  113.     display: flex;
  114.     -ms-flex-align: center;
  115.     align-items: center;
  116. }
  117. .wechat-code p>img{
  118.     width: 16px;
  119.     height: 16px;
  120.     margin-right: 10px;
  121. }
  122. .study{
  123.   padding: 25px 52px;
  124. }
  125. .study span{
  126.   display: block;
  127.   width: 140px;
  128.   height: 42px;
  129.   text-align: center;
  130.   line-height: 42px;
  131.   cursor: pointer;
  132.   background: #ffc210;
  133.   border-radius: 6px;
  134.   font-size: 16px;
  135.   color: #fff;
  136. }
  137. .el-icon-warning{
  138.   font-size: 22px;
  139.   margin-right: 5px;
  140. }
  141. .el-icon-chat-dot-round{
  142.   font-size: 122px;
  143.   margin-right: 10px;
  144. }
  145. </style>

routers/index.js，路由代码:

  1. ,
  2.     {
  3.       meta:{
  4.         title: "支付成功",
  5.         keepAlive: true
  6.       },
  7.       path: '/alipay',
  8.       name: "PaySuccess",
  9.       component: ()=> import("../views/AliPaySuccess.vue"),
  10.     },

src/api/order.js，代码：

  1. import http from "../utils/http";
  2. import {reactive} from "vue";
  4. const order = reactive({
  5.     // ... 代码省略
  6.     // ... 代码省略
  7.     // ... 代码省略
  8.     course_list: [],     // 本次购买的商品课程列表
  9.     real_price: 0,       // 付款金额
  10.     pay_time: undefined, // 付款时间
  11.     is_show: false,      // 是否展示支付成功的内容
  12.     // ... 代码省略
  13.     // ... 代码省略
  14.     // ... 代码省略
  15.     relay_alipay_result(query_string){
  16.         // 把地址栏中的查询字符串(支付成功以后的同步回调通知)转发给服务端
  17.         return http.get(`/payments/alipay/result/${query_string}`)
  18.     }
  19. });
  21. export default order;

转发支付结果到服务端。views/AliPaySuccess.vue，代码：

  1. <script setup>
  2. import Header from "../components/Header.vue"
  3. import Footer from "../components/Footer.vue"
  4. import {ElMessage} from "element-plus";
  5. import order from "../api/order";
  7. let query_string = location.search; // 获取查询字符串的支付结果参数
  8. order.relay_alipay_result(query_string).then(response=>{
  9.   order.is_show = true;
  10.   order.course_list = response.data.course_list;
  11.   order.real_price  = response.data.real_price;
  12.   order.pay_time    = response.data.pay_time;
  13. }).catch(error=>{
  14.   console.log(error);
  15. })
  17. </script>

提交代码版本：

  1. cd /home/moluo/Desktop/luffycity
  2. git add .
  3. git commit -m "feature: 客户端实现发起支付并转换同步支付结果到服务端"
  4. git push

服务端接收并处理同步通知支付结果

因为我们需要多次对支付接口进行调用，所以我们可以在缩减重复代码的情况下，对原有代码进行封装。

luffycityapi/utils/alipaysdk.py，代码：

  1. from django.conf import settings
  2. from alipay import AliPay
  3. from alipay.utils import AliPayConfig
  4. from datetime import datetime
  6. class AliPaySDK(AliPay):
  7.     """支付宝接口sdk工具类"""
  8.     def __init__(self, config=None):
  9.         if config is None:
  10.             self.config = settings.ALIPAY
  11.         else:
  12.             self.config = config
  14.         app_private_key_string = open(self.config["app_private_key_path"]).read()
  15.         alipay_public_key_string = open(self.config["alipay_public_key_path"]).read()
  16.         super().__init__(
  17.             appid=self.config["appid"],
  18.             app_notify_url=self.config["notify_url"],  # 默认全局回调 url
  19.             app_private_key_string=app_private_key_string,
  20.             # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
  21.             alipay_public_key_string=alipay_public_key_string,
  22.             sign_type=self.config["sign_type"],  # RSA 或者 RSA2
  23.             debug=self.config["debug"],  # 默认 False，沙箱模式下必须设置为True
  24.             verbose=self.config["verbose"],  # 输出调试数据
  25.             config=AliPayConfig(timeout=self.config["timeout"])  # 可选，请求超时时间，单位：秒
  26.         )
  28.     def page_pay(self,order_number,real_price,order_name):
  29.         """
  30.         生成支付链接
  31.         @parmas order_number: 商户订单号
  32.         @parmas real_price: 订单金额
  33.         @parmas order_name: 订单标题
  34.         @return 支付链接
  35.         """
  36.         order_string = self.client_api(
  37.             "alipay.trade.page.pay",
  38.             biz_content={
  39.                 "out_trade_no": order_number,  # 订单号
  40.                 "total_amount": float(real_price),  # 订单金额
  41.                 "subject": order_name,  # 订单标题
  42.                 "product_code": "FAST_INSTANT_TRADE_PAY",
  43.             },
  44.             return_url=self.config["return_url"],  # 可选，同步回调地址，必须填写客户端的路径
  45.             notify_url=self.config["notify_url"]  # 可选，不填则使用采用全局默认notify_url，必须填写服务端的路径
  46.         )
  48.         return f"{self.config['gateway']}?{order_string}"
  50.     def check_sign(self, data):
  51.         """
  52.         验证返回的支付结果中的签证信息
  53.         @params data: 支付平台返回的支付结果，字典格式
  54.         """
  55.         signature = data.pop("sign")
  56.         success = self.verify(data, signature)
  57.         return success
  59.     def query(self,order_number):
  60.         """
  61.         根据订单号查询订单状态
  62.         @params order_number: 订单号
  63.         """
  64.         return self.server_api(
  65.             "alipay.trade.query",
  66.             biz_content={
  67.                 "out_trade_no": order_number
  68.             }
  69.         )
  71.     def refund(self,order_number, real_price):
  72.         """
  73.         原路退款
  74.         @params order_number: 退款的订单号
  75.         @params real_price: 退款的订单金额
  76.         """
  77.         self.server_api(
  78.             "alipay.rade.refund",
  79.             biz_content={
  80.                 "out_trade_no": order_number,
  81.                 "refund_amount": real_price
  82.             }
  83.         )
  85.     def transfer(self, account,amount):
  86.         """
  87.         转账给个人
  88.         @params account: 收款人的支付宝账号
  89.         @params amount: 转账金额
  90.         """
  91.         return self.server_api(
  92.             "alipay.fund.trans.toaccount.transfer",
  93.             biz_content = {
  94.                 "out_biz_no": datetime.now().strftime("%Y%m%d%H%M%S"),
  95.                 "payee_type": "ALIPAY_LOGONID/ALIPAY_USERID",
  96.                 "payee_account": account,
  97.                 "amount": amount
  98.             }
  99.         )

payments/views.py，代码：

  1. from  datetime import datetime
  2. from rest_framework.viewsets import ViewSet
  3. from rest_framework.response import Response
  4. from rest_framework import status
  6. from courses.serializers import CourseInfoModelSerializer
  7. from orders.models import Order
  8. from alipaysdk import AliPaySDK
  10. # Create your views here.
  11. class AlipayAPIViewSet(ViewSet):
  12.     """支付宝接口"""
  14.     def link(self, request, order_number):
  15.         """生成支付宝支付链接信息"""
  16.         try:
  17.             order = Order.objects.get(order_number=order_number)
  18.             if order.order_status > 0:
  19.                 return Response({"message": "对不起，当前订单不能重复支付或订单已超时！"})
  20.         except Order.DoesNotExist:
  21.             return Response({"message": "对不起，当前订单不存在！"})
  23.         # # 读取支付宝公钥与商户私钥
  24.         # app_private_key_string = open(settings.ALIPAY["app_private_key_path"]).read()
  25.         # alipay_public_key_string = open(settings.ALIPAY["alipay_public_key_path"]).read()
  26.         #
  27.         # # 创建alipay SDK操作对象
  28.         # alipay = AliPay(
  29.         #     appid=settings.ALIPAY["appid"],
  30.         #     app_notify_url=settings.ALIPAY["notify_url"],  # 默认全局回调 url
  31.         #     app_private_key_string=app_private_key_string,
  32.         #     # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
  33.         #     alipay_public_key_string=alipay_public_key_string,
  34.         #     sign_type=settings.ALIPAY["sign_type"],  # RSA2
  35.         #     debug=settings.ALIPAY["debug"],  # 默认 False，沙箱模式下必须设置为True
  36.         #     verbose=settings.ALIPAY["verbose"],  # 输出调试数据
  37.         #     config=AliPayConfig(timeout=settings.ALIPAY["timeout"])  # 可选，请求超时时间，单位：秒
  38.         # )
  40.         # 生成支付信息
  41.         # order_string = alipay.client_api(
  42.         #     "alipay.trade.page.pay",  # 接口名称
  43.         #     biz_content={
  44.         #         "out_trade_no": order_number,  # 订单号
  45.         #         "total_amount": float(order.real_price),  # 订单金额 单位：元
  46.         #         "subject": order.name,  # 订单标题
  47.         #         "product_code": "FAST_INSTANT_TRADE_PAY",  # 产品码，目前只能支持 FAST_INSTANT_TRADE_PAY
  48.         #     },
  49.         #     return_url=settings.ALIPAY["return_url"],  # 可选，同步回调地址，必须填写客户端的路径
  50.         #     notify_url=settings.ALIPAY["notify_url"]   # 可选，不填则使用采用全局默认notify_url，必须填写服务端的路径
  51.         # )
  52.         #
  53.         # # 拼接完整的支付链接
  54.         # link = f"{settings.ALIPAY['gateway']}?{order_string}"
  56.         alipay = AliPaySDK()
  57.         link = alipay.page_pay(order_number, order.real_price, order.name)
  58.         print(link)
  60.         return Response({
  61.             "pay_type": 0, # 支付类型
  62.             "get_pay_type_display": "支付宝", # 支付类型的提示
  63.             "link": link  # 支付连接地址
  64.         })
  66.     def return_result(self, request):
  67.         """支付宝支付结果的同步通知处理"""
  68.         data = request.query_params.dict()  # QueryDict
  69.         alipay = AliPaySDK()
  70.         success = alipay.check_sign(data)
  71.         if not success:
  72.             return Response({"errmsg": "通知通知结果不存在！"}, status=status.HTTP_400_BAD_REQUEST)
  74.         order_number = data.get("out_trade_no")
  75.         try:
  76.             order = Order.objects.get(order_number=order_number)
  77.             if order.order_status > 1:
  78.                 return Response({"errmsg": "订单超时或已取消！"}, status=status.HTTP_400_BAD_REQUEST)
  79.         except Order.DoesNotExist:
  80.             return Response({"errmsg": "订单不存在！"}, status=status.HTTP_400_BAD_REQUEST)
  82.         # 获取当前订单相关的课程信息，用于返回给客户端
  83.         order_courses = order.order_courses.all()
  84.         course_list = [item.course for item in order_courses]
  86.         if order.order_status == 0:
  87.             result = alipay.query(order_number)
  89.             print(f"result-{result}")
  90.             if result.get("trade_status", None) in ["TRADE_FINISHED", "TRADE_SUCCESS"]:
  91.                 """支付成功"""
  92.                 # todo 1. 修改订单状态
  93.                 order.pay_time = datetime.now()
  94.                 order.order_status = 1
  95.                 order.save()
  96.                 # todo 2. 记录扣除个人积分的流水信息，补充个人的优惠券使用记录
  97.                 # todo 3. 用户和课程的关系绑定
  98.                 # todo 4. 取消订单超时
  100.         # 返回客户端结果
  101.         serializer = CourseInfoModelSerializer(course_list, many=True)
  102.         return Response({
  103.             "pay_time": order.pay_time.strftime("%Y-%m-%d %H:%M:%S"),
  104.             "real_price": float(order.real_price),
  105.             "course_list": serializer.data
  106.         })

payments/urls.py，代码：

  1. from django.urls import path,re_path
  2. from . import views
  3. urlpatterns = [
  4.     re_path("^alipay/(?P<order_number>[0-9]+)/$", views.AlipayAPIViewSet.as_view({"get":"link"})),
  5.     path("alipay/result/", views.AlipayAPIViewSet.as_view({"get":"return_result"}))
  6. ]

提交代码版本：

  1. cd /home/moluo/Desktop/luffycity
  2. git add .
  3. git commit -m "feature: 服务端接收客户端转发的同步支付结果并验证修改订单状态"
  4. git push

服务端更新用户购买商品课程的记录

user/models.py，模型代码：

  1. from django.contrib.auth.models import AbstractUser
  2. from django.utils.safestring import mark_safe
  3. from luffycityapi.utils.models import BaseModel,models
  4. from luffycityapi.settings import constants
  6. # Create your models here.
  8. class User(AbstractUser):
  9.     name   = models.CharField(max_length=150, default="", null=True, blank=True, verbose_name='用户昵称')
  10.     mobile = models.CharField(max_length=15, unique=True, verbose_name='手机号')
  11.     money  = models.DecimalField(max_digits=9, default=0.0, decimal_places=2, verbose_name="钱包余额")
  12.     credit = models.IntegerField(default=0, verbose_name="积分")
  13.     avatar = models.ImageField(upload_to="avatar/%Y/", blank=True, null=True, default=constants.DEFAULT_USER_AVATAR, verbose_name="个人头像")
  14.     study_time = models.IntegerField(default=0, verbose_name="总学习时长")
  16.     class Meta:
  17.         db_table = 'fg_users'
  18.         verbose_name = '用户信息'
  19.         verbose_name_plural = verbose_name
  21.     def avatar_image(self):
  22.         if self.avatar:
  23.             return mark_safe( f'<img style="border-radius: 100%; max-width: 50px;" src="{self.avatar.url}">' )
  24.         else:
  25.             return mark_safe(f'<img style="border-radius: 100%; max-width: 50px;" src="/uploads/{constants.DEFAULT_USER_AVATAR}">')
  27.     avatar_image.short_description = "个人头像"
  28.     avatar_image.allow_tags = True
  29.     avatar_image.admin_order_field = "avatar"
  31. class Credit(BaseModel):
  32.     """积分流水"""
  33.     opera_choices = (
  34.         (0, "业务增值"),
  35.         (1, "购物消费"),
  36.         (2, "系统赠送"),
  37.     )
  38.     operation = models.SmallIntegerField(choices=opera_choices, default=1, verbose_name="积分操作类型")
  39.     number = models.IntegerField(default=0, verbose_name="积分数量", help_text="如果是扣除积分则需要设置积分为负数，如果消费10积分，则填写-10，<br>如果是添加积分则需要设置积分为正数，如果获得10积分，则填写10。")
  40.     user = models.ForeignKey(User, related_name='user_credits', on_delete=models.CASCADE, verbose_name="用户")
  41.     remark = models.CharField(max_length=500, null=True, blank=True, verbose_name="备注信息")
  42.     class Meta:
  43.         db_table = 'fg_credit'
  44.         verbose_name = '积分流水'
  45.         verbose_name_plural = verbose_name
  47.     def __str__(self):
  48.         if self.number > 0:
  49.             oper_text = "获得"
  50.         else:
  51.             oper_text = "减少"
  52.         return "[%s] %s 用户%s %s %s积分" % (self.get_operation_display(),self.created_time.strftime("%Y-%m-%d %H:%M:%S"), self.user.username, oper_text, abs(self.number))
  55. from courses.models import Course,CourseChapter,CourseLesson
  56. class UserCourse(BaseModel):
  57.     """用户的课程"""
  58.     user   = models.ForeignKey(User, related_name='user_courses', on_delete=models.CASCADE,verbose_name="用户", db_constraint=False)
  59.     course = models.ForeignKey(Course, related_name='course_users', on_delete=models.CASCADE, verbose_name="课程名称", db_constraint=False)
  60.     chapter = models.ForeignKey(CourseChapter, related_name="user_chapter", on_delete=models.DO_NOTHING, null=True, blank=True, verbose_name="章节信息", db_constraint=False)
  61.     lesson = models.ForeignKey(CourseLesson, related_name="user_lesson", on_delete=models.DO_NOTHING, null=True, blank=True, verbose_name="课时信息", db_constraint=False)
  62.     study_time = models.IntegerField(default=0, verbose_name="学习时长")
  64.     class Meta:
  65.         db_table = 'ly_user_course'
  66.         verbose_name = '用户课程购买记录'
  67.         verbose_name_plural = verbose_name

数据迁移

  1. /home/moluo/Desktop/luffycity/luffycityapi
  2. python manage.py makemigrations
  3. python manage.py migrate

在订单结果处理的视图中把用户购买课程逻辑代码加上。

payments/views.py，代码：

  1. import logging
  2. from datetime import datetime
  3. from rest_framework.viewsets import ViewSet
  4. from rest_framework.response import Response
  5. from rest_framework import status
  6. from django.db import transaction
  8. from orders.models import Order
  9. from alipaysdk import AliPaySDK
  10. from users.models import Credit, UserCourse
  11. from courses.serializers import CourseInfoModelSerializer
  12. from coupon.models import CouponLog
  14. logger = logging.getLogger("django")
  17. # Create your views here.
  18. class AlipayAPIViewSet(ViewSet):
  19.     """支付宝接口"""
  21.     def link(self, request, order_number):
  22.         """生成支付宝支付链接信息"""
  23.         try:
  24.             order = Order.objects.get(order_number=order_number)
  25.             if order.order_status > 0:
  26.                 return Response({"message": "对不起，当前订单不能重复支付或订单已超时！"})
  27.         except Order.DoesNotExist:
  28.             return Response({"message": "对不起，当前订单不存在！"})
  30.         # # 读取支付宝公钥与商户私钥
  31.         # app_private_key_string = open(settings.ALIPAY["app_private_key_path"]).read()
  32.         # alipay_public_key_string = open(settings.ALIPAY["alipay_public_key_path"]).read()
  33.         #
  34.         # # 创建alipay SDK操作对象
  35.         # alipay = AliPay(
  36.         #     appid=settings.ALIPAY["appid"],
  37.         #     app_notify_url=settings.ALIPAY["notify_url"],  # 默认全局回调 url
  38.         #     app_private_key_string=app_private_key_string,
  39.         #     # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
  40.         #     alipay_public_key_string=alipay_public_key_string,
  41.         #     sign_type=settings.ALIPAY["sign_type"],  # RSA2
  42.         #     debug=settings.ALIPAY["debug"],  # 默认 False，沙箱模式下必须设置为True
  43.         #     verbose=settings.ALIPAY["verbose"],  # 输出调试数据
  44.         #     config=AliPayConfig(timeout=settings.ALIPAY["timeout"])  # 可选，请求超时时间，单位：秒
  45.         # )
  47.         # 生成支付信息
  48.         # order_string = alipay.client_api(
  49.         #     "alipay.trade.page.pay",  # 接口名称
  50.         #     biz_content={
  51.         #         "out_trade_no": order_number,  # 订单号
  52.         #         "total_amount": float(order.real_price),  # 订单金额 单位：元
  53.         #         "subject": order.name,  # 订单标题
  54.         #         "product_code": "FAST_INSTANT_TRADE_PAY",  # 产品码，目前只能支持 FAST_INSTANT_TRADE_PAY
  55.         #     },
  56.         #     return_url=settings.ALIPAY["return_url"],  # 可选，同步回调地址，必须填写客户端的路径
  57.         #     notify_url=settings.ALIPAY["notify_url"]   # 可选，不填则使用采用全局默认notify_url，必须填写服务端的路径
  58.         # )
  59.         #
  60.         # # 拼接完整的支付链接
  61.         # link = f"{settings.ALIPAY['gateway']}?{order_string}"
  63.         alipay = AliPaySDK()
  64.         link = alipay.page_pay(order_number, order.real_price, order.name)
  65.         print(link)
  67.         return Response({
  68.             "pay_type": 0, # 支付类型
  69.             "get_pay_type_display": "支付宝", # 支付类型的提示
  70.             "link": link  # 支付连接地址
  71.         })
  73.     def return_result(self, request):
  74.         """支付宝支付结果的同步通知处理"""
  75.         data = request.query_params.dict()  # QueryDict
  76.         alipay = AliPaySDK()
  77.         success = alipay.check_sign(data)
  78.         if not success:
  79.             return Response({"errmsg": "通知通知结果不存在！"}, status=status.HTTP_400_BAD_REQUEST)
  81.         order_number = data.get("out_trade_no")
  82.         try:
  83.             order = Order.objects.get(order_number=order_number)
  84.             if order.order_status > 1:
  85.                 return Response({"errmsg": "订单超时或已取消！"}, status=status.HTTP_400_BAD_REQUEST)
  86.         except Order.DoesNotExist:
  87.             return Response({"errmsg": "订单不存在！"}, status=status.HTTP_400_BAD_REQUEST)
  89.         # 获取当前订单相关的课程信息，用于返回给客户端
  90.         order_courses = order.order_courses.all()
  91.         course_list = [item.course for item in order_courses]
  93.         if order.order_status == 0:
  94.             # 请求支付宝，查询订单的支付结果
  95.             result = alipay.query(order_number)
  96.             print(f"result-{result}")
  97.             if result.get("trade_status", None) in ["TRADE_FINISHED", "TRADE_SUCCESS"]:
  98.                 """支付成功"""
  99.                 with transaction.atomic():
  100.                     save_id = transaction.savepoint()
  101.                     try:
  102.                         now_time = datetime.now()
  103.                         # 1. 修改订单状态
  104.                         order.pay_time = now_time
  105.                         order.order_status = 1
  106.                         order.save()
  107.                         # 2.1 记录扣除个人积分的流水信息
  108.                         if order.credit > 0:
  109.                             Credit.objects.create(operation=1, number=order.credit, user=order.user)
  111.                         # 2.2 补充个人的优惠券使用记录
  112.                         coupon_log = CouponLog.objects.filter(order=order).first()
  113.                         if coupon_log:
  114.                             coupon_log.use_time = now_time
  115.                             coupon_log.use_status = 1  # 1 表示已使用
  116.                             coupon_log.save()
  118.                         # 3. 用户和课程的关系绑定
  119.                         user_course_list = []
  120.                         for course in course_list:
  121.                             user_course_list.append(UserCourse(course=course, user=order.user))
  122.                         UserCourse.objects.bulk_create(user_course_list)
  124.                         # todo 4. 取消订单超时
  126.                     except Exception as e:
  127.                         logger.error(f"订单支付处理同步结果发生未知错误：{e}")
  128.                         transaction.savepoint_rollback(save_id)
  129.                         return Response({"errmsg": "当前订单支付未完成！请联系客服工作人员！"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
  131.         # 返回客户端结果
  132.         serializer = CourseInfoModelSerializer(course_list, many=True)
  133.         return Response({
  134.             "pay_time": order.pay_time.strftime("%Y-%m-%d %H:%M:%S"),
  135.             "real_price": float(order.real_price),
  136.             "course_list": serializer.data
  137.         })

因为在处理同步通知结果的代码中，还进行了一次向支付宝查询订单支付结果的操作，所以有时候网络延迟的话，就会出现服务端成功，但是客户端因为超时等待而导致无法获取结果报错，此时应该设置axios的timeout为5~10秒，原来项目搭建时我们设置的是2.5秒。

utils/http.js，代码：

  1. import axios from "axios"
  3. const http = axios.create({
  4.     // timeout: 2500,                          // 请求超时，有大文件上传需要关闭这个配置
  5.     baseURL: "http://api.luffycity.cn:8000",   // 设置api服务端的默认地址[如果基于服务端实现的跨域，这里可以填写api服务端的地址，如果基于nodejs客户端测试服务器实现的跨域，则这里不能填写api服务端地址]
  6.     withCredentials: false,                    // 是否允许客户端ajax请求时携带cookie
  7. })
  9. // 后续代码省略....

客户端展示支付处理后的结果。views/AliPaySuccess.vue，代码：

  1. <template>
  2.   <div class="success" v-if="order.is_show">
  3.     <Header/>
  4.     <div class="main">
  5.         <div class="title">
  6.           <i class="el-icon-chat-dot-round"></i>
  7.           <div class="success-tips">
  8.              <p class="tips1">您已成功购买 {{order.course_list?.length}} 门课程！</p>
  9.               <p class="tips2">你还可以加入QQ群 <span>747556033</span> 学习交流</p>
  10.           </div>
  11.         </div>
  12.         <div class="order-info">
  13.             <p class="info1"><b>付款时间：</b><span>{{order.pay_time}}</span></p>
  14.             <p class="info2"><b>付款金额：</b><span >{{order.real_price?.toFixed(2)}}</span></p>
  15.             <p class="info3"><b>课程信息：</b>
  16.               <span v-for="course in order.course_list">《{{course.name}}》</span>
  17.             </p>
  18.         </div>
  19.         <div class="wechat-code">
  20.           <img src="../assets/wechat.jpg" alt="" class="er">
  21.           <p><i class="el-icon-warning"></i>重要！微信扫码关注获得学习通知&amp;课程更新提醒！否则将严重影响学习进度和课程体验！</p>
  22.         </div>
  23.         <div class="study">
  24.           <router-link to="/user/study"><span>立即学习</span></router-link>
  25.         </div>
  26.     </div>
  27.     <Footer/>
  28.   </div>
  29. </template>
  2. <script setup>
  3. import Header from "../components/Header.vue"
  4. import Footer from "../components/Footer.vue"
  5. import {ElMessage} from "element-plus";
  6. import order from "../api/order";
  7. import {useRouter} from "vue-router";
  8. const router = useRouter()
  10. let query_string = location.search; // 获取查询字符串的支付结果参数
  11. order.relay_alipay_result(query_string).then(response=>{
  12.   order.is_show = true;
  13.   order.course_list = response.data.course_list;
  14.   order.real_price  = response.data.real_price;
  15.   order.pay_time    = response.data.pay_time;
  16. }).catch(error=>{
  17.   ElMessage.error(error.response.data.errmsg);
  18.   router.push("/");
  19. })
  21. </script>

我们当前完成的项目具有一定特殊性，和传统卖实物商品不一样的是，我们卖的是虚拟商品，所以不存在多次购买同一款商品的，所以后续用户添加商品到购物车时， 要判断用户是否曾经购买了当前商品课程，如果在UserCourse中查询到购买记录，则不能添加商品到购物车！！cart/views.py，代码：

  1. from rest_framework.views import APIView
  2. from rest_framework.permissions import IsAuthenticated
  3. from rest_framework.response import Response
  4. from rest_framework import status
  5. from django_redis import get_redis_connection
  6. from courses.models import Course
  7. from users.models import UserCourse
  10. # Create your views here.
  11. class CartAPIView(APIView):
  12.     permission_classes = [IsAuthenticated]  # 保证用户必须时登录状态才能调用当前视图
  14.     def post(self, request):
  15.         """添加课程商品到购物车中"""
  16.         # 1. 接受客户端提交的商品信息：用户ID，课程ID，勾选状态
  17.         # 用户ID 可以通过self.request.user.id 或 request.user.id 来获取
  18.         user_id = request.user.id
  19.         course_id = request.data.get("course_id", None)
  20.         selected = 1  # 默认商品是勾选状态的
  21.         print(f"user_id={user_id},course_id={course_id}")
  23.         try:
  24.             # 判断课程是否存在
  25.             course = Course.objects.get(is_show=True, is_deleted=False, pk=course_id)
  26.         except:
  27.             return Response({"errmsg": "当前课程不存在！"}, status=status.HTTP_400_BAD_REQUEST)
  29.         try:
  30.             # 判断用户是否已经购买了
  31.             UserCourse.objects.get(user_id=user_id, course_id=course_id)
  32.             return Response({"errmsg": "对不起，您已经购买过当前课程！不需要重新购买了."}, status=status.HTTP_400_BAD_REQUEST)
  33.         except:
  34.             pass
  36.         # 3. 添加商品到购物车
  37.         redis = get_redis_connection("cart")
  38.         """
  39.         cart_用户ID: {
  40.            课程ID: 勾选状态
  41.         }
  42.         """
  43.         redis.hset(f"cart_{user_id}", course_id, selected)
  45.         # 4. 获取购物车中的商品课程数量
  46.         cart_total = redis.hlen(f"cart_{user_id}")
  48.         # 5. 返回结果给客户端
  49.         return Response({"errmsg": "成功添加商品课程到购物车！", "cart_total": cart_total}, status=status.HTTP_201_CREATED)
  51.     # ... 代码省略

提交代码版本：

  1. cd /home/moluo/Desktop/luffycity
  2. git add .
  3. git commit -m "feature: 服务端更新用户购买的课程记录以及的订单支付成功后的积分流水记录与优惠券的使用状态记录，最后在购物车中防止用户重复购买商品"
  4. git push

上面的支付结果处理都是基于支付平台返回的同步结果，是支付宝那边通过js页面跳转来完成支付结果通知的。在项目运营过程中，很容易出现跳转页面过程中无法跳转或者跳转过程中被用户手动关闭页面的情况，这些情况都会导致服务端没法完成同步通知代码的执行，也就是说，我们不能单纯等待用户付款完成以后支付宝通过页面跳转的同步通知结果，还要结合用户的行为操作和支付宝的异步通知结果处理，才能防止订单状态的丢失。

提供支付倒计时功能

客户端订单页面中添加一个倒计时的遮罩层，当用户关闭当前遮罩层则发送ajax轮询请求查询当前订单的支付结果。

views/Order.vue，代码

  1.     <div class="loadding" v-if="order.loading" @click="check_order">
  2.       <div class="box">
  3.           <p class="time">{{fill0(parseInt(order.timeout/60))}}:{{ fill0(order.timeout%60)}}</p>
  4.           <i class="el-icon-loading"></i><br>
  5.           <p>支付完成！点击关闭当前页面</p>
  6.       </div>
  7.     </div>  <!-- 这里添加到Footer上方即可 -->
  8.     <Footer/>
  2. <script setup>
  3. import {reactive,watch} from "vue"
  4. import Header from "../components/Header.vue"
  5. import Footer from "../components/Footer.vue"
  6. import {useStore} from "vuex";
  7. import cart from "../api/cart"
  8. import order from "../api/order";
  9. import {ElMessage} from "element-plus";
  10. import {useRouter} from "vue-router";
  11. import {fill0} from "../utils/func";
  13. let store = useStore()
  14. let router = useRouter()
  16. const get_select_course = ()=>{
  17.     // 获取购物车中的勾选商品列表
  18.     let token = sessionStorage.token || localStorage.token;
  19.     cart.get_select_course(token).then(response=>{
  20.         cart.select_course_list = response.data.cart
  21.         if(response.data.cart.length === 0){
  22.           ElMessage.error("当前购物车中没有下单的商品！请重新重新选择购物车中要购买的商品~");
  23.           router.back();
  24.         }
  26.         // 计算本次下单的总价格
  27.         let sum = 0
  28.         let credit_course_list= [] // 可使用积分抵扣的课程列表
  29.         let max_use_credit = 0     // 本次下单最多可以用于抵扣的积分
  30.         response.data.cart?.forEach((course,key)=>{
  31.             if(course.discount.price > 0 || course.discount.price === 0){
  32.               sum+=course.discount.price
  33.             }else{
  34.               sum+=course.price
  35.             }
  37.            if(course.credit > 0){
  38.               max_use_credit = max_use_credit + course.credit
  39.               credit_course_list.push(course)
  40.             }
  42.         })
  43.         cart.total_price = sum;
  44.         order.credit_course_list = credit_course_list
  45.         order.max_use_credit = max_use_credit // 本次下单最多可以用于抵扣的积分
  46.         console.log(`order.max_use_credit=${order.max_use_credit}`);
  47.         // 本次订单最多可以使用的积分数量
  48.         // 如果用户积分不足，则最多只能用完自己的积分
  49.         if(order.max_use_credit > order.has_credit){
  50.           order.max_use_credit = order.has_credit
  51.         }
  52.     }).catch(error=>{
  53.     if(error?.response?.status===400){
  54.       ElMessage.error("登录超时！请重新登录后再继续操作~");
  55.     }
  56.   })
  57. }
  59. get_select_course();
  62. const commit_order = ()=>{
  63.     // 生成订单
  64.     let token = sessionStorage.token || localStorage.token;
  65.     // 当用户选择了优惠券，则需要获取当前选择的优惠券发放记录的id
  66.     let user_coupon_id = -1;
  67.     if(order.select !== -1){
  68.         user_coupon_id = order.coupon_list[order.select].user_coupon_id;
  69.     }
  71.     order.create_order(user_coupon_id, token).then(response=>{
  72.       // 支付倒计时提示
  73.       order.order_number = response.data.order_number  // 订单号
  74.       order.loading = true                             // 显示遮罩层
  75.       order.timeout = response.data.order_timeout      // 订单超时的时间，为15分钟
  76.       clearInterval(order.timer)  // 先清除原有定时器，保证整个页面中timer对应的定时器是唯一的。
  77.       order.timer = setInterval(() => {
  78.         if(order.timeout > 1){
  79.             order.timeout=order.timeout - 1;
  80.         }else{
  81.             ElMessage.error("订单超时！如果您已经支付成功！请点击关闭当前弹窗！当前页面15秒后关闭！");
  82.             clearInterval(order.timer);
  83.             // 发送一个订单查询
  84.             check_order();
  85.             // 关闭页面
  86.             setTimeout(()=>{
  87.                 // 跳转到用户的订单用心
  88.                 router.push("/user/order");
  89.             }, 1500);
  90.         }
  91.       }, 3000);
  93.     // 成功提示
  94.     ElMessage.success("下单成功！马上跳转到支付页面，请稍候~")
  95.     // 扣除掉被下单的商品数量，更新购物车中的商品数量
  96.     store.commit("cart_total", store.state.cart_total - cart.select_course_list.length);
  97.     // 订单生成以后，先扣除临时用户积分
  98.     order.has_credit = order.has_credit - order.credit
  100.     // 根据订单号到服务端获取支付链接，并打开支付页面。
  101.     console.log(order.order_number)  // 订单号
  102.     order.alipay_page_pay().then(response=>{
  103.         window.open(response.data.link,"_blank");
  104.     })
  106.   }).catch(error=>{
  107.     if(error?.response?.status===400){
  108.           ElMessage.success("登录超时！请重新登录后再继续操作~");
  109.     }
  110.   })
  111. }
  114. // 获取本次下单的可用优惠券
  115. const get_enable_coupon_list = ()=>{
  116.     let token = sessionStorage.token || localStorage.token;
  117.     order.get_enable_coupon_list(token).then(response=>{
  118.         order.coupon_list = response.data.coupon_list;
  119.         // 获取积分相关信息
  120.         order.credit_to_money = response.data.credit_to_money;
  121.         order.has_credit      = response.data.has_credit;
  122.     })
  123. }
  124. get_enable_coupon_list()
  127. // 积分兑换抵扣
  128. const conver_credit = ()=>{
  129.   order.discount_price = parseFloat( (order.credit / order.credit_to_money).toFixed(2) )
  130. }
  132. // 本次下单的最大兑换积分
  133. const max_conver_credit = ()=>{
  134.   order.credit=order.max_use_credit
  135.   conver_credit();
  136. }
  138. // 查询订单状态
  139. const check_order = ()=>{
  140.   let token = sessionStorage.token || localStorage.token;
  141.   order.query_order(token).then(response=>{
  142.     order.loading = false;
  143.     router.push("/user/order");
  144.   }).catch(error=>{
  145.     console.log(error);
  146.     ElMessage.error(error.response.data.errmsg);
  147.   })
  148. }
  150. // 监听用户选择的支付方式
  151. watch(
  152.     ()=>order.pay_type,
  153.     ()=>{
  154.       console.log(order.pay_type)
  155.     }
  156. )
  159. // 监听用户选择的优惠券
  160. watch(
  161.     ()=>order.select,
  162.     ()=>{
  163.       order.discount_price = 0;
  164.       // 如果没有选择任何的优惠券，则select 为-1，那么不用进行计算优惠券折扣的价格了
  165.       if (order.select === -1) {
  166.         return // 阻止代码继续往下执行
  167.       }
  169.       // 根据下标select，获取当前选中的优惠券信息
  170.       let current_coupon = order.coupon_list[order.select]
  171.       console.log(current_coupon);
  173.       // 针对折扣优惠券，找到最大优惠的课程
  174.       let max_discount = -1;
  175.       for(let course of cart.select_course_list) {  // 循环本次下单的勾选商品
  176.         // 找到当前优惠券的可用课程
  177.         if(current_coupon.enable_course === "__all__") { // 如果当前优惠券是通用优惠券
  178.           if(max_discount !== -1){
  179.             if(course.price > max_discount.price){  // 在每次循环中，那当前循环的课程的价格与之前循环中得到的最大优惠课程的价格进行比较
  180.               max_discount = course
  181.             }
  182.           }else{
  183.             max_discount = course
  184.           }
  185.         }else if((current_coupon.enable_course.indexOf(course.id) > -1) && (course.price >= parseFloat(current_coupon.condition))){
  186.           // 判断 当前优惠券如果包含了当前课程， 并 课程的价格 > 当前优惠券的使用门槛
  187.           // 只允许没有参与其他优惠券活动的课程使用优惠券，基本所有的平台都不存在折上折的。
  188.           if( course.discount.price === undefined ) {
  189.             if(max_discount !== -1){
  190.               if(course.price > max_discount.price){
  191.                 max_discount = course
  192.               }
  193.             }else{
  194.               max_discount = course
  195.             }
  196.           }
  197.         }
  198.       }
  200.       if(max_discount !== -1){
  201.         if(current_coupon.discount === '1') { // 抵扣优惠券[抵扣的价格就是当前优惠券的价格]
  202.           order.discount_price = parseFloat( Math.abs(current_coupon.sale) )
  203.         }else if(current_coupon.discount === '2') { // 折扣优惠券]抵扣的价格就是(1-折扣百分比) * 课程原价]
  204.           order.discount_price = parseFloat(max_discount.price * (1-parseFloat(current_coupon.sale.replace("*",""))) )
  205.         }
  206.       }else{
  207.         order.select = -1
  208.         order.discount_price = 0
  209.         ElMessage.error("当前课程商品已经参与了其他优惠活动，无法再次使用当前优惠券！")
  210.       }
  212. })
  215. // 在切换不同的优惠类型，重置积分和优惠券信息
  216. watch(
  217.     ()=>order.discount_type,
  218.     ()=>{
  219.         order.select = -1
  220.         order.credit = 0
  221.         order.discount_price = 0
  222.     }
  223. )
  226. // 底部订单总价信息固定浮动效果
  227. window.onscroll = ()=>{
  228.   let cart_body_table = document.querySelector(".cart-body-table")
  229.   let offsetY = window.scrollY
  230.   let maxY = cart_body_table.offsetTop+cart_body_table.offsetHeight
  231.   order.fixed = offsetY < maxY
  232. }
  235. </script>
  1. <style>
  2. .loadding{
  3.   width: 100%;
  4.   height: 100%;
  5.   margin: auto;
  6.   position: fixed;
  7.   top: 0;
  8.   left: 0;
  9.   right: 0;
  10.   bottom: 0;
  11.   z-index: 999;
  12.   background-color: rgba(0,0,0,.7);
  13. }
  14. .box{
  15.   width: 300px;
  16.   height: 150px;
  17.   position: absolute;
  18.   top: 0;
  19.   left: 0;
  20.   right: 0;
  21.   bottom: 0;
  22.   margin: auto;
  23.   font-size: 40px;
  24.   text-align: center;
  25.   padding-top: 50px;
  26.   color: #fff;
  27. }
  28. .box .time{
  29.   font-size: 22px;
  30. }
  31. </style>

api/order.js，代码：

  1. import http from "../utils/http";
  2. import {reactive} from "vue";
  4. const order = reactive({
  5.   total_price: 0,      // 勾选商品的总价格
  6.   discount_price: 0,   // 本次下单的优惠抵扣价格
  7.   discount_type: 0,    // 0表示优惠券，1表示积分
  8.   use_coupon: false,   // 用户是否使用优惠
  9.   coupon_list:[],      // 用户拥有的可用优惠券列表
  10.   select: -1,          // 当前用户选中的优惠券下标，-1表示没有选择
  11.   credit: 0,           // 当前用户选择抵扣的积分，0表示没有使用积分
  12.   fixed: true,         // 底部订单总价是否固定浮动
  13.   pay_type: 0,         // 支付方式
  14.   credit_to_money: 0,  // 积分兑换现金的比例
  15.   has_credit: 0,       // 用户拥有的积分
  16.   max_use_credit: 0,   // 当前用户本次下单可用最大积分数量
  17.   credit_course_list:[], // 可使用积分抵扣的课程列表
  18.   course_list: [],     // 本次购买的商品课程列表
  19.   real_price: 0,       // 付款金额
  20.   pay_time: undefined, // 付款时间
  21.   order_number: null,  // 订单号
  22.   is_show: false,      // 是否展示支付成功的内容[接收到支付宝的同步处理结果以后，先把结果转发给后端验证成功以后，才把前端的页面内容展示处理]
  23.   loading: false,      // 订单支付时的倒计时背景遮罩层
  24.   timeout: 0,          // 订单支付超时倒计时
  25.   timer: 0,            // 订单支付倒计时定时器的标记符
  26.   create_order(user_coupon_id, token){
  27.     // 生成订单
  28.     return http.post("/orders/",{
  29.         pay_type: this.pay_type,
  30.         user_coupon_id,
  31.         credit: this.credit,
  32.     },{
  33.         headers:{
  34.             Authorization: "jwt " + token,
  35.         }
  36.     })
  37.   },
  38.   get_enable_coupon_list(token){
  39.     // 获取本次下单的可用优惠券列表
  40.     return http.get("/coupon/enable/",{
  41.         headers:{
  42.             Authorization: "jwt " + token,
  43.         }
  44.     })
  45.   },
  46.   alipay_page_pay(){
  47.     // 获取订单的支付宝支付链接信息
  48.     return http.get(`/payments/alipay/${this.order_number}`)
  49.   },
  50.   relay_alipay_result(query_string){
  51.     // 把地址栏中的查询字符串(支付成功以后的同步回调通知)转发给服务端
  52.     return http.get(`/payments/alipay/result/${query_string}`)
  53.   },
  54.   query_order(token){
  55.     // 查询订单支付结果
  56.     return http.get(`/payments/alipay/query/${this.order_number}`,{
  57.       headers:{
  58.         Authorization: "jwt " + token,
  59.       }
  60.     })
  61.   }
  62. })
  64. export default order;

服务端下单成功返回订单号时同时返回服务端配置的订单超时时间。

order/serializers.py，代码：

  1. import logging
  2. import constants
  4. from datetime import datetime
  5. from rest_framework import serializers
  6. from django_redis import get_redis_connection
  7. from django.db import transaction
  8. from .models import Order, OrderDetail, Course
  9. from coupon.models import CouponLog
  11. logger = logging.getLogger("django")
  14. class OrderModelSerializer(serializers.ModelSerializer):
  15.     user_coupon_id = serializers.IntegerField(write_only=True, default=-1)
  16.     order_timeout = serializers.IntegerField(read_only=True)
  18.     class Meta:
  19.         model = Order
  20.         fields = ["pay_type", "id", "order_number", "user_coupon_id", "credit", "order_timeout"]
  21.         read_only_fields = ["id", "order_number"]
  22.         extra_kwargs = {
  23.             "pay_type": {"write_only": True},
  24.             "credit": {"write_only": True},
  25.         }
  27.     def create(self, validated_data):
  28.         """创建订单"""
  29.         redis = get_redis_connection("cart")
  30.         user = self.context["request"].user
  31.         user_id = user.id
  33.         # 判断用户如果使用了优惠券，则优惠券需要判断验证
  34.         user_coupon_id = validated_data.get("user_coupon_id")
  35.         # 本次下单时，用户使用的优惠券
  36.         user_coupon = None
  37.         if user_coupon_id != -1:
  38.             user_coupon = CouponLog.objects.filter(pk=user_coupon_id, user_id=user_id).first()
  40.         # 本次下单时使用的积分数量
  41.         use_credit = validated_data.get("credit", 0)
  42.         if use_credit > 0 and use_credit > user.credit:
  43.             raise serializers.ValidationError(detail="您拥有的积分不足以抵扣本次下单的积分，请重新下单！")
  45.         # 开启事务操作，保证下单过程中的所有数据库的原子性
  46.         with transaction.atomic():
  47.             # 设置事务的回滚点标记
  48.             t1 = transaction.savepoint()
  49.             try:
  50.                 # 创建订单记录
  51.                 order = Order.objects.create(
  52.                     name="购买课程",  # 订单标题
  53.                     user_id=user_id,  # 当前下单的用户ID
  54.                     # order_number = datetime.now().strftime("%Y%m%d%H%M%S") + ("%08d" % user_id) + "%08d" % random.randint(1,99999999) # 基于随机数生成唯一订单号
  55.                     order_number=datetime.now().strftime("%Y%m%d") + ("%08d" % user_id) + "%08d" % redis.incr("order_number"), # 基于redis生成分布式唯一订单号
  56.                     pay_type=validated_data.get("pay_type"),  # 支付方式
  57.                 )
  59.                 # 记录本次下单的商品列表
  60.                 cart_hash = redis.hgetall(f"cart_{user_id}")
  61.                 if len(cart_hash) < 1:
  62.                     raise serializers.ValidationError(detail="购物车没有要下单的商品")
  64.                 # 提取购物车中所有勾选状态为b'1'的商品
  65.                 course_id_list = [int(key.decode()) for key, value in cart_hash.items() if value == b'1']
  67.                 # 添加订单与课程的关系
  68.                 course_list = Course.objects.filter(pk__in=course_id_list, is_deleted=False, is_show=True).all()
  69.                 detail_list = []
  70.                 total_price = 0 # 本次订单的总价格
  71.                 real_price = 0  # 本次订单的实付总价
  73.                 # 用户使用优惠券或积分以后，需要在服务端计算本次使用优惠券或积分的最大优惠额度
  74.                 total_discount_price = 0    # 总优惠价格
  75.                 max_discount_course = None  # 享受最大优惠的课程
  77.                 # 本次下单最多可以抵扣的积分
  78.                 max_use_credit = 0
  80.                 for course in course_list:
  81.                     discount_price = course.discount.get("price", None)  # 获取课程原价
  82.                     if discount_price is not None:
  83.                         discount_price = float(discount_price)
  84.                     discount_name = course.discount.get("type", "")
  85.                     detail_list.append(OrderDetail(
  86.                         order=order,
  87.                         course=course,
  88.                         name=course.name,
  89.                         price=course.price,
  90.                         real_price=course.price if discount_price is None else discount_price,
  91.                         discount_name=discount_name,
  92.                     ))
  94.                     # 统计订单的总价和实付总价
  95.                     total_price += float(course.price)
  96.                     real_price += float(course.price if discount_price is None else discount_price)
  98.                     # 在用户使用了优惠券，并且当前课程没有参与其他优惠活动时，找到最佳优惠课程
  99.                     if user_coupon and discount_price is None:
  100.                         if max_discount_course is None:
  101.                             max_discount_course = course
  102.                         else:
  103.                             if course.price >= max_discount_course.price:
  104.                                 max_discount_course = course
  106.                     # 添加每个课程的可用积分
  107.                     if use_credit > 0 and course.credit > 0:
  108.                         max_use_credit += course.credit
  110.                 # 在用户使用了优惠券以后，根据循环中得到的最佳优惠课程进行计算最终抵扣金额
  111.                 if user_coupon:
  112.                     # 优惠公式
  113.                     sale = float(user_coupon.coupon.sale[1:])
  114.                     if user_coupon.coupon.discount == 1:
  115.                         """减免优惠券"""
  116.                         total_discount_price = sale
  117.                     elif user_coupon.coupon.discount == 2:
  118.                         """折扣优惠券"""
  119.                         total_discount_price = float(max_discount_course.price) * (1 - sale)
  121.                 if use_credit > 0:
  122.                     if max_use_credit < use_credit:
  123.                         raise serializers.ValidationError(detail="本次使用的抵扣积分数额超过了限制！")
  125.                     # 当前订单添加积分抵扣的数量
  126.                     order.credit = use_credit
  127.                     total_discount_price = float(use_credit / constants.CREDIT_TO_MONEY)
  129.                     # todo 扣除用户拥有的积分，后续在订单超时未支付，则返还订单中对应数量的积分给用户。如果订单成功支付，则添加一个积分流水记录。
  130.                     user.credit = user.credit - use_credit
  131.                     user.save()
  133.                 # 一次性批量添加本次下单的商品记录
  134.                 OrderDetail.objects.bulk_create(detail_list)
  136.                 # 保存订单的总价格和实付价格
  137.                 order.total_price = real_price
  138.                 order.real_price =  float(real_price - total_discount_price)
  139.                 order.save()
  141.                 # 删除购物车中被勾选的商品，保留没有被勾选的商品信息
  142.                 cart = {key: value for key, value in cart_hash.items() if value == b'0'}
  143.                 pipe = redis.pipeline()
  144.                 pipe.multi()
  145.                 # 删除原来的购物车
  146.                 pipe.delete(f"cart_{user_id}")
  147.                 # 重新把未勾选的商品记录到购物车中
  148.                 if cart:
  149.                     pipe.hmset(f"cart_{user_id}", cart)
  150.                 pipe.execute()
  152.                 # 如果有使用了优惠券，则把优惠券和当前订单进行绑定
  153.                 if user_coupon:
  154.                     user_coupon.order = order
  155.                     user_coupon.save()
  156.                     # 把优惠券从redis中移除
  157.                     redis = get_redis_connection("coupon")
  158.                     redis.delete(f"{user_id}:{user_coupon_id}")
  160.                 # 返回订单超时时间
  161.                 order.order_timeout = constants.ORDER_TIMEOUT
  162.                 return order
  163.             except Exception as e:
  164.                 # 1. 记录日志
  165.                 logger.error(f"订单创建失败：{e}")
  166.                 # 2. 事务回滚
  167.                 transaction.savepoint_rollback(t1)
  168.                 # 3. 抛出异常，通知视图返回错误提示
  169.                 raise serializers.ValidationError(detail="订单创建失败！")

utils/constants.py，代码：

  1. # 订单超时的时间(单位：秒)
  2. ORDER_TIMEOUT = 15 * 60

服务端提供查询订单的api接口

payments/urls.py，代码：

  1. from django.urls import path,re_path
  2. from . import views
  3. urlpatterns = [
  4.     re_path("^alipay/(?P<order_number>[0-9]+)/$", views.AlipayAPIViewSet.as_view({"get":"link"})),
  5.     path("alipay/result/", views.AlipayAPIViewSet.as_view({"get":"return_result"})),
  6.     re_path("^alipay/query/(?P<order_number>[0-9]+)/$", views.AlipayAPIViewSet.as_view({"get":"query"})),
  7. ]

payments/views.py，代码：

  1. import logging
  2. from datetime import datetime
  3. from rest_framework.viewsets import ViewSet
  4. from rest_framework.response import Response
  5. from rest_framework import status
  6. from django.db import transaction
  8. from orders.models import Order
  9. from alipaysdk import AliPaySDK
  10. from users.models import Credit, UserCourse
  11. from courses.serializers import CourseInfoModelSerializer
  12. from coupon.models import CouponLog
  14. logger = logging.getLogger("django")
  17. # Create your views here.
  18. class AlipayAPIViewSet(ViewSet):
  19.     """支付宝接口"""
  21.     # // ... 代码省略
  22.     # // ... 代码省略
  23.     # // ... 代码省略
  26.     def query(self, request, order_number):
  27.         """主动查询订单支付的支付结果"""
  28.         try:
  29.             order = Order.objects.get(order_number=order_number)
  30.             if order.order_status > 1:
  31.                 return Response({"errmsg": "订单超时或已取消！"}, status=status.HTTP_400_BAD_REQUEST)
  32.         except Order.DoesNotExist:
  33.             return Response({"errmsg": "订单不存在！"}, status=status.HTTP_400_BAD_REQUEST)
  35.         # 获取当前订单相关的课程信息，用于返回给客户端
  36.         order_courses = order.order_courses.all()
  37.         course_list = [item.course for item in order_courses]
  38.         courses_list = []
  39.         for course in course_list:
  40.             courses_list.append(UserCourse(course=course, user=order.user))
  42.         if order.order_status == 0:
  43.             # 请求支付宝，查询订单的支付结果
  44.             alipay = AliPaySDK()
  45.             result = alipay.query(order_number)
  46.             print(f"result-{result}")
  47.             if result.get("trade_status", None) in ["TRADE_FINISHED", "TRADE_SUCCESS"]:
  48.                 """支付成功"""
  49.                 with transaction.atomic():
  50.                     save_id = transaction.savepoint()
  51.                     try:
  52.                         now_time = datetime.now()
  53.                         # 1. 修改订单状态
  54.                         order.pay_time = now_time
  55.                         order.order_status = 1
  56.                         order.save()
  57.                         # 2.1 记录扣除个人积分的流水信息
  58.                         if order.credit > 0:
  59.                             Credit.objects.create(operation=1, number=order.credit, user=order.user)
  61.                         # 2.2 补充个人的优惠券使用记录
  62.                         coupon_log = CouponLog.objects.filter(order=order).first()
  63.                         if coupon_log:
  64.                             coupon_log.use_time = now_time
  65.                             coupon_log.use_status = 1  # 1 表示已使用
  66.                             coupon_log.save()
  68.                         # 3. 用户和课程的关系绑定
  69.                         user_course_list = []
  70.                         for course in course_list:
  71.                             user_course_list.append(UserCourse(course=course, user=order.user))
  72.                         UserCourse.objects.bulk_create(user_course_list)
  74.                         # todo 4. 取消订单超时
  76.                     except Exception as e:
  77.                         logger.error(f"订单支付处理同步结果发生未知错误：{e}")
  78.                         transaction.savepoint_rollback(save_id)
  79.                         return Response({"errmsg": "当前订单支付未完成！请联系客服工作人员！"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
  80.             else:
  81.                 """当前订单未支付"""
  82.                 return Response({"errmsg": "当前订单未支付！"}, status=status.HTTP_400_BAD_REQUEST)
  84.         return Response({"errmsg":"当前订单已支付！"})

提交代码版本：

  1. cd /home/moluo/Desktop/luffycity
  2. git add .
  3. git commit -m "feature: 客户端实现支付倒计时功能"
  4. git push

虽然上面提供了支付倒计时进一步确认用户是否支付了。但是还是会存在用户不点击页面而是通过页面刷新来避开了倒计时。这样的话，我们还是存存在订单状态丢失的情况。

接受支付宝异步发送支付结果

支付宝异步通知结果相关文档：https://opendocs.alipay.com/open/270/105902

注意：程序执行完后必须打印输出“success”（不包含引号）。如果商家反馈给支付宝的字符不是 success 这7个字符，支付宝服务器会不断重发通知，直到超过 24 小时 22 分钟。一般情况下，25 小时以内完成 8 次通知（通知的间隔频率一般是：4m,10m,10m,1h,2h,6h,15h）。

payments/views.py，代码：

  1. import logging
  2. from datetime import datetime
  3. from rest_framework.viewsets import ViewSet
  4. from rest_framework.response import Response
  5. from rest_framework import status
  6. from django.db import transaction
  7. from django.http.response import HttpResponse
  9. from orders.models import Order
  10. from alipaysdk import AliPaySDK
  11. from users.models import Credit, UserCourse
  12. from courses.serializers import CourseInfoModelSerializer
  13. from coupon.models import CouponLog
  15. logger = logging.getLogger("django")
  18. # Create your views here.
  19. class AlipayAPIViewSet(ViewSet):
  20.     """支付宝接口"""
  22.     def link(self, request, order_number):
  23.         """生成支付宝支付链接信息"""
  24.         try:
  25.             order = Order.objects.get(order_number=order_number)
  26.             if order.order_status > 0:
  27.                 return Response({"message": "对不起，当前订单不能重复支付或订单已超时！"})
  28.         except Order.DoesNotExist:
  29.             return Response({"message": "对不起，当前订单不存在！"})
  31.         # # 读取支付宝公钥与商户私钥
  32.         # app_private_key_string = open(settings.ALIPAY["app_private_key_path"]).read()
  33.         # alipay_public_key_string = open(settings.ALIPAY["alipay_public_key_path"]).read()
  34.         #
  35.         # # 创建alipay SDK操作对象
  36.         # alipay = AliPay(
  37.         #     appid=settings.ALIPAY["appid"],
  38.         #     app_notify_url=settings.ALIPAY["notify_url"],  # 默认全局回调 url
  39.         #     app_private_key_string=app_private_key_string,
  40.         #     # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
  41.         #     alipay_public_key_string=alipay_public_key_string,
  42.         #     sign_type=settings.ALIPAY["sign_type"],  # RSA2
  43.         #     debug=settings.ALIPAY["debug"],  # 默认 False，沙箱模式下必须设置为True
  44.         #     verbose=settings.ALIPAY["verbose"],  # 输出调试数据
  45.         #     config=AliPayConfig(timeout=settings.ALIPAY["timeout"])  # 可选，请求超时时间，单位：秒
  46.         # )
  48.         # 生成支付信息
  49.         # order_string = alipay.client_api(
  50.         #     "alipay.trade.page.pay",  # 接口名称
  51.         #     biz_content={
  52.         #         "out_trade_no": order_number,  # 订单号
  53.         #         "total_amount": float(order.real_price),  # 订单金额 单位：元
  54.         #         "subject": order.name,  # 订单标题
  55.         #         "product_code": "FAST_INSTANT_TRADE_PAY",  # 产品码，目前只能支持 FAST_INSTANT_TRADE_PAY
  56.         #     },
  57.         #     return_url=settings.ALIPAY["return_url"],  # 可选，同步回调地址，必须填写客户端的路径
  58.         #     notify_url=settings.ALIPAY["notify_url"]   # 可选，不填则使用采用全局默认notify_url，必须填写服务端的路径
  59.         # )
  60.         #
  61.         # # 拼接完整的支付链接
  62.         # link = f"{settings.ALIPAY['gateway']}?{order_string}"
  64.         alipay = AliPaySDK()
  65.         link = alipay.page_pay(order_number, order.real_price, order.name)
  66.         print(link)
  68.         return Response({
  69.             "pay_type": 0, # 支付类型
  70.             "get_pay_type_display": "支付宝", # 支付类型的提示
  71.             "link": link  # 支付连接地址
  72.         })
  74.     def return_result(self, request):
  75.         """支付宝支付结果的同步通知处理"""
  76.         data = request.query_params.dict()  # QueryDict
  77.         alipay = AliPaySDK()
  78.         success = alipay.check_sign(data)
  79.         if not success:
  80.             return Response({"errmsg": "通知通知结果不存在！"}, status=status.HTTP_400_BAD_REQUEST)
  82.         order_number = data.get("out_trade_no")
  83.         try:
  84.             order = Order.objects.get(order_number=order_number)
  85.             if order.order_status > 1:
  86.                 return Response({"errmsg": "订单超时或已取消！"}, status=status.HTTP_400_BAD_REQUEST)
  87.         except Order.DoesNotExist:
  88.             return Response({"errmsg": "订单不存在！"}, status=status.HTTP_400_BAD_REQUEST)
  90.         # 获取当前订单相关的课程信息，用于返回给客户端
  91.         order_courses = order.order_courses.all()
  92.         course_list = [item.course for item in order_courses]
  94.         if order.order_status == 0:
  95.             # 请求支付宝，查询订单的支付结果
  96.             result = alipay.query(order_number)
  97.             print(f"result-{result}")
  98.             if result.get("trade_status", None) in ["TRADE_FINISHED", "TRADE_SUCCESS"]:
  99.                 """支付成功"""
  100.                 with transaction.atomic():
  101.                     save_id = transaction.savepoint()
  102.                     try:
  103.                         now_time = datetime.now()
  104.                         # 1. 修改订单状态
  105.                         order.pay_time = now_time
  106.                         order.order_status = 1
  107.                         order.save()
  108.                         # 2.1 记录扣除个人积分的流水信息
  109.                         if order.credit > 0:
  110.                             Credit.objects.create(operation=1, number=order.credit, user=order.user)
  112.                         # 2.2 补充个人的优惠券使用记录
  113.                         coupon_log = CouponLog.objects.filter(order=order).first()
  114.                         if coupon_log:
  115.                             coupon_log.use_time = now_time
  116.                             coupon_log.use_status = 1  # 1 表示已使用
  117.                             coupon_log.save()
  119.                         # 3. 用户和课程的关系绑定
  120.                         user_course_list = []
  121.                         for course in course_list:
  122.                             user_course_list.append(UserCourse(course=course, user=order.user))
  123.                         UserCourse.objects.bulk_create(user_course_list)
  125.                         # todo 4. 取消订单超时
  127.                     except Exception as e:
  128.                         logger.error(f"订单支付处理同步结果发生未知错误：{e}")
  129.                         transaction.savepoint_rollback(save_id)
  130.                         return Response({"errmsg": "当前订单支付未完成！请联系客服工作人员！"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
  132.         # 返回客户端结果
  133.         serializer = CourseInfoModelSerializer(course_list, many=True)
  134.         return Response({
  135.             "pay_time": order.pay_time.strftime("%Y-%m-%d %H:%M:%S"),
  136.             "real_price": float(order.real_price),
  137.             "course_list": serializer.data
  138.         })
  140.     def notify_result(self, request):
  141.         """支付宝支付结果的异步通知处理"""
  142.         # drf中接收POST参数需要使用request.data
  143.         data = request.data
  144.         alipay = AliPaySDK()
  145.         success = alipay.check_sign(data)
  146.         if not success:
  147.             # 因为是属于异步处理，这个过程无法通过终端调试，因此，需要把支付发送过来的结果，记录到日志中。
  148.             logger.error(f"[支付宝]>> 异步通知结果验证失败：{data}")
  149.             return HttpResponse("fail")
  151.         if data.get("trade_status") not in ["TRADE_FINISHED", "TRADE_SUCCESS"]:
  152.             return HttpResponse("fail")
  154.         # 基于支付包异步请求的支付结果中提取订单号
  155.         order_number = data.get("out_trade_no")
  157.         try:
  158.             order = Order.objects.get(order_number=order_number)
  159.             if order.order_status > 1:
  160.                 return HttpResponse("fail")
  161.         except Order.DoesNotExist:
  162.             return HttpResponse("fail")
  164.         # 如果已经支付完成，则不需要继续往下处理
  165.         if order.order_status == 1:
  166.             return HttpResponse("success")
  168.         # 获取本次下单的商品课程列表
  169.         order_courses = order.order_courses.all()
  170.         course_list = [item.course for item in order_courses]
  171.         courses_list = []
  173.         for course in course_list:
  174.             courses_list.append(UserCourse(course=course, user=order.user))
  176.         """支付成功"""
  177.         with transaction.atomic():
  178.             save_id = transaction.savepoint()
  179.             try:
  180.                 now_time = datetime.now()
  181.                 # 1. 修改订单状态
  182.                 order.pay_time = now_time
  183.                 order.order_status = 1
  184.                 order.save()
  185.                 # 2.1 记录扣除个人积分的流水信息
  186.                 if order.credit > 0:
  187.                     Credit.objects.create(operation=1, number=order.credit, user=order.user)
  189.                 # 2.2 补充个人的优惠券使用记录
  190.                 coupon_log = CouponLog.objects.filter(order=order).first()
  191.                 if coupon_log:
  192.                     coupon_log.use_time = now_time
  193.                     coupon_log.use_status = 1  # 1 表示已使用
  194.                     coupon_log.save()
  196.                 # 3. 用户和课程的关系绑定
  197.                 user_course_list = []
  198.                 for course in course_list:
  199.                     user_course_list.append(UserCourse(course=course, user=order.user))
  200.                 UserCourse.objects.bulk_create(user_course_list)
  202.                 # todo 4. 取消订单超时
  204.             except Exception as e:
  205.                 logger.error(f"订单支付处理同步结果发生未知错误：{e}")
  206.                 transaction.savepoint_rollback(save_id)
  207.                 return HttpResponse("fail")
  209.         return HttpResponse("success")
  211.     def query(self, request, order_number):
  212.         """主动查询订单支付的支付结果"""
  213.         try:
  214.             order = Order.objects.get(order_number=order_number)
  215.             if order.order_status > 1:
  216.                 return Response({"errmsg": "订单超时或已取消！"}, status=status.HTTP_400_BAD_REQUEST)
  217.         except Order.DoesNotExist:
  218.             return Response({"errmsg": "订单不存在！"}, status=status.HTTP_400_BAD_REQUEST)
  220.         # 获取当前订单相关的课程信息，用于返回给客户端
  221.         order_courses = order.order_courses.all()
  222.         course_list = [item.course for item in order_courses]
  223.         courses_list = []
  224.         for course in course_list:
  225.             courses_list.append(UserCourse(course=course, user=order.user))
  227.         if order.order_status == 0:
  228.             # 请求支付宝，查询订单的支付结果
  229.             alipay = AliPaySDK()
  230.             result = alipay.query(order_number)
  231.             print(f"result-{result}")
  232.             if result.get("trade_status", None) in ["TRADE_FINISHED", "TRADE_SUCCESS"]:
  233.                 """支付成功"""
  234.                 with transaction.atomic():
  235.                     save_id = transaction.savepoint()
  236.                     try:
  237.                         now_time = datetime.now()
  238.                         # 1. 修改订单状态
  239.                         order.pay_time = now_time
  240.                         order.order_status = 1
  241.                         order.save()
  242.                         # 2.1 记录扣除个人积分的流水信息
  243.                         if order.credit > 0:
  244.                             Credit.objects.create(operation=1, number=order.credit, user=order.user)
  246.                         # 2.2 补充个人的优惠券使用记录
  247.                         coupon_log = CouponLog.objects.filter(order=order).first()
  248.                         if coupon_log:
  249.                             coupon_log.use_time = now_time
  250.                             coupon_log.use_status = 1  # 1 表示已使用
  251.                             coupon_log.save()
  253.                         # 3. 用户和课程的关系绑定
  254.                         user_course_list = []
  255.                         for course in course_list:
  256.                             user_course_list.append(UserCourse(course=course, user=order.user))
  257.                         UserCourse.objects.bulk_create(user_course_list)
  259.                         # todo 4. 取消订单超时
  261.                     except Exception as e:
  262.                         logger.error(f"订单支付处理同步结果发生未知错误：{e}")
  263.                         transaction.savepoint_rollback(save_id)
  264.                         return Response({"errmsg": "当前订单支付未完成！请联系客服工作人员！"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
  265.             else:
  266.                 """当前订单未支付"""
  267.                 return Response({"errmsg": "当前订单未支付！"}, status=status.HTTP_400_BAD_REQUEST)
  269.         return Response({"errmsg":"当前订单已支付！"})

路由，payments/urls.py，代码：

  1. from django.urls import path,re_path
  2. from . import views
  3. urlpatterns = [
  4.     re_path("^alipay/(?P<order_number>[0-9]+)/$", views.AlipayAPIViewSet.as_view({"get":"link"})),
  5.     path("alipay/result/", views.AlipayAPIViewSet.as_view({"get":"return_result"})),
  6.     re_path("^alipay/query/(?P<order_number>[0-9]+)/$", views.AlipayAPIViewSet.as_view({"get":"query"})),
  7.     path("alipay/notify", views.AlipayAPIViewSet.as_view({"post": "notify_result"})),
  8. ]

补充：异步支付结果的处理代码的验证，只能放在线上服务器中通过支付在日志中检验。无法在本地开发中校验。因为异步通知结果是需要支付宝能访问到我们的当前站点，但是现在属于本地开发。

提交代码版本：

  1. cd /home/moluo/Desktop/luffycity
  2. git add .
  3. git commit -m "feature: 服务端接收并处理支付宝异步通知结果"
  4. git push