class MyAliPay(View):
def __init__(self, **kwargs):
super().__init__(**kwargs)
# 初始化alipay
self.alipay = AliPay(
appid=settings.ALIPAY_APP_ID,
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 # 默认是False，True是请求转发到沙箱
)
def get_trade_url(self, order_id, price):
# 生成支付宝支付连接 https://openapi.alipaydev.com/gateway.do? +查询字符串
# 拼接查询字符串的函数
query_str = self.alipay.api_alipay_trade_page_pay(
out_trade_no=order_id,
total_amount=price,
subject=f'达达商城:{order_id}', # 对订单的描述
return_url=settings.ALIPAY_RETURN_URL,
notify_url=settings.ALIPAY_NOTIFY_URL,
)
return f'https://openapi.alipaydev.com/gateway.do?{query_str}'
def get_verify_result(self, data, sign):
# 调用支付宝验签，返回 bool 值
return self.alipay.verify(data, sign)
def get_trade_result(self, order_id):
# 查询支付结果
reslut = self.alipay.api_alipay_trade_query(order_id)
print('-----------:', reslut)
return True if reslut.get('trade_status') == 'TRADE_SUCCESS' else False
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.DoesNotExist:
return JsonResponse({'res': 2, 'errmsg': '订单错误'})
# 业务处理:使用python sdk调用支付宝的支付接口
# 初始化
alipay = AliPay(
appid="2016090800464054", # 应用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
)
# 调用支付宝的交易查询接口
while True:
# 调用alipay工具查询支付结果
response = alipay.api_alipay_trade_query(order_id) # response是一个字典
# 判断支付结果
code = response.get("code") # 支付宝接口调用成功或者错误的标志
trade_status = response.get("trade_status") # 用户支付的情况
if code == "10000" and trade_status == "TRADE_SUCCESS":
# 表示用户支付成功
# 返回前端json，通知支付成功
return JsonResponse({"res": 3, "message": "支付成功"})
elif code == "40004" or (code == "10000"
and trade_status == "WAIT_BUYER_PAY"):
# 表示支付宝接口调用暂时失败，（支付宝的支付订单还未生成） 后者 等待用户支付
# 继续查询
print(code)
print(trade_status)
continue
else:
# 支付失败
# 返回支付失败的通知
return JsonResponse({"code": 1, "message": "支付失败"})
def check_pay(request):
"""获取用户支付的结果"""
#用户登陆判断
if not request.session.has_key('islogin'):
return JsonResponse({'res':0,'errmsg':'用户未登录'})
passport_id = request.session.get('passport_id')
#接收订单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':'订单信息出错'})
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", #应用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", #RSA 或者RSA2
debug=True, #默认False
)
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 get(self, request):
user = request.user
order_id = request.GET.get('out_trade_no')
if not all([order_id]):
return JsonResponse({'res': 1, 'errmsg': '缺少参数'})
try:
order = OrderInfo.objects.get(
order_id=order_id,
user=user,
order_status=1,
pay_method=3,
)
except OrderInfo.DoesNotExist:
return HttpResponse('订单信息错误')
ali_pay = AliPay(
appid=settings.ALIPAY_APP_ID,
app_notify_url=settings.ALIPAY_APP_NOTIFY_URL,
app_private_key_path=settings.APP_PRIVATE_KEY_PATH,
alipay_public_key_path=settings.ALIPAY_PUBLIC_KEY_PATH,
sign_type="RSA2",
debug=settings.ALIPAY_DEBUG)
response = ali_pay.api_alipay_trade_query(out_trade_no=order_id)
res_code = response.get('code')
if res_code == '10000' and response.get(
'trade_status') == 'TRADE_SUCCESS':
order.trade_no = response.get('trade_no')
order.save()
return render(request, 'pay_result.html', {'pay_result': '支付成功'})
else:
return render(request, 'pay_result.html', {'pay_result': '支付失败'})
def post(self, requset):
# 用户是否登录
user = requset.user
if not user.is_authenticated:
return JsonResponse({'res': 0, 'errmsg': '用户未登录'})
# 接收参数
order_id = requset.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=1,
order_status=1)
except order.DoesNotExist:
return JsonResponse({'res': 2, 'errmsg': '订单错误'})
# 业务逻辑：查询订单支付的结果
app_private_key_string = open(
os.path.join(BASE_DIR,
"apps/order/alipay/app_private_key.pem")).read()
alipay_public_key_string = open(
os.path.join(BASE_DIR,
'apps/order/alipay/alipay_public_key.pem')).read()
# 初始化
alipay = AliPay(
appid="2016102300746102", # 应用的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=True)
# 调用支付宝的查询接口
while True:
response = alipay.api_alipay_trade_query(out_trade_no=order_id)
code = response.get('code')
if code == '10000' and response.get(
'trade_status') == 'TRADE_SUCCESS':
# 支付成功
# 获取支付宝交易号
# 更新订单状态
order.trade_no = response.get("trade_no")
order.order_status = 4
order.save()
# 返回结果
return JsonResponse({'res': 3, 'message': '支付成功'})
elif code == '40004' or (code == '10000'
and response.get('trade_status')
== 'WAIT_BUYER_PAY'):
# 等待买家付款
# 业务处理失败，可能一会就会成功
import time
time.sleep(5)
continue
else:
# 支付出错
return JsonResponse({'res': 4, 'errmsg': '支付失败'})
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.DoesNotExist:
return JsonResponse({'res':2,'errmsg':'订单错误'})
# 业务处理：使用python sdk调用支付宝的支付接口
# 初始化
alipay = AliPay(
appid="2016101100663392", # 应用id，模拟时用沙箱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,沙箱用True
)
# 调用支付宝交易查询接口
while True:
response = alipay.api_alipay_trade_query(order_id)
code = response.get('code')
if code == '10000' and response.get('trade_status') == 'TRADE_SUCCESS':
# 支付成功
# 获取支付宝交易号
trade_no = response.get('trade_no')
# 更新订单状态
order.trade_no = trade_no
order.order_status = 4 # 待评价
order.save()
# 返回结果
return JsonResponse({'res': 3, 'message': '支付成功'})
elif code == '40004' or (code == '10000' and response.get('trade_status') == 'WAIT_BUYER_PAY'):
# 等待买家付款
# 业务处理失败，可能一会成功
import time
time.sleep(5)
continue
else:
# 支付出错
return JsonResponse({'res':4,'errmsg':'支付失败'})
class Pay:
def __init__(self):
if not settings.USE_ALIPAY:
return
# NOTE 暂时只支持支付宝
self.alipay = AliPay(
app_notify_url="",
appid=settings.ALIPAY_APP_ID,
app_private_key_string=settings.ALIPAY_APP_PRIVATE_KEY_STRING,
alipay_public_key_string=settings.ALIPAY_PUBLIC_KEY_STRING,
)
def trade_precreate(self, out_trade_no, total_amount, subject,
timeout_express, notify_url):
return self.alipay.api_alipay_trade_precreate(
out_trade_no=out_trade_no,
total_amount=total_amount,
subject=subject,
timeout_express=timeout_express,
notify_url=notify_url,
)
def trade_query(self, out_trade_no):
return self.alipay.api_alipay_trade_query(out_trade_no=out_trade_no)
def verify(self, data, signature):
return self.alipay.verify(data=data, signature=signature)
def checkpay(request):
orderid = request.POST.get('orderid')
if not orderid:
return JsonResponse({'status':500,'msg':'必须传递订单号'})
alipay_public_key_string = open(PUBLIC_KEY).read()
app_private_key_string = open(PRIVATE_KEY).read()
alipay = AliPay(
appid="2021000116697358",
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=False # 默认False
)
while True:
response = alipay.api_alipay_trade_query(orderid)
#判断response的结果
print(response)
if response.get('code')=='10000' and response.get('trade_status'):
money = math.floor(response.get('total_amount'))
request.user.beans += (money*2)
request.user.save()
return JsonResponse({'status':200,'msg':'支付成功！'})
elif response.get('code' == '40004') or (
response.get('code') == '10000' and response.get('trade_status') == 'WAIT_BUYER_PAY'):
time.sleep(3)
continue
else:
print(response.get('code') )
print(response.get('trade_status'))
return JsonResponse({'status':500,'msg':'支付失败！'})
def check_pay(self, order_id):
alipay_ = AliPay(appid=APPID,
app_notify_url=None,
app_private_key_path=app_private_key_path,
alipay_public_key_path=alipay_public_key_path,
sign_type='RSA2',
debug=True)
_ = 0
while True:
_ += 1
try:
response = alipay_.api_alipay_trade_query(order_id)
code = response.get('code')
sub_msg = response.get('sub_msg')
trade_status = response.get('trade_status')
if code == "10000" and trade_status == 'TRADE_SUCCESS':
#付款成功，需要改变状态，，未做完
return {"code": 1, "message": "成功"}
elif code == '40004' or (code == "10000"
and trade_status == "WAIT_BUYER_PAY"):
if _ >= 60:
#需要在此标记订单状态###此处是ＢＵＧ
break
time.sleep(2)
continue
else:
return {"code": -1, "message": "失败"}
except Exception as e:
time.sleep(3)
return {"code": -2, "message": "失败"}
class MyAliPay(View):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.alipay = AliPay(
appid=settings.ALIPAY_APPID,
app_private_key_string=app_private_key_string,
alipay_public_key_string=alipay_public_key_string,
app_notify_url=None,
sign_type="RSA2",
debug=True #默认False True则将请求转发沙箱环境
)
def get_trade_url(self, order_id, amount):
order_string = self.alipay.api_alipay_trade_page_pay(
subject=order_id,
out_trade_no=order_id,
total_amount=amount,
#支付完毕后，将用户跳转至哪个页面
return_url=settings.ALIPAY_RETURN_URL,
notify_url=settings.ALIPAY_NOTIFY_URL)
return "https://openapi.alipaydev.com/gateway.do?" + order_string
def get_verify_result(self, data, sign):
#验证签名 True 成功 False 失败
return self.alipay.verify(data, sign)
def get_trade_result(self, order_id):
#主动查询
result = self.alipay.api_alipay_trade_query(order_id)
if result.get('trade_status') == 'TRADE_SUCCESS':
return True
return False
def star(request):
# 读取私钥
app_private_key_string = open(os.path.join(settings.BASE_DIR, 'apps/order/private.txt')).read()
# 读取公钥
alipay_public_key_string = open(os.path.join(settings.BASE_DIR, 'apps/order/public.txt')).read()
alipay = AliPay(
appid="2016092300576093",
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
)
# 获取参数
out_trade_no = request.GET.get('out_trade_no')
paid = False
for i in range(3):
result = alipay.api_alipay_trade_query(out_trade_no=out_trade_no)
if result.get("trade_status", "") == "TRADE_SUCCESS":
paid = True
break
else:
time.sleep(10)
# 判断是否支付成功
if paid is False:
context = {'star': '支付失败!'}
else:
context = {'star': '支付成功!'}
# 修改订单状态
trade_no = request.GET.get('trade_no')
order = OrderStatus.objects.filter(order_number=trade_no, is_delete=False).update(order_state=5)
# 渲染页面
return render(request, 'pay_detail.html', context)
class MyAlipay(View):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.alipay = AliPay(appid=settings.ALIPAY_APP_ID,
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)
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(
out_trade_no=order_id,
total_amount=amount,
subject=order_id,
return_url=settings.ALIPAY_RETURN_URL,
notify_url=settings.ALIPAY_NOTIFY_URL)
return base_url + '?' + order_string
def get_trade_result(self, order_id):
result = self.alipay.api_alipay_trade_query(out_trade_no=order_id)
if result.get('trade_status') == 'TRADE_SUCCESS':
return True
return False
def get_verify_result(self, data, sign):
# 验证签名
return self.alipay.verify(data, sign)
def get(self, request):
order_id = request.GET.get('order_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': '订单错误'}))
check_client = AliPay(
appid=settings.ALIPAY_APPID,
app_notify_url=None,
app_private_key_path=settings.APP_PRIVATE_KEY_PATH,
alipay_public_key_path=settings.ALIPAY_PUBLIC_KEY_PATH,
sign_type="RSA2",
debug=True)
while True:
response = check_client.api_alipay_trade_query(order_id)
print(response)
code = response.get('code')
trade_status = response.get('trade_status')
if code == '10000' and trade_status == 'TRADE_SUCCESS':
order.status = OrderInfo.ORDER_STATUS_ENUM['UNCOMMENT']
order.trade_id = response.get('trade_no')
order.save()
return JsonResponse({'code': 0, 'message': '支付成功'})
elif code == '40004' or (code == '10000'
and trade_status == 'WAIT_BUYER_PAY'):
continue
else:
return JsonResponse({'code': 4, 'message': '支付失败'})
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':'订单失效'})
try:
order = OrderInfo.objects.get(order_id=order_id)
except OrderInfo.DoesNotExist:
return JsonResponse({'res':2,'errmsg':'订单失效'})
alipay = AliPay(
appid="2016092200569759",
app_notify_url=None, # 默认回调url
app_private_key_string=os.path.join(settings.BASE_DIR, 'apps/order/app_private_key.pem'),
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
alipay_public_key_string=os.path.join(settings.BASE_DIR, 'apps/order/alipay_public_key.pem'),
sign_type="RSA2", # RSA 或者 RSA2
debug=True # 默认False
)
while True:
response = alipay.api_alipay_trade_query(order_id)
# response = {
# "trade_no": "2017032121001004070200176844", # 支付宝交易号
# "code": "10000", # 接口调用是否成功
# "invoice_amount": "20.00",
# "open_id": "20880072506750308812798160715407",
# "fund_bill_list": [
# {
# "amount": "20.00",
# "fund_channel": "ALIPAYACCOUNT"
# }
# ],
# "buyer_logon_id": "csq***@sandbox.com",
# "send_pay_date": "2017-03-21 13:29:17",
# "receipt_amount": "20.00",
# "out_trade_no": "out_trade_no15",
# "buyer_pay_amount": "20.00",
# "buyer_user_id": "2088102169481075",
# "msg": "Success",
# "point_amount": "0.00",
# "trade_status": "TRADE_SUCCESS", # 支付结果
# "total_amount": "20.00"
# }
code = response['code']
if code == '10000' and response['trade_status'] == 'TRADE_SUCCESS':
order.order_status = 4
order.trade_no =response['trade_no']
order.save()
return JsonResponse({'res':3,'message':'支付成功'})
elif code == '40004' or (code == '10000' and response.get('trade_status') == 'WAIT_BUYER_PAY'):
import time
time.sleep(5)
continue
else:
print(code)
return JsonResponse({'res':4,'errmsg':'支付错误'})
def check_trade(out_trade_no=None):
"""
check trade by the order number
Keyword Arguments:
out_trade_no {int} -- order number (default: {None})
Returns:
bool -- decided by trade success or failure
"""
if not out_trade_no:
return False
else:
app_private_key_string = open(
f'{CUR_PATH}/rsa_alipay/app_private.txt').read()
alipay_public_key_string = open(
f'{CUR_PATH}/rsa_alipay/alipay_public.txt').read()
alipay = AliPay(
appid="2016102400752486",
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
)
try:
result = alipay.api_alipay_trade_query(out_trade_no=out_trade_no)
except:
pass
else:
if result.get("trade_status", "") == "TRADE_SUCCESS":
return True
else:
return False
def post(self, request):
"""查询支付结果"""
if not request.user.is_authenticated():
return JsonResponse({'code': 1, 'errmsg': '请先登录'})
# 获取请求参数
order_id = request.POST.get('order_id')
if not order_id:
return JsonResponse({'code': 2, 'errmsg': '参数不能为空'})
# 查询订单对象
try:
order = OrderInfo.objects.get(order_id=order_id,
status=1,
user=request.user)
except:
return JsonResponse({'code': 3, 'errmsg': '无效订单'})
# todo: 业务逻辑：调用第三方的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 = AliPay(
appid="2016091500513478", # 沙箱应用id（后期需要换成用户创建的应用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", # RSA 或者 RSA2
debug=True, # 默认False,True表示使用沙箱环境
)
# todo: 调用第三方的SDK，查询支付结果
while True:
dict_data = alipay.api_alipay_trade_query(out_trade_no=order_id)
code = dict_data.get('code')
trade_status = dict_data.get('trade_status')
trade_no = dict_data.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, 'errmsg': '支付成功'})
elif (code == '10000'
and trade_status == 'WAIT_BUYER_PAY') or code == '40004':
sleep(2)
continue
else:
# 支付失败
return JsonResponse({'code': 4, 'errmsg': '支付失败'})
class MyAliPay(View):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.alipay = AliPay(
appid=settings.ALIPAY_ID,
app_private_key_string=app_private_key_string,
alipay_public_key_string=alipay_public_key_string,
app_notify_url=None,
sign_type='RSA2',
debug=True, # 默认是Ｆalse True则是将请求转发沙箱环境
)
# 支付绑定地址 -- 订单ｉｄ，订单价格
def get_trade_url(self, order_id, amount):
order_string = self.alipay.api_alipay_trade_page_pay(
subject=order_id,
out_trade_no=order_id,
total_amount=amount,
# 支付完毕，将用户跳转至哪个页面
return_url='http://127.0.0.1:5000/',
notify_url='http://127.0.0.1:5000/',
)
return 'https://openapi.alipaydev.com/gateway.do?' + order_string
def get_verify_result(self, data, sign):
# 验证签名 True 成功 False 失败
return self.alipay.verify(data, sign)
def get_trade_result(self, order_id):
# 主动查询
result = self.alipay.api_alipay_trade_query(order_id)
if result.get('trade_status') == 'TRADE_SUCCESS':
return True
return False
def post(self, request):
user = request.user
if not user.is_authenticated():
return JsonResponse({'info': '未登陆'})
order_id_2 = request.POST.get('order_id')
if not order_id_2:
return JsonResponse({'info': '没有订单号'})
try:
order = Order.objects.get(id=order_id_2, user=user)
except Exception as e:
return JsonResponse({'info': '没有订单'})
alipay = AliPay(
appid='2016091400508044',
app_notify_url=None,
app_private_key_path=os.path.join(
settings.BASE_DIR, 'apps/orderform/app_private_key.pem'),
alipay_public_key_path=os.path.join(
settings.BASE_DIR, 'apps/orderform/app_public_key.pem'),
sign_type="RSA2",
debug=True,
)
while True:
response = alipay.api_alipay_trade_query(order_id_2)
code = response.get('code')
status = response.get('trade_status')
if code == '10000' and status == 'TRADE_SUCCESS':
order.status = 1
order.save()
return JsonResponse({'info': 'succeed!'})
elif code == '10000' and status == 'WAIT_BUYER_PAY':
continue
else:
return JsonResponse({'info': 'mistake!'})
def check_pay(request):
if request.method == 'GET':
o_id = request.GET.get('o_id')
alipay = AliPay(
appid=settings.ALIPAY_APPID,
app_notify_url=None,
app_private_key_path=os.path.join(settings.BASE_DIR, 'keys/pri'),
alipay_public_key_path=os.path.join(settings.BASE_DIR, 'keys/pub'),
sign_type='RSA2',
# 沙箱环境下没有查询订单服务的
debug=True)
while True:
response = alipay.api_alipay_trade_query(o_id)
# code 40004 支付订单未创建
# code 10000 trade_status WAIT_BUYER_PAY 等待支付
# oode 10000 trade_status TRADE_SUCCESS 支付成功
# response 是字典
code = response.get('code')
trade_status = response.get('trade_status')
if code == '10000' and trade_status == 'TRADE_SUCCESS':
# 支付成功
# 返回支付结果
return JsonResponse({'status': 1, 'msg': '支付成功'})
elif (code == '10000'
and trade_status == 'WAIT_BUYER_PAY') or code == '40004':
# 表示支付暂时没有完成
continue
else:
return JsonResponse({'status': 0, 'msg': '支付失败'})
def post(self, request):
user = request.user
if not user.is_authenticated:
# 用户未登陆
return JsonResponse({'res': 0, 'errmsg': '用户未登录'})
# 获取数据
# 订单id
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.DoesNotExist:
return JsonResponse({'res': 2, 'errmsg': '订单不存在'})
# 业务处理:使用python sdk调用支付宝的支付接口
# 初始化
alipay = AliPay(
appid="2016101800714203", # 应用id
app_notify_url=None, # 默认回调Url
app_private_key_string=os.path.join(
settings.BASE_DIR, 'apps/order/app_private_key.pem'),
alipay_public_key_string=os.path.join(
settings.BASE_DIR, 'apps/order/alipay_public_key.pem'),
sign_type="RSA2", # RSA 或者RSA2
debug=True, # 默认False是正式环境
)
while True:
#调用支付宝的交易查询接口
response = alipay.api_alipay_trade_query(trade_no=order_id)
code = response.get('code')
if code == '10000' and response.get(
'trade_status') == 'TRADE_SUCCESS':
#支付成功
#获取支付宝交易号
trade_no = response.get('trade_no')
#更新订单状态
order.trade_no = trade_no
order.order_status = 4 #待评价
order.save()
#返回结果
return JsonResponse({'res': 3, 'message': '支付成功'})
elif code == '40004' or (code == '10000'
and response.get('trade_status')
== 'WAIT_BUYER_PAY'):
#等待买家付款
import time
time.sleep(5)
continue
else:
#支付出错
return JsonResponse({'res': 4, 'errmsg': '支付失败'})
class My_Alipay(object):
"""阿里云支付的类"""
# 初始化 应用id 私钥文件的二进制数据 公钥文件的二进制数据
def __init__(self,
appid,
private_key_data=None,
public_key_data=None,
app_notify_url=None,
sign_type="RSA2",
debug=False):
if not private_key_data:
private_key_data = open(constants.APP_PRIVATE_KEY_FILE).read()
if not public_key_data:
public_key_data = open(constants.ALIPAY_PUBLIC_KEY_FILE).read()
self.alipay = AliPay(
appid=appid, # 应用id
app_notify_url=app_notify_url, # 默认回调url
# 绑定应用公钥对应的私钥信息
app_private_key_string=private_key_data,
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
alipay_public_key_string=public_key_data,
sign_type=sign_type, # RSA 或者 RSA2
debug=debug, # 默认False是访问真实的地址。True就是访问沙箱的地址
)
self.api_alipay_trade_page_pay_url = "https://openapi.alipay.com/gateway.do?"
self.api_alipaydev_trade_page_pay_url = "https://openapi.alipaydev.com/gateway.do?"
# 拉去支付宝的交易界面 交易订单流水号 交易金额（必须是字符串） 主体 是否获取沙箱的支付地址
def api_alipay_trade_page_pay(self,
out_trade_no,
total_amount,
subject,
dev=False,
return_url=None,
notify_url=None):
order_string = self.alipay.api_alipay_trade_page_pay(
out_trade_no=out_trade_no, # 订单id
total_amount=total_amount, # 支付总金额,因为我们的是Decimal类型无法被json序列化，所以变成字符串
subject=subject,
return_url=return_url,
notify_url=notify_url # 可选, 不填则使用默认notify url,支付宝服务器主动通知商户服务器里指定的页面
)
# 返回支付宝交易的url地址
if dev:
return self.api_alipaydev_trade_page_pay_url + order_string
return self.api_alipay_trade_page_pay_url + order_string
# 根据流水号，查询用户是否支付成功
def api_alipay_trade_query(self, out_trade_no):
response = self.alipay.api_alipay_trade_query(out_trade_no)
code = response.get('code')
if code == '10000' and response.get('trade_status') == 'TRADE_SUCCESS':
return True
else:
# 支付出错
return False
def post(self,request):
# 判断用户是否登录
if 'user' not in request.session:
return JsonResponse({'res': 0, 'errmsg': '请先登录'})
user = jsonpickle.loads(request.session.get('user'))
# 获取参数
order_id = request.POST.get('order_id')
# 校验数据
if not order_id:
return JsonResponse({'res': 1, 'errmsg': '无效的订单ID'})
# 查看订单是否存在
try:
order = OrderInfo.objects.get(user=user, pay_method=3, order_status=1, order_id=order_id)
except OrderInfo.DoesNotExist:
return JsonResponse({'res': 2, 'errmsg': '订单无效'})
# 使用python.SDK 连接支付宝接口
# 初始化
# 业务处理：条用python.sdk条用支付宝的支付接口
# 初始化
alipay = AliPay(
appid="2016093000634740", # APPID 支付宝沙箱
app_notify_url=None, # 默认回调url
# 应用私钥
app_private_key_path=os.path.join(os.path.dirname(os.path.abspath(__file__)), 'app_private_key.pem'),
# 支付宝公钥
alipay_public_key_path=os.path.join(os.path.dirname(os.path.abspath(__file__)),
'alipay_public_key.pem'),
sign_type='RSA2', # RSA 或者 RSA2
debug=True # 默认False
)
# 调用支付宝订单查询接口
while True:
response = alipay.api_alipay_trade_query(order_id)
code = response.get('code')
trade_status = response.get('trade_status')
if code == '10000' and trade_status == 'TRADE_SUCCESS':
# 支付成功
# 获取支付宝交易号
trade_on = response.get('trade_no')
# 更新订单状态
order.trade_on = trade_on
order.order_status = 4 # 待评价
order.save()
# 返回结果
return JsonResponse({'res': 3, 'message': '支付成功'})
elif code == '40004' or code == '10000' and trade_status == 'WAIT_BUYER_PAY':
# 业务处理失败，可能一会就能成功
# 等待买家付款
import time
time.sleep(3)
continue
else:
# 支付出错
return JsonResponse({'res': 4, 'errmsg': '支付失败'})
def get(self, request):
"""查询订单状态:保存支付宝返回的支付宝维护的订单id,修改订单的状态为待评价"""
# 接受订单id
order_id = request.GET.get('order_id')
# 校验order_id
if not order_id:
return JsonResponse({'code': 2, 'message': '缺少订单id'})
# 查询订单信息:订单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 配合沙箱模式使用
)
# 循环查询,知道成功或者失败
while True:
# 调用查询接口
# 参数:可以接受商家维护的订单id.可以接受支付宝维护的订单id
# 返回值:是个字典,内部包含了支付宝响应给调用者的参数信息,包括code,trade_status,trade_no
response = alipay.api_alipay_trade_query(order_id)
# 读取code,trade_status
code = response.get('code')
trade_status = response.get('trade_status')
# 判断订单状态
if code == '10000' and trade_status == 'TRADE_SUCCESS':
# 支付成功:保存trade_no,修改订单状态
order.trade_id = response.get('trade_no')
order.status = OrderInfo.ORDER_STATUS_ENUM['UNCOMMENT']
order.save()
return JsonResponse({'code': 0, 'message': '支付成功'})
elif code == '40004' or (code == '10000'
and trade_status == 'WAIT_BUYER_PAY'):
# 有待商量,需要继续查询
continue
else:
# 支付失败
return JsonResponse({'code': 4, 'message': '支付失败'})
def post(self, request):
user = request.user
if not user.is_authenticated():
return JsonResponse({'res': -1, 'error': '用户未登录'})
order_id = request.POST.get('order_id')
if not order_id:
return JsonResponse({'res': -2, 'error': '无效的订单id'})
try:
order = OrderInfo.objects.get(order_id=order_id,
user=user,
pay_method=3,
order_status=1)
except OrderInfo.DoesNotExist:
return JsonResponse({'res': -3, 'error': '订单错误'})
app_private_key_string = open(
os.path.join(settings.BASE_DIR,
'apps/order/app_private_key.pem')).read()
alipay_public_key_string = open(
os.path.join(settings.BASE_DIR,
'apps/order/alipay_public_key.pem')).read()
alipay = AliPay(
appid="2016100100636673",
# 默认回调url
app_notify_url=None,
app_private_key_string=app_private_key_string,
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
alipay_public_key_string=alipay_public_key_string,
# RSA 或者 RSA2
sign_type="RSA2",
# 正式环境使用False，沙箱环境使用True
debug=True,
)
while True:
# 调用支付宝的交易查询接口
response = alipay.api_alipay_trade_query(order_id)
code = response.get('code')
if code == '10000':
# 支付成功
if response.get('trade_status') == 'TRADE_SUCCESS':
trade_no = response.get('trade_no')
order.trade_no = trade_no
order.order_status = 4
order.save()
return JsonResponse({'res': 1, 'message': '支付成功'})
# 等待支付
elif response.get('trade_status') == 'WAIT_BUYER_PAY':
time.sleep(5)
# 支付失败
else:
return JsonResponse({'res': -1, 'error': '支付失败'})
# 业务处理失败，可能一会后就会成功
elif code == '40004':
time.sleep(5)
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 all([order_id]):
return JsonResponse({'res': 1, 'errmsg': '订单id为空'})
# 校验订单信息
try:
order = OrderInfo.objects.get(order_id=order_id,
user=user,
order_status=1,
pay_method=3)
except OrderInfo.DoesNotExist:
return JsonResponse({'res': 2, 'errmsg': '无效订单id'})
# 业务处理: 使用python SDK调用支付宝的下单支付接口
# 初始化
alipay = AliPay(
appid="2016091900545245", # 应用id
app_notify_url=None, # 默认回调url
app_private_key_path=APP_PRIVATE_KEY_PATH, # 网站私钥文件路径
alipay_public_key_path=ALIPAY_PUBLIC_KEY_PATH, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
sign_type="RSA2", # RSA 或者 RSA2
debug=True # 默认False, True代表沙箱环境
)
while True:
response = alipay.api_alipay_trade_query(order_id)
code = response.get('code')
if code == '10000' and response.get('trade_status') == 'TRADE_SUCCESS':
# 支付成功
# 获取支付宝交易号
trade_no = response.get('trade_no')
# 更新订单状态，设置支付宝交易号
order.order_status = 2 # 待发货
order.trade_no = trade_no
order.save()
# 返回应答
return JsonResponse({'res': 3, 'message': '支付成功'})
elif code == '40004' or (code == '10000' and response.get('trade_status') == 'WAIT_BUYER_PAY'):
# code == '40004': 支付交易订单还未创建，用户登录支付宝后就会创建
# 等待买家付款
import time
time.sleep(5)
continue
else:
# 支付失败
return JsonResponse({'res': 4, 'errmsg': '支付失败'})
def post(self, request):
'''处理浏览器支付结果查询请求'''
# 用户是否登录
user = request.user
if not user.is_authenticated:
return JsonResponse({'res': -1, 'errmsg': '用户未登录'})
# 接收参数
order_id = request.POST.get('order_id')
# 校验参数
if not order_id:
return JsonResponse({'res': -2, 'errmsg': '无效的订单ID'})
try:
order = OrderInfo.objects.get(order_id=order_id,
user=user,
pay_method=3,
order_status=1)
except OrderInfo.DoesNotExist:
return JsonResponse({'res': -3, 'errmsg': '订单错误'})
# total_pay = order.total_price + order.transit_price # 计算得到订单应付总金额
# 业务处理:使用Python SDK调用支付宝的交易查询接口
# 初始化
app_private_key_string = open(os.path.join(settings.BASE_DIR, 'apps/order/app_private_key.pem')).read()
alipay_public_key_string = open(os.path.join(settings.BASE_DIR, 'apps/order/alipay_public_key.pem')).read()
alipay = AliPay(
appid="2016102100732704", # 应用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", # RSA 或者 RSA2
debug=True # 默认False
)
while True:
# 调用支付宝交易查询接口, https://openapi.alipaydev.com/gateway.do? + order_string
response = alipay.api_alipay_trade_query(order_id)
code = response.get('code')
if code == '10000' and (response.get('trade_status') == 'TRADE_SUCCESS'):
# 支付成功
# 获取支付宝交易号
trade_no = response.get('trade_no')
# 更新订单状态
order.trade_no = trade_no
order.order_status = 3
order.save()
# 返回结果
return JsonResponse({'res': 1, 'message': '支付成功'})
elif code == '40004' or (code == '10000' and response.get('trade_status') == 'WAIT_BUYER_PAY'):
# 等待买家付款
import time
time.sleep(5)
continue
else:
# 支付出错
print(code)
print(response.get('trade_status'))
return JsonResponse({'res': -4, 'errmsg': '支付错误'})
def post(self, request):
"""查询支付结果"""
user = request.user
if not user.is_authenticated():
return redirect(reverse('user:login'))
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.DoesNotExist:
return JsonResponse({'res': 2, 'errmsg': "订单不存在！"})
app_private_key = open('./apps/order/app_private_key.pem').read()
alipay_public_key = open('./apps/order/alipay_public_key.pem').read()
alipay = AliPay(
appid='2016092900627469',
app_notify_url=None,
app_private_key_string=app_private_key,
alipay_public_key_string=alipay_public_key,
sign_type="RSA2",
debug=True
)
# 返回的是一个字典
while True:
query_response = alipay.api_alipay_trade_query(out_trade_no=order_id)
code = query_response.get('code')
if code == '10000' and query_response.get('trade_status') == 'TRADE_SUCCESS':
# 支付成功
# 获取支付宝交易号
# 更新订单的支付状态
trade_no = query_response.get('trade_no')
order.trade_no = trade_no
order.order_status = 4 # 待评价
order.save()
return JsonResponse({'res': 4, 'message': '支付成功！'})
elif code == '40004' or code == '10000' and query_response.get('trade_status') == "WAIT_BUYER_PAY":
# 等待买家付款
# 业务处理失败，可能一会就可以成功
import time
time.sleep(5)
continue
else:
# 支付出错
return JsonResponse({'res': 3, 'errmsg': '支付出错！'})
def post(self):
user = request.user
if not user.is_authenticated:
return jsonify({'res': 0, 'errmsg': '请先登录!'})
order_id = request.form.get('order_id')
if not order_id:
return jsonify({'res': 1, 'errmsg': '无效的订单id'})
# try:
# order = OrderInfo.objects.get(
# order_id=order_id, user=user, pay_method=3, order_status=1)
# except OrderInfo.DoesNotExist:
# return JsonResponse({'res': 2, 'errmsg': '订单错误！'})
order = OrderInfo.query.filter(
OrderInfo.id == order_id,
OrderInfo._user == user,
OrderInfo.pay_method == 3,
OrderInfo.order_status == 1,
)
if not order:
return jsonify({'res': 2, 'errmsg': '订单错误！'})
alipay = AliPay(
appid=config.ALIPAY_APP_ID,
app_notify_url=None, # 默认回调url
app_private_key_path=config.APP_PRIVATE_KEY_PATH,
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
alipay_public_key_path=config.ALIPAY_PUBLIC_KEY_PATH,
sign_type="RSA2", # RSA 或者 RSA2
debug=True # 默认False
)
# 调用支付宝的交易查询接口
while True:
response = alipay.api_alipay_trade_query(order_id)
code = response.get('code')
if code == '10000' and response.get(
'trade_status') == 'TRADE_SUCCESS':
# 支付成功
# 更新订单的状态
train_no = response.get('trade_no')
order.trade_no = train_no
# 将支付状态改为待评价
order.order_status = 4
db.session.add(order)
db.session.commit()
# order.save()
return jsonify({'res': 3, 'message': '支付成功!'})
elif (code == '10000' and response.get('trade_status') == 'WAIT_BUYER_PAY') or code == '40004':
# 等待支付
sleep(5)
continue
else:
# 支付失败
return jsonify({'res': 4, 'errmsg': '支付失败!'})
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': '参数不完整'})
try:
# 校验该订单是不是当前用户的
order = OrderInfo.objects.get(order_id=order_id,
user=user,
pay_method=3,
order_status=1)
except OrderInfo.DoesNotExist:
return JsonResponse({'res': 2, 'errmsg': '无效订单号'})
while True:
# 业务处理 使用python sdk调用支付宝接口
alipay = AliPay(
appid="2016092500595178", # 应用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 True访问沙箱
)
# 调用查询接口
response = alipay.api_alipay_trade_query(order_id)
code = response.code
print(code)
if code == '1000' and response.get(
'trade_stutas') == 'TRADE_SUCCESS':
# 修改订单信息
trade_no = response.get('trade_no')
order.trade_no = trade_no
order.trade_status = 4
order.save()
return JsonResponse({'res': 3, 'msg': '支付成功'})
elif code == '1000' and response.get(
'trade_stutas') == 'WAIT_BUYER_PAY':
time.sleep(5)
continue
else:
return JsonResponse({'res': 4, 'errmsg': '支付失败'})
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': '无效的订单'})
try:
order = OrderInfo.objects.get(order_id=order_id,
user=user,
pay_method=3,
order_status=1)
except OrderInfo.DoesNotExist:
return JsonResponse({'res': 2, 'errmsg': '订单错误'})
# 业务处理：使用python sdk调用支付宝的支付接口
# alipay初始化
app_private_key_string = open("apps/order/app_private_key.pem").read()
alipay_public_key_string = open("apps/order/alipay_public_key.pem").read()
alipay = AliPay(
appid="2016102200738204", # 应用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", # RSA 或者 RSA2
debug=True # 默认False, 此处沙箱模拟True
)
# 调用支付宝的交易查询接口
while True:
response = alipay.api_alipay_trade_query(order_id)
code = response.get('code')
if code == '10000' and response.get('trade_status')=="TRADE_SUCCESS":
# 支付成功
trade_no = response.get("trade_no")
# 获取支付宝交易号
order.trade_no = trade_no
# 更新交易状态
order.order_status = 4
order.save()
return JsonResponse({'res': 3, "messsage":'成功'})
elif code=='40004' or (code=="10000" and response.get('trade_status')=="WAIT_BUYER_PAY"):
# 等待买家付款
import time
time.sleep(5)
continue
else:
# 支付出错
return JsonResponse({"res": 4, 'errmsg':"支付失败"})
