def order_pay(request):
order_id = request.POST.get('order_id')
if not order_id:
return JsonResponse({'res':1,'errmsg':'订单不存在'})
try:
order = OrderInfo.objects.get(order_id=order_id,
status=1,
pay_method=3)
except OrderInfo.DoesNotExist:
return JsonResponse({'res':2,'errmsg':'订单信息出错'})
app_private_key_path = os.path.join(settings.BASE_DIR,'order/app_private_key.pem')
alipay_public_key_path = os.path.join(settings.BASE_DIR,'order/app_public_key.pem')
app_private_key_string = open(app_private_key_path).read()
alipay_public_key_string = open(alipay_public_key_path).read()
alipay = AliPay(
appid='2016091500515408',
app_notify_url=None,
app_private_key_string=app_private_key_string,
alipay_public_key_string=alipay_public_key_string,
sign_type= 'RSA2',
debug= True,
)
total_pay = order.total_price + order.transit_price
order_string = alipay.api_alipay_trade_page_pay(
out_trade_no= order_id,
total_amount= str(total_pay),
subject = '尚硅谷书城%s' % order_id,
return_url= None,
notify_url= None,
)
pay_url = settings.ALIPAY_URL + '?' + order_string
return JsonResponse({'res':3,'pay_url': pay_url,'message':'OK'})
def AlipayViews(request):
payorder_id = request.GET.get('payorder_id')
payorder = PayOrder.objects.get(id=payorder_id)
## 实例化支付对象
alipay = AliPay(
appid='2016101300674021',
app_notify_url=None,
app_private_key_string=alipay_private_key_string,
alipay_public_key_string=alipay_public_key_string,
sign_type="RSA2",
)
## 实例化订单
order_string = alipay.api_alipay_trade_page_pay(
subject='牛羊生鲜', ## 交易主题
out_trade_no=payorder.order_number, ## 订单号
total_amount=payorder.order_total, ## 交易总金额
return_url='http://127.0.0.1:8000/Buyer/payresult', ## 请求支付，之后及时回调的一个接口
notify_url='http://127.0.0.1:8000/Buyer/payresult' ## 通知地址，
)
## 发送支付请求
## 请求地址 支付网关 + 实例化订单
result = "https://openapi.alipaydev.com/gateway.do?" + order_string
# print(result)
return HttpResponseRedirect(result)
def check_pay(request):
passport_id = request.session.get('passport_id')
order_id = request.POST.get('order_id')
if not order_id:
return JsonResponse({'res': 1, 'errmsg': '订单不存在'})
try:
order = OrderInfo.objects.get(order_id=order_id,
passport_id=passport_id,
pay_method=3)
except OrderInfo.DoesNotExist:
return JsonResponse({'res': 2, 'errmsg': '订单信息出错'})
alipay = AliPay(
appid='2016092300577139',
app_notify_url=None,
app_private_key_path=APP_PRIVATE_KEY_PATH,
alipay_public_key_path=
ALIPAY_PUBLIC_KEY_PATH, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
sign_type='RSA2')
while True:
result = alipay.api_alipay_trade_query(order_id)
code = result.get('code')
if code == '10000' and result.get('trade_status') == 'TRADE_SUCCESS':
order.status = 2
order.trade_id = result.get('trade_no')
order.save()
return JsonResponse({'res': 3, 'message': '支付成功'})
elif code == '40004' or (code == '10000' and result.get('trade_status')
== 'WAIT_BUYER_PAY'):
time.sleep(5)
continue
else:
return JsonResponse({'res': 4, 'errmsg': '支付出错'})
def init_alipay_cfg():
'''
初始化alipay配置
:return: alipay 对象
'''
alipay = AliPay(
appid=APP_ID,
# app_private_key_path="keys/app_private_2048.txt",
# alipay_public_key_path="keys/alipay_public_2048.txt",
app_private_key_string=app_private_key_string,
alipay_public_key_string=alipay_public_key_string,
sign_type="RSA2", # RSA 或者 RSA2
debug=True # 默认False ,若开启则使用沙盒环境的支付宝公钥
)
return alipay
def get(self, request, order_id):
# 1.根据order_id查询订单对象
try:
order = OrderInfo.objects.get(pk=order_id)
except:
raise Exception('订单编号无效')
# 2.创建alipay对象
alipay = AliPay(
appid=settings.ALIPAY_APPID,
app_notify_url=None,
app_private_key_path=settings.ALIPAY_PRIVATE_KEY_PATH,
alipay_public_key_path=settings.ALIPAY_PUBLIC_KEY_PATH,
debug=settings.ALIPAY_DEBUG
)
# 3.调用方法生成url
order_string = alipay.api_alipay_trade_page_pay(
subject=settings.ALIPAY_SUBJECT,
out_trade_no=order_id, # 订单编号
total_amount=str(order.total_amount), # 支付总金额, 类型为Decimal(),不支持序列化，需要强转成str
return_url=settings.ALIPAY_RETURN_URL # 支付成功后的回调地址
)
# 4. 返回url
return Response({'alipay_url': settings.ALIPAY_GATE + order_string})
def alipay(request):
# pdb.set_trace()
order_id = request.GET.get("orderid")
totalPrice = float(request.GET.get("totalPrice"))
order = Order.objects.get(pk=order_id)
order.o_status = ORDER_STATUS_NOT_SEND
order.save()
# 构建支付的客户端 AlipayClient
alipay_client = AliPay(
appid=APP_ID,
app_notify_url=None, # 默认回调url
app_private_key_string=APP_PRIVATE_KEY,
alipay_public_key_string=
ALIPAY_PUBLIC_KEY, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
# alipay_public_key_path=os.path.join(BASE_DIR, 'alipay/app_private_key.pem'), # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
# app_private_key_path=os.path.join(BASE_DIR, 'alipay/alipay_public_key.pem'),
sign_type="RSA2", # RSA 或者 RSA2
debug=True # 默认False
)
# 使用Alipay进行支付请求的发起
subject = "购买商品所需费用"
# 电脑网站支付，需要跳转到https://openapi.alipay.com/gateway.do? + order_string
order_string = alipay_client.api_alipay_trade_page_pay(
out_trade_no=uuid.uuid4().hex,
total_amount=totalPrice,
subject=subject,
# return_url="http://www.fand.wang/forgood/changestate/",
return_url="http://127.0.0.1:8080/axf/mine/",
# notify_url="http://www.fand.wang" # 可选, 不填则使用默认notify url
)
# 客户端操作
return redirect("https://openapi.alipaydev.com/gateway.do?" + order_string)
def order_pay(order_id):
"""发起支付宝支付"""
user_id = g.user_id
# 判断订单状态
try:
order = Order.query.filter(Order.id == order_id, Order.user_id == user_id, Order.status == "WAIT_PAYMENT").first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库异常")
if order is None:
return jsonify(errno=RET.NODATA, errmsg="订单数据有误")
# 创建支付宝sdk的工具对象
alipay_client = AliPay(
appid="2016081600258081",
app_notify_url=None, # 默认回调url
app_private_key_path=os.path.join(os.path.dirname(__file__), "keys/app_private_key.pem"), # 私钥
alipay_public_key_path=os.path.join(os.path.dirname(__file__), "keys/alipay_public_key.pem"), # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
sign_type="RSA2", # RSA 或者 RSA2
debug=True # 默认False
)
# 手机网站支付，需要跳转到https://openapi.alipaydev.com/gateway.do? + order_string
order_string = alipay_client.api_alipay_trade_wap_pay(
out_trade_no=order.id, # 订单编号
total_amount=str(order.amount/100.0), # 总金额
subject=u"爱家租房 %s" % order.id, # 订单标题
return_url="http://127.0.0.1:5000/payComplete.html", # 返回的连接地址
notify_url=None # 可选, 不填则使用默认notify url
)
# 构建让用户跳转的支付连接地址
pay_url = constants.ALIPAY_URL_PREFIX + order_string
return jsonify(errno=RET.OK, errmsg="OK", data={"pay_url": pay_url})
def pay(request):
if request.method == 'POST':
newOrder = Order()
newOrder.number = datetime.now().strftime("%Y%m%d%H%M%S%f")
newOrder.money = int(request.POST.get('summary')[0:-3])
newOrder.create_time = datetime.now()
newOrder.uid = request.user
newOrder.receiver = request.POST.get('receiver')
newOrder.address = request.POST.get('address')
newOrder.mobile = request.POST.get('mobile')
clist = ''
idlist = request.POST.getlist('cid')
for cid in idlist:
c = cid + '/' + request.POST.get('quantity' + cid) + ','
clist += c
newOrder.clist = clist
newOrder.save()
alipay = AliPay(appid=ALI_APP_ID,
app_notify_url=None,
app_private_key_string=APP_PRIVATE_KEY,
alipay_public_key_string=ALIPAY_PUBLIC_KEY,
sign_type="RSA2",
debug=False)
order_string = alipay.api_alipay_trade_page_pay(
out_trade_no="{}".format(newOrder.number),
total_amount=newOrder.money,
subject=newOrder.number,
return_url="http://49.234.99.134/finish/?id=" + str(newOrder.id),
notify_url="http://49.234.99.134/orders/",
)
net = "https://openapi.alipaydev.com/gateway.do?{}".format(
order_string)
return redirect(net)
return redirect(reverse('app:index'))
def put(self, request):
query_dict = request.GET
data = query_dict.dict()
signature = data.pop('sign')
alipay = AliPay(appid=settings.ALIPAY_APPID,
app_notify_url=None,
app_private_key_path=os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"keys/app_private_key.pem"),
alipay_public_key_path=os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'keys/app_public_key.pem'),
sign_type="RSA2",
debug=settings.ALIPAY_DEBUG)
success = alipay.verify(data, signature)
if success:
order_id = data.get('out_trade_no')
trade_id = data.get('trade_no')
Payment.objects.create(order_id=order_id, trade_id=trade_id)
#修改订单状态
OrderInfo.objects.filter(
order_id=order_id,
status=OrderInfo.ORDER_STATUS_ENUM['UNPAID']).update(
status=OrderInfo.ORDER_STATUS_ENUM['UNCOMMENT'])
return JsonResponse({
'code': 0,
'errmsg': 'ok',
'trade_id': trade_id
})
else:
return JsonResponse({'code': 400, 'errmsg': '非法请求'})
def get(self, request, order_id):
# 判断订单是否正确
user = request.user
try:
order = OrderInfo.objects.get(
order_id=order_id,
user=user,
pay_method=OrderInfo.PAY_METHODS_ENUM['ALIPAY'],
status=OrderInfo.ORDER_STATUS_ENUM['UNPAID'])
except OrderInfo.DoesNotExist:
return Response({'message': '订单信息有误'},
status=status.HTTP_400_BAD_REQUEST)
# 向支付宝获取给用户支付页面的链接请求
alipay = AliPay(
appid=settings.ALIPAY_APPID,
app_notify_url=None, # 默认回调url
app_private_key_path=os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"keys/app_private_key.pem"),
alipay_public_key_path=os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"keys/alipay_public_key.pem"), # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
sign_type="RSA2", # RSA 或者 RSA2
debug=settings.ALIPAY_DEBUG, # 默认False
)
# 电脑网站支付，需要跳转到https://openapi.alipay.com/gateway.do? + order_string
order_string = alipay.api_alipay_trade_page_pay(
out_trade_no=order_id, # 订单编号
total_amount=str(order.total_amount + order.freight),
subject="测试订单,美多商城%s" % order_id,
return_url="http://www.meiduo.site:8080/pay_success.html",
# notify_url="https://example.com/notify", # 可选, 不填则使用默认notify url
)
# 返回alipay_url
alipay_url = settings.ALIPAY_URL + '?' + order_string
return Response({'alipay_url': alipay_url})
def put(self, request):
# 接收参数，效验参数
# 构造支付宝支付链接地址
alipay_req_data = request.query_params
if not alipay_req_data:
return Response({"message": "缺啥参数"},
status=status.HTTP_400_BAD_REQUEST)
alipay_req_dict = alipay_req_data.dict()
sign = alipay_req_dict.pop("sign")
alipay = AliPay(
appid=dev.ALIPAY_APPID,
app_notify_url=None, # 默认回调url
app_private_key_path=os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"keys/app_private_key.pem"),
alipay_public_key_path=os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"keys/alipay_public_key.pem"), # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
sign_type="RSA2", # RSA 或者 RSA2
debug=dev.ALIPAY_DEBUG # 默认False
)
result = alipay.verify(alipay_req_dict, sign)
# 保存数据，保存支付结果数据
if result:
order_id = alipay_req_dict.get("out_trade_no")
trade_id = alipay_req_dict.get("trade_no")
# 修改订单状态
Payment.objects.create(order_id=order_id, trade_id=trade_id)
OrderInfo.objects.filter(order_id=order_id).update(
status=OrderInfo.ORDER_STATUS_ENUM["UNCOMMENT"])
return Response({"trade_id": trade_id})
else:
return Response({"message": "参数有误"},
status=status.HTTP_400_BAD_REQUEST)
def pay(request):
money = request.GET.get('money')
# 构建支付的客户端 AlipayClient
alipay_client = AliPay(
appid=ALIPAY_APPID,
app_notify_url=None, # 默认回调url
app_private_key_string=APP_PRIVATE_KEY,
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
alipay_public_key_string=ALIPAY_PUBLIC_KEY,
sign_type="RSA2", # RSA 或者 RSA2
debug=False # 默认False
)
# 使用Alipay进行支付请求的发起
subject = '停车费13'
# 客户端操作
no = str(int(time.time()))
order_string = alipay_client.api_alipay_trade_page_pay(
out_trade_no=no,
total_amount=money,
subject=subject,
return_url="http://127.0.0.1:8000/index",
notify_url="" # 可选, 不填则使用默认notify url
)
return redirect('https://openapi.alipaydev.com/gateway.do?' + order_string)
def alipayfun():
# 构造支付请求
app_private_key_string = open(os.path.join(settings.BASE_DIR, 'alipay_key/应用私钥2048.txt')).read()
alipay_public_key_string = open(os.path.join(settings.BASE_DIR, 'alipay_key/alipay_public_key.txt')).read()
# 初始化对象
alipay = AliPay(
appid="2016092400582448",
app_notify_url=None, # 默认回调url
app_private_key_string=app_private_key_string,
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
alipay_public_key_string=alipay_public_key_string,
sign_type="RSA2", # RSA 或者 RSA2
debug=True # 默认False
)
return alipay
def get_alipay():
app_private_key_string = open(BASE_DIR +
"/utils/app_private_key.pem").read()
alipay_public_key_string = open(BASE_DIR +
"/utils/app_public_key.pem").read()
alipay = AliPay(
appid="2016091500515408",
app_notify_url=
'http://127.0.0.1:8000/orders/pay_success/?order=9', # 默认回调url
app_private_key_string=app_private_key_string,
alipay_public_key_string=
alipay_public_key_string, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
sign_type="RSA2", # RSA 或者 RSA2
debug=True # 默认False
)
return alipay
def get_alipay():
#初始化主支付对象
app_private_key_string = open(
settings.ALIAPY_CONFIG["app_private_key_path"]).read()
alipay_public_key_string = open(
settings.ALIAPY_CONFIG["alipay_public_key_path"]).read()
alipay = AliPay(
appid=settings.ALIAPY_CONFIG["appid"],
app_notify_url=settings.ALIAPY_CONFIG["app_notify_url"], # 默认回调url
app_private_key_string=app_private_key_string,
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
alipay_public_key_string=alipay_public_key_string,
sign_type=settings.ALIAPY_CONFIG["sign_type"],
debug=settings.ALIAPY_CONFIG["debug"] # 默认False
)
return alipay
def init_alipay_obj():
"""
初始化alipay对象
:return: alipay object
"""
alipay = AliPay(
appid= settings.ALIPAY_APPID,
app_notify_url= None,
app_private_key_path=os.path.join(os.path.dirname(__file__), "keys/app_private_key.pem"),
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
alipay_public_key_path=os.path.join(os.path.dirname(__file__), "keys/alipay_public_key.pem"),
sign_type="RSA2", # RSA 或者 RSA2
debug=True # 默认False
)
return alipay
def post(self, request):
'''订单支付'''
#用户是否登录
user = request.user
if not user.is_authenticated():
return JsonResponse({'res': 0, 'errmsg': '用户未登录'})
#接受参数
order_id = request.POST.get('order_id')
#校验参数
if not order_id:
return JsonResponse({'res': 1, 'errmsg': '无效订单id'})
try:
order = OrderInfo.objects.get(
order_id=order_id,
user=user,
pay_method=3,
order_status=1,
)
except OrderInfo.DoseNotExist:
return JsonResponse({'res': 2, 'errmsg': '订单错误'})
#业务处理：使用python sdk调用支付宝的支付接口
#初始化
pay = AliPay(
appid="2016080900462020", #应用id
app_notify_url=None, #默认回调url
app_private_key_path=os.path.join(
settings.BASE_DIR, 'apps/order/app_private_key.pem'),
alipay_public_key_path=os.path.join(
settings.BASE_DIR, 'apps/order/alipay_public_key.pem'),
sign_type='RSA2', #RSA或者RSA2
debug=True, #默认false
)
#调用支付接口
#电脑网站支付，需要跳转到https://openapi.alipay.com/gatewa.do?+order_string
total_pay = order.total_price + order.transit_price
order_string = alipay.api_alipay_trade_page_pay(
out_trade_no=order_id, #订单id
total_amount=str(total_pay), #支付总金额
subject='天天生鲜%s' % order_id,
return_url=None,
notify_url=None, #可选，不填则使用默认notify url
)
#返回应答
pay_url = "https://openapi.alipaydev.com/gateway.do?" + order_string
return JsonResponse({'res': 3, 'pay_url': pay_url})
def create_alipay():
"""
创建支付宝对象
:return: 支付宝对象
"""
alipay = AliPay(
appid=settings.ALIPAY_APPID,
# 回调地址
app_notify_url=None,
# 公钥路径
alipay_public_key_path=settings.ALIPAY_PUBLIC_KEY_PATH,
# 私钥路径
app_private_key_path=settings.APP_PRIVATE_KEY_PATH,
# 加密方式
sign_type='RSA2',
debug=True,
)
return alipay
def createAlipay():
# 创建对接支付宝接口的SDK对象
app_private_key_string = open(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
"keys/app_private_key.pem")).read()
alipay_public_key_string = open(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
"keys/alipay_public_key.pem")).read()
alipay = AliPay( # 传入公共参数（对接任何接口都要传递的）
appid=settings.ALIPAY_APPID, # 应用ID
app_notify_url=None, # 默认回调url，如果采用同步通知就不传
# 应用的私钥和支付宝公钥的路径
app_private_key_string=app_private_key_string,
alipay_public_key_string=alipay_public_key_string,
sign_type="RSA2", # 加密标准
debug=settings.ALIPAY_DEBUG # 指定是否是开发环境
)
return alipay
def post(self, request):
"""创建alipay对象,调用支付接口"""
# 获取订单id
order_id = request.POST.get('order_id')
# 校验订单id
if not order_id:
return JsonResponse({'code':2, 'message':'没有订单id'})
# 获取订单信息:状态是待支付，支付方式是支付宝
try:
order = OrderInfo.objects.get(order_id=order_id, user=request.user,
status=OrderInfo.ORDER_STATUS_ENUM["UNPAID"],
pay_method=OrderInfo.PAY_METHODS_ENUM["ALIPAY"])
except OrderInfo.DoesNotExist:
return JsonResponse({'code': 3, 'message': '订单错误'})
# 创建用于支付宝支付的对象
alipay = AliPay(
appid = settings.ALIPAY_APPID,
app_notify_url = None, # 默认回调url
# 自己生产的私钥
app_private_key_path = settings.APP_PRIVATE_KEY_PATH,
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
alipay_public_key_path = settings.ALIPAY_PUBLIC_KEY_PATH,
sign_type = "RSA2", # RSA 或者 RSA2
debug = True # 默认False 配合沙箱模式使用
)
# 电脑网站支付，需要跳转到https://openapi.alipaydev.com/gateway.do? + order_string
order_string = alipay.api_alipay_trade_page_pay(
out_trade_no = order_id,
total_amount = str(order.total_amount), # 将浮点数转成字符串
subject = '天天生鲜',
return_url = None,
notify_url = None # 可选, 不填则使用默认notify url
)
# 生成url:让用户进入支付宝页面的支付网址
url = settings.ALIPAY_URL + '?' + order_string
# 响应结果
return JsonResponse({'code':0, 'message':'支付成功', 'url':url})
def order_pay():
# 实例化Alipay，并加上alipay需要的一些参数
alipay = AliPay(
appid="2016090800465324",
app_notify_url='http://39.106.96.112',
app_private_key_path=app.config["app_private_key_path"],
alipay_public_key_path=app.config["alipay_public_key_path"],
sign_type="RSA2",
debug=True,
)
# 加上订单的参数
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
n = random.randint(0, 1000000)
# create an order
print(n)
result = alipay.api_alipay_trade_precreate(
subject="水杯",
out_trade_no=str(n),
total_amount=100,
timeout_express="10m"
)
import qrcode
qr = qrcode.QRCode(
version=1,
error_correction=qrcode.constants.ERROR_CORRECT_L,
box_size=10,
border=4,
)
qr.add_data(result["qr_code"])
qr.make(fit=True)
img = qr.make_image()
img.save(str(n)+'.png')
print(img)
# check order status
paid = False
for i in range(10):
# check every 3s, and 10 times in all
print("now sleep 3s")
time.sleep(5)
result = alipay.api_alipay_trade_query(out_trade_no=str(n))
if result.get("trade_status", "") == "TRADE_SUCCESS":
paid = True
print("success")
break
print("not paid...")
# order is not paid in 30s , cancel this order
if paid is False:
alipay.api_alipay_trade_cancel(out_trade_no=str(n))
class MyAlipay(View):
def __init__(self, **kwargs):
# 首先调用父类的构造函数
super().__init__(**kwargs)
# 创建一个Alipay对象
self.alipay = AliPay(
# 应用ID
appid=settings.ALIPAY_APP_ID,
# 接受支付宝的url:
app_notify_url=None,
# 用户私钥 把自己的私钥传给支付宝，在开发者模式里面设置已经给过公钥
app_private_key_string=app_private_key_string,
# 支付宝公钥
alipay_public_key_string=alipay_public_key_string,
# 非对称加密的算法
sign_type='RSA2',
# 指定为调试模式，请求会发送到沙箱服务器
debug=True,
)
print(settings.ALIPAY_APP_ID)
print(app_private_key_string)
print(alipay_public_key_string)
def get_trade_url(self, order_id, amount):
# 步骤: 编写一个父类，在够在函数中，初始化一个alipay对象
# 调用alipay的方法完成功能
# 根据参数生成订单的查询字符串
base_url = 'https://openapi.alipaydev.com/gateway.do'
order_string = self.alipay.api_alipay_trade_page_pay(
# 1 订单编号
out_trade_no=order_id,
# 2. 订单总金额
total_amount=amount,
# 3. 订单标题
subject=order_id,
# 4.用户支付完成后，告诉支付宝跳转到商家的哪个页面
return_url=settings.ALIPAY_RETURN_URL,
# 5。 支付结果通知的url
notify_url=settings.ALIPAY_NOTIFY_URL,
)
return base_url + '?' + order_string
def alipay_ini():
with open(os.path.join(current_app.root_path,
'trade/app_private_key.pem')) as f:
app_private_key_string = f.read()
with open(
os.path.join(current_app.root_path,
'trade/alipay_public_key.pem')) as f:
alipay_public_key_string = f.read()
alipay = AliPay(
appid="2021001146618124",
app_notify_url="http://sorapage.com/alipay/callback",
app_private_key_string=app_private_key_string,
alipay_public_key_string=alipay_public_key_string,
sign_type="RSA2",
debug=False, # 默认False
verbose=False, # 输出调试数据
config=AliPayConfig(timeout=15) # 可选, 请求超时时间
)
return alipay
def post(self, request):
if not request.user.is_authenticated():
return JsonResponse({'code': 1, 'message': '用户未登录'})
order_id = request.POST.get('order_id')
try:
order = OrderInfo.objects.get(order_id=order_id,
user=request.user)
except OrderInfo.DoesNotExist:
return JsonResponse({'code': 2, 'message': '无效订单'})
if not order_id:
return JsonResponse({'code': 3, 'message': '订单id不能为空'})
# 调用 第三方sdk, 实现支付功能
# (1) 初始化sdk
from alipay import AliPay
app_private_key_string = open("apps/orders/app_private_key.pem").read()
alipay_public_key_string = open("apps/orders/alipay_public_key.pem").read()
alipay = AliPay(
appid="2016091000481374", # 沙箱应用
app_notify_url=None, # 默认回调url
app_private_key_string=app_private_key_string,
alipay_public_key_string=alipay_public_key_string, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
sign_type="RSA2", # RSA 或者 RSA2 # 不要使用rsa
debug=True # 默认False True: 表示使用测试环境(沙箱环境)
)
while True:
result_dict = alipay.api_alipay_trade_query(out_trade_no=order_id)
code = result_dict.get('code')
trade_status = result_dict.get('trade_status')
trade_no = result_dict.get('trade_no')
if code == '10000' and trade_status == 'TRADE_SUCCESS':
order.status = 4 # 待评价
order.trade_no = trade_no
order.save() # 修改订单信息表
return JsonResponse({'code': 0, 'message': '支付成功'})
elif (code == '10000' and trade_status == 'WAIT_BUYER_PAY') or code == '40004':
sleep(2)
continue
else:
return JsonResponse({'code': 4, 'message': '支付失败'})
def _init_ali_pay(self):
path = os.path.abspath(os.path.dirname(__file__))
private_file = open(settings.ALI_PAY_PRIVATE_KEY_PATH, "r")
private_key = private_file.read()
private_file.close()
public_file = open(settings.ALI_PAY_PUBLIC_KEY_PATH, "r")
public_key = public_file.read()
public_file.close()
debug = settings.DJANGO_IN_DOCKER_DEBUG is None
appid = settings.ALI_PAY_APP_ID
app_notify_url = settings.ALI_PAY_APP_NOTIFY_URL
alipay = AliPay(appid=appid,
app_notify_url=app_notify_url,
app_private_key_string=private_key,
alipay_public_key_string=public_key,
debug=debug)
return AliPayment(alipay)
def ali():
# 商户 app_id
app_id = "2016101700708422" # 复制来自支付宝生成的 id
# 服务器异步通知页面路径 需 http: // 格式的完整路径，不能加?id = 123这类自定义参数，必须外网可以正常访问
# 对于 PC 网站支付的交易，在用户支付完成之后，支付宝会根据 API 中商户传入的 notify_url，通过 POST 请求的形式将支付结果作为参数通知到商户系统
# 发 post 请求
notify_url = "http://127.0.0.1:8000/order/page1/"
return_url = "http://127.0.0.1:8000/order/return_pay/"
merchant_private_key_path = "keys/pri" # 设置公钥和私钥的地址，文件上下两行 begin 和 end 是必须的，公钥就放在第二行。
alipay_public_key_path = "keys/pub"
alipay = AliPay(
appid=app_id,
app_notify_url=notify_url,
app_private_key_path=merchant_private_key_path,
alipay_public_key_path=
alipay_public_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥
sign_type="RSA2",
debug=True, # 默认 False,
)
return alipay
class MyAliPay(View):
def __init__(self, **kwargs):
# 首先调用父类的构造函数
super().__init__(**kwargs)
# 创建alipay对象
self.alipay = AliPay(
# 应用id
appid=settings.ALIPAY_APPID,
# 接受结果的url
app_notify_url=None,
# 用户私钥
app_private_key_string=app_private_key_string,
# 支付宝公钥
alipay_public_key_string=alipay_public_key_string,
# 非对称加密算法
sign_type='RSA2',
# 制定调试/沙箱模式
debug=True,
)
print(app_private_key_string)
print(alipay_public_key_string)
def get_trade_url(self, order_id, amount):
base_url = 'https://openapi.alipaydev.com/gateway.do'
# 根据参数生成订单的查询字符串
order_string = self.alipay.api_alipay_trade_page_pay(
# 1 订单编号
out_trade_no=order_id,
# 2 订单总金额
total_amount=amount,
# 3 订单标题
subject=order_id,
# 4 用户支付完成后，告知支付宝跳转到商家的哪个页面
return_url=settings.ALIPAY_RETURN_URL,
# 5 支付结果通知的url
notify_url=settings.ALIPAY_NOTIFY_URL,
)
print(base_url + '?' + order_string)
return base_url + '?' + order_string
def kb_alipay():
APP_PRIVATE_KEY_PATH = os.path.join(
settings.BASE_DIR, "utils/kbalipay/alipay_keys/app_private.pem")
ALIPAY_PUBLIC_KEY_PATH = os.path.join(
settings.BASE_DIR, "utils/kbalipay/alipay_keys/alipay_public.pem")
app_private_key_string = open(APP_PRIVATE_KEY_PATH).read()
alipay_public_key_string = open(ALIPAY_PUBLIC_KEY_PATH).read()
alipay = AliPay(
appid=settings.ALIPAY_APPID,
app_notify_url=None, # 默认回调url
app_private_key_string=app_private_key_string,
alipay_public_key_string=alipay_public_key_string,
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
sign_type="RSA2", # RSA 或者 RSA2
debug=True # 默认False 配合沙箱模式使用
)
ali_url = {
'alipay_url': settings.ALIPAY_URL,
'return_url': settings.RETURN_URL,
'notify_url': settings.NOTICE_URL,
}
return ali_url, alipay
def init_alipay_cfg(appID:str, publicKey:str, privateKey:str, callbackUrl:str):
'''
初始化alipay配置
:return: alipay 对象
'''
ssl._create_default_https_context = ssl._create_unverified_context
publicKey = '''-----BEGIN PUBLIC KEY-----\n ''' + publicKey + '''\n-----END PUBLIC KEY-----'''
privateKey = '''-----BEGIN RSA PRIVATE KEY-----\n''' + privateKey + '''\n-----END RSA PRIVATE KEY-----'''
# print(publicKey)
alipay = AliPay(
appid=appID,
app_notify_url=callbackUrl, # 默认回调url
# app_private_key_string=app_private_key_string,
# alipay_public_key_string=alipay_public_key_string, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
app_private_key_string=privateKey,
alipay_public_key_string=publicKey, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
sign_type="RSA2", # RSA 或者 RSA2
debug=False # 默认False ,若开启则使用沙盒环境的支付宝公钥
)
return alipay
def y_alipay():
with open(
os.path.join(settings.BASE_DIR,
'extends/alipay/web_private_key.txt').replace(
"\\", "/")) as f:
app_private_key_string = f.read()
with open(
os.path.join(settings.BASE_DIR,
'extends/alipay/alipay_public_key.txt').replace(
"\\", "/")) as f:
alipay_public_key_string = f.read()
alipay = AliPay(
appid=configs.APPID,
app_notify_url=configs.APP_NOTIFY_URL,
app_private_key_string=app_private_key_string,
alipay_public_key_string=alipay_public_key_string,
sign_type="RSA2",
debug=False,
)
return alipay
# -- coding UTF-8 --
from alipay import AliPay
import qrcode # 导入模块
alipay = AliPay(
appid=2017051207221985,
app_notify_url=https91vps.club20170526freenom,
app_private_key_path=app_private_key_path.txt,
alipay_public_key_path=alipay_public_key_path.txt # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
)
# create an order
result = alipay.api_alipay_trade_precreate(
subject=test subject,
out_trade_no=out_trade_no,
total_amount=10
)
img = qrcode.make(result['qr_code']) # QRCode信息
img.save(test.png) # 保存图片
