python3.7+flask+alipay 支付宝付款功能

文档参考github：https://github.com/fzlee/alipay/blob/master/docs/init.md

沙箱环境配置：https://opendocs.alipay.com/open/200/105311

1、进入沙箱环境进行配置，有对应的APPID和支付宝网关

2、然后设置RSA2密钥，可下载支付宝开放平台开发助手进行生成，可查看 文档 ，然后记录好密钥的存放位置

回调地址是在支付过程中，后台会默认去调用的接口，以此接口去确认支付是否成功。所以回调地址根据自己本地接口进行填写，可参考后续的完整代码；

线上真实配置也与沙箱类似，需要开通自己的支付宝账号为商家才能进行配置。

进入非沙箱环境 ，然后选择你所需要开发的应用，创建应用后填写所需的信息以及需要开通的功能，然后提交审核即可。

比如选择开发网页付款，创建后进入配置信息，而相应的服务会提醒需要商家账号才能开通使用。审核通过即可正常使用

本地代码配置文件及完整代码：

APP_PRIVATE_KEY_PATH：存放 app_private_key.txt 的文件路径

ALIPAY_PUBLIC_KEY_PATH：存放alipay_public_key.txt的文件路径

比如本地路径： d:/keys/app_private_key.txt

或 服务器路径： /mnt/keys/app_private_key.txt 

项目中安装： pip install python-alipay-sdk 

file_system.py 文件

# file_system.py
import os


env = "production"
# env = ""
if env == 'production':
    APP_PRIVATE_KEY_PATH = '/mnt/alipay_keys/app_private_key.txt'
    ALIPAY_PUBLIC_KEY_PATH = '/mnt/alipay_keys/alipay_public_key.txt'
else:
    APP_PRIVATE_KEY_PATH = os.getcwd() + '/ipay/keys/app_private_key.txt'
    ALIPAY_PUBLIC_KEY_PATH = os.getcwd() + '/ipay/keys/alipay_public_key.txt'

alipay_setting.py文件

# alipay_setting.py
from alipay import AliPay
from config import APP_PRIVATE_KEY_PATH, ALIPAY_PUBLIC_KEY_PATH


env == "production"
if env == "production":
    # 支付宝应用APPID
    APP_ID = '20210021******'
    # 支付连接(支付宝网关)
    PAY_URL = 'https://openapi.alipay.com/gateway.do?'
else:
    # 沙箱
    APP_ID = '2016102******'
    PAY_URL = 'https://openapi.alipaydev.com/gateway.do?'

# 应用私钥文件路径
APP_PRIVATE_KEY = open(APP_PRIVATE_KEY_PATH).read()

# 支付宝公钥文件路径
ALIPAY_PUBLIC_KEY = open(ALIPAY_PUBLIC_KEY_PATH).read()
# 签名方式
SIGN_TYPE = 'RSA2'
# 是否是测试环境 - 是否是支付宝沙箱，默认为 False
DEBUG = False


def alipay_trade_page_pay(pay_id, paid_price, item_name, return_url, notify_url):
    alipay = AliPay(
        appid=APP_ID,
        app_notify_url=notify_url,
        app_private_key_string=APP_PRIVATE_KEY,
        alipay_public_key_string=ALIPAY_PUBLIC_KEY,
        sign_type=SIGN_TYPE,
        debug=DEBUG
    )

    # 生成支付链接
    order_string = alipay.api_alipay_trade_page_pay(
        out_trade_no=pay_id,
        total_amount=paid_price,
        subject=item_name,
        return_url=return_url,        # 支付成功后同步回调的项目前台页面
        notify_url=notify_url   # 支付成功后异步回调的项目后台接口
    )

    # 支付链接 = 支付宝网关 +  order_string
    order_url = PAY_URL + order_string
    return order_url


# 验证支付结果
def verify_payment_result(data, signature):
    alipay = AliPay(
        appid=APP_ID,
        app_notify_url=None,
        app_private_key_string=APP_PRIVATE_KEY,
        alipay_public_key_string=ALIPAY_PUBLIC_KEY,
        sign_type=SIGN_TYPE,
        debug=DEBUG
    )
    success = alipay.verify(data, signature)
    return success

数据库模版文件，主要清楚接口是如何去调用支付宝付款功能，以及会生成怎样的数据内容

resource：了解上面支付宝配置文件 alipay_setting.py 中的接口是如何被调用，这里是结合了数据库模版 AlipayModel 的代码

import json
from config import FILE_DOMAIN_PREFIX
from model import AlipayOrderModel, UserModel
from flask_cors import cross_origin
from flask_restful import Resource
from util import id_generator
from flask_jwt_extended import jwt_required, get_jwt_identity
from flask import request, jsonify
import time
from ipay.alipay_setting import alipay_trade_page_pay, verify_payment_result
from wrapper import universal_resource_wrapper, root_role_required
# 参考路径：https://github.com/fzlee/alipay


# 创建支付宝订单接口
class CreateAlipayOrder(Resource):
    """
    itemName,paidPrice,paymentMethod,itemDeadline,setMeal
    """
    @universal_resource_wrapper(required=['paymentMethod', 'itemName', 'paidPrice','itemDeadline', 'setMeal'])
    @jwt_required
    @cross_origin(allow_headers=['Content-Type'])
    def post(self):
        data = request.get_json()
        uid = get_jwt_identity()
        item_name = data['itemName']
        paid_price = data['paidPrice']
        payment_method = data['paymentMethod']
        pay_id = id_generator(template='uuid')
        notify_url = FILE_DOMAIN_PREFIX + '/api/check_payment_success'
        return_url = FILE_DOMAIN_PREFIX + '/chooseProductking/cpkRenewalInstructions'
        # 生成支付宝付款链接
        order_url = alipay_trade_page_pay(pay_id=pay_id, paid_price=paid_price, item_name=item_name,
                                          return_url=return_url, notify_url=notify_url)
        # 保存到数据库中；
        ao = AlipayOrderModel(
            alipayId=pay_id,     # 订单编号
            itemName=item_name,     # 项目名称
            paymentMethod=payment_method,
            paidPrice=paid_price,   # 付费价格
            paymentStatus=False,
            paidAt=time.time(),
            paymentUrl=order_url,
            uid=uid,
            setMeal=data['setMeal'],
            itemDeadline=data['itemDeadline']   # 项目截止日期
        )
        ao.save()
        resp = jsonify({
            'msg': '成功创建订单数据，返回支付宝订单ID',
            'status': True,
            'alipayId': pay_id
        })
        return resp


class GetAlipayPaymentUrl(Resource):
    """alipayId"""
    @universal_resource_wrapper(required=['alipayId'])
    @cross_origin(allow_headers=['Content-Type'])
    def post(self):
        """
        alipayId
        :return:
        """
        data = request.get_json()
        url = AlipayOrderModel.get_payment_url(data['alipayId'])
        resp = jsonify({
            'msg': '获取支付宝付款链接',
            'status': True,
            'data': {
                'url': url
            }
        })
        return resp


# 验证是否支付成功，作为回调接口notify_url使用
class CheckPaymentSuccess(Resource):
    @universal_resource_wrapper(required=[])
    @cross_origin(allow_headers=['Content-Type'])
    def post(self):
        data = request.form.to_dict()
        # sign must be poped out
        signature = data.pop("sign")
        print(json.dumps(data))
        print(signature)
        # verify
        success = verify_payment_result(data, signature)
        # 交易结果判断
        if success and data["trade_status"] in ("TRADE_SUCCESS", "TRADE_FINISHED"):
            ao = AlipayOrderModel.find_by_alipay_id(data['out_trade_no'])
            ao.paymentStatus = True
            ao.save()
            usr = UserModel.find_by_uid(ao.uid)
            usr.update_expire_time(ao.setMeal, ao.itemDeadline)
            print("trade succeed")
            resp = jsonify({
                'msg': '支付成功',
                'status': True
            })
        else:
            resp = jsonify({
                'msg': '支付失败',
                'status': False
            })
        return resp


class CheckPaymentStatus(Resource):
    """
    alipayId
    """
    @universal_resource_wrapper(required=['alipayId'])
    @jwt_required
    @cross_origin(allow_headers=['Content-Type'])
    def post(self):
        uid = get_jwt_identity()
        data = request.get_json()
        ao = AlipayOrderModel.get_payment_status(uid=uid, pay_id=data['alipayId'])
        if ao is None:
            resp = jsonify({
                'msg': '支付失败，无法找到已付款订单',
                'status': False
            })
        else:
            resp = jsonify({
                'msg': '支付成功',
                'status': True,
                'data': ao
            })
        return resp


class UpdatePaymentStatusForLocal(Resource):
    """alipayId"""
    @universal_resource_wrapper(required=['alipayId'])
    @jwt_required
    @root_role_required
    @cross_origin(allow_headers=['Content-Type'])
    def post(self):
        data = request.get_json()
        ao = AlipayOrderModel.find_by_alipay_id(data['alipayId'])
        ao.paymentStatus = True
        ao.save()
        usr = UserModel.find_by_uid(ao.uid)
        usr.update_expire_time(ao.setMeal, ao.itemDeadline)
        print("trade succeed")
        resp = jsonify({
            'msg': '支付成功',
            'status': True
        })
        return resp

model：根据自己的需求自定义的数据库模版，只为跟上面的接口代码结合使用而已。

from model import Collection
import custom_field as cf


MODIFIABLE = [
    'paymentMethod',
    'itemName',
    'paidPrice',
    'paymentStatus',
    'paidAt',
    'paymentUrl',
    'uid',
    'itemDeadline',
    'setMeal'
]
UNMODIFIABLE = []

ID_KEY = 'alipayId'
ID_KEY_TEMPLATE = 'uuid'


class AlipayOrderModel(Collection):
    alipayId = cf.Uuid()
    paymentMethod = cf.String(default='alipay')
    itemName = cf.String()
    paidPrice = cf.Float()
    paymentStatus = cf.Bool()
    paidAt = cf.Time(required=False)
    paymentUrl = cf.String()
    uid = cf.Uuid()
    setMeal = cf.String(required='free', choices=['lowLevel', 'highLevel'])
    itemDeadline = cf.String(required=False, choices=['oneMonth', 'halfYear', 'oneYear'])

    meta = {"db_alias": "MAILDB", "collection": "alipay_order"}

    @classmethod
    def create_new(cls, data_, created_by):
        return super()._create_new(data_, id_key=ID_KEY,
                                   id_template=ID_KEY_TEMPLATE,
                                   created_by=created_by,
                                   strict_fields=MODIFIABLE + UNMODIFIABLE
                                   )

    def do_update(self, keys_values, update_by):
        return super()._do_update(keys_values, update_by,
                                  MODIFIABLE)

    @classmethod
    def find_by_alipay_id(cls, obj_id):
        return cls._find_by({'alipayId': obj_id})

    @classmethod
    def get_payment_url(cls, pay_id):
        obj = AlipayOrderModel._find_by(query={'alipayId': pay_id, 'paymentStatus': False})
        return obj.paymentUrl

    @classmethod
    def get_payment_status(cls, uid, pay_id):
        obj = AlipayOrderModel._find_by(query={'alipayId': pay_id, 'paymentStatus': True, 'uid': uid})
        return obj