def get_alipay_oauth_token_response(app_id, app_private_key, alipay_public_key, auth_code=''):
'''
初始化一个支付宝请求client
'''
alipay_client_config = AlipayClientConfig()
alipay_client_config.server_url = constants.SERVER_URL
alipay_client_config.app_id = app_id
alipay_client_config.app_private_key = app_private_key
alipay_client_config.alipay_public_key = alipay_public_key
alipay_client_config.format = 'json'
alipay_client_config.charset = 'utf-8'
alipay_client_config.sign_type = 'RSA2'
client = DefaultAlipayClient(alipay_client_config=alipay_client_config)
model = AlipaySystemOauthTokenModel()
request = AlipaySystemOauthTokenRequest(biz_model=model)
request.code = auth_code
request.grant_type = 'authorization_code'
response_content = None
try:
response_content = client.execute(request)
except AopException:
print(traceback.format_exc())
if not response_content:
raise ValidationError({'app_id|app_private_key|alipay_public_key': ['all should be correct']})
res = AlipaySystemOauthTokenResponse()
res.parse_response_content(response_content)
return res
def zfb_callback_login(request):
app_auto_code = request.GET.get("app_auto_code")
model = AlipayOpenAuthTokenAppModel()
model.grant_type = "authorization_code"
model.code = app_auto_code
client = DefaultAlipayClient(
alipay_client_config=zfb_conf.alipay_client_config)
request = AlipayOpenAuthTokenAppRequest(biz_model=model)
response_content = client.execute(request)
response = AlipayOpenAuthTokenAppResponse()
response.parse_response_content(response_content)
app_auto_token = response.app_auth_token
expires = response.expires_in
app_refresh_token = response.app_refresh_token
re_expires = response.re_expires_in
alipay_user_id = response.user_id
return HttpResponse(response.body)
def post(self):
bid = self.get_argument('bid')
out_trade_no = self.get_argument('out_trade_no')
payConfig = self.DefaultValues[bid]
# 设置配置信息
alipay_client_config = AlipayClientConfig()
alipay_client_config.server_url = payConfig['zfbpay']['url']
alipay_client_config.app_id = payConfig['zfbpay']['appId']
alipay_client_config.app_private_key = payConfig['zfbpay']['app_private_key']
alipay_client_config.alipay_public_key = payConfig['zfbpay']['alipay_public_key']
# 客户端对象
client = DefaultAlipayClient(alipay_client_config=alipay_client_config, logger=logger)
# 构造请求对象
model = AlipayTradeQueryModel()
model.out_trade_no = out_trade_no
request = AlipayTradeQueryRequest(biz_model=model)
response_content = None
try:
response_content = client.execute(request)
except Exception as e:
print('1-' + traceback.format_exc())
if not response_content:
print( "2-failed execute")
else:
response = AlipayTradeQueryResponse()
# 解析响应结果
response.parse_response_content(response_content)
print(response.body)
if response.is_success():
# 业务成功，则通过respnse属性获取需要的值
print("业务成功- get response trade_no:" + response.trade_no)
info = {
'errCode': '0',
'errMsg': '',
'detail': {
'trade_no': response.trade_no
}
}
result = {
'result': info
}
self.write(json.dumps(result, ensure_ascii=False))
else:
# 业务失败
print('业务失败-' + response.code + "," + response.msg + "," + response.sub_code + "," + response.sub_msg)
info = {
'errCode': response.code,
'errMsg': response.sub_msg
}
result = {
'result': info
}
self.write(json.dumps(result, ensure_ascii=False))
def get_access_token_and_userid(self, alipay_client_config, auth_code):
"""
设置配置，包括支付宝网关地址、app_id、应用私钥、支付宝公钥等，其他配置值可以查看AlipayClientConfig的定义。
"""
client = DefaultAlipayClient(alipay_client_config=alipay_client_config)
"""
系统接口：alipay.system.oauth.token
"""
# 对照接口文档，构造请求对象
from alipay.aop.api.request.AlipaySystemOauthTokenRequest import AlipaySystemOauthTokenRequest
model = AlipaySystemOauthTokenRequest()
model.grant_type = "authorization_code"
model.code = auth_code
result = client.execute(model)
logging.info(">>>支付宝返回结果:{}".format(result))
def pay(userinfo):
"""
设置配置，包括支付宝网关地址、app_id、应用私钥、支付宝公钥等，其他配置值可以查看AlipayClientConfig的定义。
"""
alipay_client_config = AlipayClientConfig()
alipay_client_config.server_url = 'https://openapi.alipay.com/gateway.do'
alipay_client_config.app_id = '' # appid
alipay_client_config.app_private_key = '' # 用户私钥
alipay_client_config.alipay_public_key = '' # 支付宝公钥（填入用户私钥，返回的支付宝公钥，而不是上面用户私钥对应的公钥，如果不会配置的话可以看我另一项目中的文档 https://github.com/yumusb/alipay-f2fpay/tree/master/%E5%AF%86%E9%92%A5%E5%AF%B9%E7%94%9F%E6%88%90%E4%B8%8E%E8%AE%BE%E7%BD%AE%E6%95%99%E7%A8%8B）
"""
得到客户端对象。
注意，一个alipay_client_config对象对应一个DefaultAlipayClient，定义DefaultAlipayClient对象后，alipay_client_config不得修改，如果想使用不同的配置，请定义不同的DefaultAlipayClient。
logger参数用于打印日志，不传则不打印，建议传递。
"""
#client = DefaultAlipayClient(alipay_client_config=alipay_client_config, logger=logger)
client = DefaultAlipayClient(alipay_client_config=alipay_client_config)
"""
系统接口示例：alipay.trade.pay
"""
# 对照接口文档，构造请求对象
model = AlipayTradePayModel()
model.auth_code = userinfo
model.subject = "Test" # 订单标题
model.out_trade_no = time() # 订单账号
model.scene = "bar_code"
model.total_amount = 0.01 # 订单金额
request = AlipayTradePayRequest(biz_model=model)
response_content = None
try:
response_content = client.execute(request)
except Exception as e:
print(traceback.format_exc())
if not response_content:
print("failed execute")
else:
response = AlipayTradePayResponse()
# 解析响应结果
response.parse_response_content(response_content)
#print(response.body)
#返回结果集，如果不能成功支付的话，建议输出以排错
if response.is_success():
# 如果业务成功，则通过respnse属性获取需要的值
print("get response trade_no:" + response.trade_no)
else:
# 如果业务失败，则从错误码中可以得知错误情况，具体错误码信息可以查看接口文档
print(response.code + "," + response.msg + "," +
response.sub_code + "," + response.sub_msg)
class Alipay():
def __init__(self):
self.appid = settings.ALIPAY_APPID
self.server_url = settings.ALIPAY_SERVER_URL
self.alipay_public_key = settings.ALIPAY_PUBLIC_KEY
self.app_private_key = settings.APP_PRIVATE_KEY
client_config = AlipayClientConfig()
client_config.server_url = self.server_url
client_config.app_id = self.appid
client_config.alipay_public_key = self.alipay_public_key
client_config.app_private_key = self.app_private_key
self.client = DefaultAlipayClient(client_config)
def payorders(self, order_id, total_amount):
model = AlipayTradePagePayModel()
model.product_code = 'FAST_INSTANT_TRADE_PAY'
model.total_amount = str(total_amount)
model.subject = '天天生鲜订单支付-天天艹楼雅倩'
model.out_trade_no = order_id
request = AlipayTradePagePayRequest(biz_model=model)
response_content = self.client.page_execute(request, http_method='GET')
if not response_content:
return "caolouyaqianshibai"
# response = AlipayTradePagePayResponse()
# response.parse_response_content(response_content)
# # 响应成功的业务处理
# if response.is_success():
# # 如果业务成功，可以通过response属性获取需要的值
# print("get response trade_no:" + response.trade_no)
# # 响应失败的业务处理
# else:
# # 如果业务失败，可以从错误码中可以得知错误情况，具体错误码信息可以查看接口文档
# print(response.code + "," + response.msg + "," + response.sub_code + "," + response.sub_msg)
return response_content
def order_status_query(self, order_id):
model = AlipayTradeQueryModel()
model.out_trade_no = order_id
request = AlipayTradeQueryRequest(biz_model=model)
response_content = self.client.execute(request)
response = AlipayTradeQueryResponse()
response.parse_response_content(response_content)
return response
def trans_to_account(out_biz_no, amount, alipay, name): # TODO 待测试
alipay_client_config = AlipayClientConfig()
alipay_client_config.server_url = 'https://openapi.alipay.com/gateway.do'
alipay_client_config.app_id = alipay_app_id
alipay_client_config.app_private_key = alipay_app_private
alipay_client_config.alipay_public_key = alipay_public_key
client = DefaultAlipayClient(alipay_client_config=alipay_client_config)
alipay_model = AlipayFundTransToaccountTransferModel()
alipay_model.out_biz_no = out_biz_no
alipay_model.payee_type = "ALIPAY_LOGONID"
alipay_model.amount = str(amount)
alipay_model.payee_account = alipay
alipay_model.payee_real_name = name
alipay_model.remark = "猪猪惠返提现" # TODO 修改app名字
request = AlipayFundTransToaccountTransferRequest(biz_model=alipay_model)
response_content = client.execute(request)
print(response_content)
return json.loads(response_content)
def get_pay_status(cls, order_id):
# 获取内容
with open(ALIPAY_KEY_PATH) as f:
alipay_public_key = f.read()
with open(APP_KEY_PRIVATE_PATH) as f:
app_private_key = f.read()
# 设置配置，包括支付宝网关地址、app_id、应用私钥、支付宝公钥;
config = AlipayClientConfig()
config.server_url = settings.SERVER_URL
config.app_id = settings.APP_ID
config.app_private_key = app_private_key
config.alipay_public_key = alipay_public_key
# 得到
client = DefaultAlipayClient(alipay_client_config=config)
model = AlipayTradeQueryModel()
model.out_trade_no = order_id
request = AlipayTradeQueryRequest(biz_model=model)
# 得到构造的请求,获取返回内容
import time
i = 1
while True:
time.sleep(10)
response_content = None
try:
response_content = client.execute(request)
except Exception as ex:
print(ex)
if not response_content:
return None
else:
# 解析相应结果
response = AlipayTradeQueryResponse()
response.parse_response_content(response_content)
if response.is_success(
) and response.trade_status == 'TRADE_SUCCESS':
return response.trade_no
i += 1
if i == 30:
# 五分钟后还是失败
# 判定支付失败
return None
def test_alipay():
# 实例化客户端
alipay_client_config = AlipayClientConfig()
alipay_client_config.server_url = 'https://openapi.alipaydev.com/gateway.do'
alipay_client_config.app_id = '请填写appi_id'
alipay_client_config.app_private_key = '请填写开发者私钥去头去尾去回车，单行字符串'
alipay_client_config.alipay_public_key = '请填写支付宝公钥，单行字符串'
client = DefaultAlipayClient(alipay_client_config, logger)
# 构造请求参数对象
model = AlipayTradeCreateModel()
model.out_trade_no = "20150320010101001";
model.total_amount = "88.88";
model.subject = "Iphone6 16G";
model.buyer_id = "2088102177846880";
request = AlipayTradeCreateRequest(biz_model=model)
# 执行API调用
try:
response_content = client.execute(request)
except Exception as e:
print(traceback.format_exc())
if not response_content:
print("failed execute")
else:
# 解析响应结果
response = AlipayTradeCreateResponse()
response.parse_response_content(response_content)
# 响应成功的业务处理
if response.is_success():
# 如果业务成功，可以通过response属性获取需要的值
print("get response trade_no:" + response.trade_no)
# 响应失败的业务处理
else:
# 如果业务失败，可以从错误码中可以得知错误情况，具体错误码信息可以查看接口文档
print(response.code + "," + response.msg + "," + response.sub_code + "," + response.sub_msg)
alipay_client_config.app_id = '请填写appi_id'
alipay_client_config.app_private_key = '请填写开发者私钥去头去尾去回车，单行字符串'
alipay_client_config.alipay_public_key = '请填写支付宝公钥，单行字符串'
client = DefaultAlipayClient(alipay_client_config, logger)
# 构造请求参数对象
model = AlipayTradeCreateModel()
model.out_trade_no = "20150320010101001"
model.total_amount = "88.88"
model.subject = "Iphone6 16G"
model.buyer_id = "2088102177846880"
request = AlipayTradeCreateRequest(biz_model=model)
# 执行API调用
try:
response_content = client.execute(request)
except Exception as e:
print(traceback.format_exc())
if not response_content:
print("failed execute")
else:
# 解析响应结果
response = AlipayTradeCreateResponse()
response.parse_response_content(response_content)
# 响应成功的业务处理
if response.is_success():
# 如果业务成功，可以通过response属性获取需要的值
print("get response trade_no:" + response.trade_no)
# 响应失败的业务处理
else:
class AliFacePay:
logger = logging.getLogger('')
def __init__(self,
app_id,
app_private_key,
alipay_public_key,
notify_url=None,
sandbox_debug=False):
'''
设置配置，包括支付宝网关地址、app_id、应用私钥、支付宝公钥等，其他配置值可以查看AlipayClientConfig的定义。
'''
alipay_client_config = AlipayClientConfig(sandbox_debug=sandbox_debug)
alipay_client_config.app_id = app_id
alipay_client_config.app_private_key = app_private_key
alipay_client_config.alipay_public_key = alipay_public_key
'''
得到客户端对象。
注意，一个alipay_client_config对象对应一个DefaultAlipayClient，定义DefaultAlipayClient对象后，alipay_client_config不得修改，如果想使用不同的配置，请定义不同的DefaultAlipayClient。
logger参数用于打印日志，不传则不打印，建议传递。
'''
self.client = DefaultAlipayClient(
alipay_client_config=alipay_client_config,
logger=AliFacePay.logger)
self.notify_url = notify_url
self.alipay_public_key = alipay_public_key
'''
功能：生成支付二维码，生成二维码后，展示给用户，由用户扫描二维码创建支付订单
参数：
out_trade_no：订单号，不可重复，用来区分每一笔订单
total_amount：订单金额，单位元，精确到小数点后2位
subject：订单标题
body：订单详细描述
返回值：string 付款二维码链接，使用二维码生成工具生成二维码提供给用户付款
'''
def precreate(self, out_trade_no, total_amount, subject, body=None):
'''
系统接口示例：alipay.trade.precreate
'''
# 对照接口文档，构造请求对象
precreate_model = AlipayTradePrecreateModel()
precreate_model.out_trade_no = out_trade_no
precreate_model.total_amount = total_amount
precreate_model.subject = subject
# 该笔订单允许的最晚付款时间，逾期将自动关闭交易(TRADE_CLOSED),时间从用户扫描付款二维码以后开始计算
# 扫码后的最晚付款时间限制 默认交易超时时间为15天
precreate_model.timeout_express = '5m'
# 二维码有效期，从创建二维码开始直到用户扫码，默认2h，要求最小2m
# （沙箱目前qr_code_timeout_express这个参数是不生效的，实际环境才有效果）
# 到期二维码失效，不会影响订单状态，因为此时订单还没有创建
# 二维码创建后的最晚扫码时间限制
precreate_model.qr_code_timeout_express = '5m'
# 花呗，默认支持吗？
#precreate_model.enable_pay_channels = 'pcredit'
# 花呗分期
#precreate_model.enable_pay_channels = 'pcreditpayInstallment'
if body:
precreate_model.body = body
precreate_request = AlipayTradePrecreateRequest(
biz_model=precreate_model)
precreate_request.notify_url = self.notify_url
precreate_response_content = None
qr_code = None
try:
precreate_response_content = self.client.execute(precreate_request)
except Exception as e:
print(traceback.format_exc())
if not precreate_response_content:
print("failed execute precreate")
else:
precreate_response = AlipayTradePrecreateResponse()
# 解析响应结果
precreate_response.parse_response_content(
precreate_response_content)
if precreate_response.is_success():
# 如果业务成功，则通过respnse属性获取需要的值
qr_code = precreate_response.qr_code
# print("get response out_trade_no:" + precreate_response.out_trade_no)
# print("get response qr_code:" + precreate_response.qr_code)
else:
# 如果业务失败，则从错误码中可以得知错误情况，具体错误码信息可以查看接口文档
print(precreate_response.code + "," + precreate_response.msg +
"," + precreate_response.sub_code + "," +
precreate_response.sub_msg)
return qr_code
'''
功能：主动查询订单状态(只有用户扫描了二维码以后才会创建订单，用户扫描之前得到的结果会是 40004 交易不存在)
参数：
out_trade_no：订单号，不可重复，用来区分每一笔订单
返回值：dict
out_trade_no：订单号
buyer_logon_id：买家支付宝账号
trade_status：交易状态：WAIT_BUYER_PAY（交易创建，等待买家付款）、TRADE_CLOSED（未付款交易超时关闭，或支付完成后全额退款）、TRADE_SUCCESS（交易支付成功）、TRADE_FINISHED（交易结束，不可退款）
交易状态 TRADE_FINISHED 的通知触发条件是商户签约的产品不支持退款功能的前提下，买家付款成功；或者，商户签约的产品支持退款功能的前提下，交易已经成功并且已经超过可退款期限
total_amount：交易金额
'''
def query(self, out_trade_no):
'''
系统接口示例：alipay.trade.query
'''
# 对照接口文档，构造请求对象
query_model = AlipayTradeQueryModel()
query_model.out_trade_no = out_trade_no
query_request = AlipayTradeQueryRequest(biz_model=query_model)
query_response_content = None
ret_dict = {}
try:
query_response_content = self.client.execute(query_request)
except Exception as e:
print(traceback.format_exc())
if not query_response_content:
print("failed execute query")
else:
query_response = AlipayTradeQueryResponse()
# 解析响应结果
query_response.parse_response_content(query_response_content)
if query_response.is_success():
# 如果业务成功，则通过respnse属性获取需要的值
ret_dict['out_trade_no'] = query_response.out_trade_no
ret_dict['buyer_logon_id'] = query_response.buyer_logon_id
ret_dict['trade_status'] = query_response.trade_status
ret_dict['total_amount'] = query_response.total_amount
else:
# 如果业务失败，则从错误码中可以得知错误情况，具体错误码信息可以查看接口文档
print(query_response.code + "," + query_response.msg + "," +
query_response.sub_code + "," + query_response.sub_msg)
return ret_dict
'''
功能：支付交易返回失败或支付系统超时，调用该接口撤销交易。
cancel和close的区别是，交易完成后不可以close，但是可以cancel，cancel会退款给用户
生成二维码之后，扫描之前也可以cancel，但是不可以close
参数：
out_trade_no：订单号，不可重复，用来区分每一笔订单
返回值：bool 是否执行成功
'''
def cancel(self, out_trade_no):
'''
系统接口示例：alipay.trade.cancel
'''
# 对照接口文档，构造请求对象
cancel_model = AlipayTradeCancelModel()
cancel_model.out_trade_no = out_trade_no
cancel_request = AlipayTradeCancelRequest(biz_model=cancel_model)
cancel_response_content = None
ret = False
try:
cancel_response_content = self.client.execute(cancel_request)
except Exception as e:
print(traceback.format_exc())
if not cancel_response_content:
print("failed execute cancel")
else:
cancel_response = AlipayTradeCancelResponse()
# 解析响应结果
cancel_response.parse_response_content(cancel_response_content)
if cancel_response.is_success():
# 如果业务成功，则通过respnse属性获取需要的值
ret = True
else:
# 如果业务失败，则从错误码中可以得知错误情况，具体错误码信息可以查看接口文档
print(cancel_response.code + "," + cancel_response.msg + "," +
cancel_response.sub_code + "," + cancel_response.sub_msg)
return ret
'''
功能：用于交易创建后，用户在一定时间内未进行支付，可调用该接口直接将未付款的交易进行关闭。
也就是用户扫码创建了订单，用户支付之前我们可以close订单
也就是说当且仅当订单状态为WAIT_BUYER_PAY时可以close
参数：
out_trade_no：订单号，不可重复，用来区分每一笔订单
返回值：bool 是否执行成功
'''
def close(self, out_trade_no):
'''
系统接口示例：alipay.trade.cancel
'''
# 对照接口文档，构造请求对象
close_model = AlipayTradeCloseModel()
close_model.out_trade_no = out_trade_no
close_request = AlipayTradeCloseRequest(biz_model=close_model)
close_response_content = None
ret = False
try:
close_response_content = self.client.execute(close_request)
except Exception as e:
print(traceback.format_exc())
if not close_response_content:
print("failed execute close")
else:
close_response = AlipayTradeCloseResponse()
# 解析响应结果
close_response.parse_response_content(close_response_content)
if close_response.is_success():
# 如果业务成功，则通过respnse属性获取需要的值
ret = True
else:
# 如果业务失败，则从错误码中可以得知错误情况，具体错误码信息可以查看接口文档
print(close_response.code + "," + close_response.msg + "," +
close_response.sub_code + "," + close_response.sub_msg)
return ret
'''
功能：退款
参数：
out_trade_no：订单号，不可重复，用来区分每一笔订单
返回值：bool 是否执行成功
'''
def refund(self, out_trade_no, refund_amount):
'''
系统接口示例：alipay.trade.refund
'''
# 对照接口文档，构造请求对象
refund_model = AlipayTradeRefundModel()
refund_model.out_trade_no = out_trade_no
refund_model.refund_amount = refund_amount
refund_request = AlipayTradeRefundRequest(biz_model=refund_model)
refund_response_content = None
ret = False
try:
refund_response_content = self.client.execute(refund_request)
except Exception as e:
print(traceback.format_exc())
if not refund_response_content:
print("failed execute refund")
else:
refund_response = AlipayTradeRefundResponse()
# 解析响应结果
refund_response.parse_response_content(refund_response_content)
if refund_response.is_success():
# 如果业务成功，则通过respnse属性获取需要的值
ret = True
# print("get response out_trade_no:" + refund_response.out_trade_no)
# print("get response refund_fee:" + refund_response.refund_fee)
else:
# 如果业务失败，则从错误码中可以得知错误情况，具体错误码信息可以查看接口文档
print(refund_response.code + "," + refund_response.msg + "," +
refund_response.sub_code + "," + refund_response.sub_msg)
return ret
'''
功能：验证异步回调签名
参数：
params：回调通知参数字典，例如flask通知中使用request.form.to_dict()来构造参数（params = request.form.to_dict()）
返回值：bool 是否验证成功
'''
def verify_params_sign(self, params):
# 文档 https://docs.open.alipay.com/194/103296#s5
sign = params.pop('sign', None) # 取出sign参数
params.pop('sign_type') # 取出sign_type参数
params = sorted(params.items(), key=lambda e: e[0],
reverse=False) # 取出字典元素按key的字母升序排序形成列表
message = "&".join(u"{}={}".format(k, v)
for k, v in params).encode() # 将列表转为二进制参数字符串
try:
status = verify_with_rsa(
self.alipay_public_key.encode('utf-8').decode('utf-8'),
message, sign) # 验证签名并获取结果
return status # 返回验证结果
except Exception as e: # 如果验证失败，返回假值。
return False
@classmethod
def get_rand_string(cls, length=10):
# 生成len长度的随机字符串
s = ""
for _ in range(length):
s = s + str(randint(0, 9))
return s
@classmethod
def gen_trade_no(cls, pre_string=None):
timestamp = time.strftime("%Y%m%d%H%M%S", time.localtime(time.time()))
trade_no = timestamp + cls.get_rand_string()
if pre_string:
trade_no = pre_string + '_' + trade_no
return trade_no
def token(request):
ref = request.GET.get("ref") if request.GET.get("ref") is not None else "/"
if ref == request.path:
ref = "/"
# 没有auth_code未登录，算错误的请求
if request.GET.get("auth_code") is None and not request.user.is_authenticated:
return render(request, "weui/siginin/fail.html", {"msg": "错误的请求", "ref": ref})
# 没有auth_code已登录，跳转ref
if request.GET.get("auth_code") is None and request.user.is_authenticated:
return render(request, "weui/siginin/success.html", {"ref": ref})
# 有auth_code未登录，走登录流程
if request.GET.get("auth_code") is not None:
auth_code = request.GET["auth_code"]
ssl._create_default_https_context = ssl._create_unverified_context
# 通过auth_code获取access_token及用户信息
alipay_config = config.Alipay(is_sandbox=True if settings.CONNECT_ALIPAY == "sandbox" else False)
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s %(levelname)s %(message)s',
filemode='a', )
logger = logging.getLogger('')
alipay_client_config = AlipayClientConfig(sandbox_debug=False)
alipay_client_config.server_url = 'https://openapi.alipay.com/gateway.do'
alipay_client_config.app_id = alipay_config.APP_ID
alipay_client_config.app_private_key = alipay_config.PRIVATE_KEY
alipay_client_config.alipay_public_key = alipay_config.ALIPAY_PUBLIC_KEY
alipayClient = DefaultAlipayClient(alipay_client_config=alipay_client_config, logger=logger)
# 获取token
tokenRequest = AlipaySystemOauthTokenRequest()
tokenRequest.code = auth_code
tokenRequest.grant_type = "authorization_code"
response_content = ""
access_token = {}
try:
response_content = alipayClient.execute(tokenRequest)
except Exception as ex:
print(ex)
if not response_content:
return render(request, "weui/siginin/fail.html", {"msg": "错误的请求", "ref": ref})
oauthTokenResponse = AlipaySystemOauthTokenResponse()
oauthTokenResponse.parse_response_content(response_content)
if not oauthTokenResponse.is_success():
return render(request, "weui/siginin/fail.html", {"msg": oauthTokenResponse.sub_msg, "ref": ref})
# 判断用户是否存在
platform_user_id = oauthTokenResponse.user_id
connectObj = Connect.objects.filter(oauth_platform_user_id=platform_user_id).first()
if connectObj is not None:
# 可以登录
user = User.objects.get(id=connectObj.user_id)
login(request, user)
return render(request, "weui/siginin/success.html", {"ref": ref})
# 构建模型，取得用户信息后即可注册
connectObj = Connect()
connectObj.oauth_expire = time.time() + oauthTokenResponse.expires_in
connectObj.oauth_key = alipay_client_config.app_id
connectObj.oauth_platform = "alipay"
connectObj.oauth_platform_user_id = platform_user_id
connectObj.oauth_token = oauthTokenResponse.access_token
connectObj.oauth_token_fresh = oauthTokenResponse.refresh_token
connectObj.oauth_token_fresh_expire = time.time() + oauthTokenResponse.re_expires_in
connectObj.created = time.time()
print(oauthTokenResponse.access_token)
# 获取用户信息
user_info_request = AlipayUserInfoShareRequest()
user_info_request.udf_params = {"auth_token": oauthTokenResponse.access_token}
response_content = alipayClient.execute(user_info_request)
infoResponse = AlipayUserInfoShareResponse()
infoResponse.parse_response_content(response_content)
print(infoResponse)
print(infoResponse.user_id, infoResponse.nick_name)
# 保存新用户信息
user = User.objects.create_user(username=infoResponse.nick_name)
user.save()
user_profile = UserProfile()
user_profile.user_id = user.id
user_profile.nickname = infoResponse.nick_name
user_profile.avatar = infoResponse.avatar
user_profile.save()
connectObj.user_id = user.id
connectObj.oauth_data = response_content
connectObj.save()
return HttpResponse(connectObj.user_id)
def post(self):
common = Common()
print(common.re_phone('13631255697'))
bid = self.get_argument('bid')
payConfig = self.DefaultValues[bid]
out_trade_no = self.get_argument('out_trade_no')
refund_amount = self.get_argument('refund_amount')
# if self.get_argument('out_request_no'):
# _request_no = self.get_argument('out_request_no')
#self.write(str(self.get_argument('out_request_no')))
out_request_no = common.random_str(16)
# 设置配置信息
alipay_client_config = AlipayClientConfig()
alipay_client_config.server_url = payConfig['zfbpay']['url']
alipay_client_config.app_id = payConfig['zfbpay']['appId']
alipay_client_config.app_private_key = payConfig['zfbpay']['app_private_key']
alipay_client_config.alipay_public_key = payConfig['zfbpay']['alipay_public_key']
# 客户端对象
client = DefaultAlipayClient(alipay_client_config=alipay_client_config, logger=logger)
# 直接使用引入库的表
online_alipay_order_list = base_mode('online_alipay_order_list')
# 获取该笔订单金额
order_info = self.db.query(online_alipay_order_list).filter(online_alipay_order_list.bid == bid,
online_alipay_order_list.out_trade_no == out_trade_no).scalar()
# 退款金额大于该笔订单金额 退款失败
if int(refund_amount) > int(order_info.total_amount):
info = {
'errCode': -1,
'errMsg': '退款失败，退款金额大于该订单金额'
}
result = {
'result': info
}
return self.write(json.dumps(result, ensure_ascii=False))
# 构造请求对象
model = AlipayTradeRefundModel()
model.out_trade_no = out_trade_no
model.refund_amount = refund_amount
model.out_request_no = out_request_no
request = AlipayTradeRefundRequest(biz_model=model)
response_content = None
try:
response_content = client.execute(request)
except Exception as e:
print('1-' + traceback.format_exc())
if not response_content:
print("2-failed execute")
else:
response = AlipayTradeRefundResponse()
# 解析响应结果
response.parse_response_content(response_content)
if response.is_success():
'''
退款成功更新订单信息
'''
if not order_info.refundList:
refund_list = []
else:
refund_list = eval(order_info.refundList)
refundInfo = {}
refundInfo['refund_no'] = out_request_no
refundInfo['refund_fee'] = int(refund_amount)
refundInfo['refund_status'] = 1 #退款成功
refundInfo['refund_date'] = common.current_stamp()
refund_list.append(refundInfo)
self.db.query(online_alipay_order_list).filter(
online_alipay_order_list.bid == bid,
online_alipay_order_list.out_trade_no == out_trade_no).update(
{
'totalFeeLeft': int(order_info.totalFeeLeft) - int(refund_amount),
'refundList': str(refund_list)
})
self.db.commit()
# 业务成功返回
info = {
'errCode': '0',
'errMsg': '',
'detail': {
'refund_fee': response.refund_fee
}
}
result = {
'result': info
}
return self.write(json.dumps(result, ensure_ascii=False))
else:
'''
退款失败更新订单信息
'''
if not order_info.refundList:
refund_list = []
else:
refund_list = eval(order_info.refundList)
refundInfo = {}
refundInfo['refund_no'] = out_request_no
refundInfo['refund_fee'] = int(refund_amount)
refundInfo['refund_status'] = 2 #退款失败
refundInfo['refund_date'] = common.current_stamp()
refundInfo['refund_errmsg'] = response.sub_msg
refund_list.append(refundInfo)
self.db.query(online_alipay_order_list).filter(
online_alipay_order_list.bid == bid,
online_alipay_order_list.out_trade_no == out_trade_no).update(
{
'refundList': str(refund_list)
})
self.db.commit()
# 业务失败
info = {
'errCode': response.code,
'errMsg': response.sub_msg
}
result = {
'result': info
}
return self.write(json.dumps(result, ensure_ascii=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': '订单错误'})
# todo: 业务处理 使用python的SDK 调用支付宝的支付接口
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s %(levelname)s %(message)s',
filemode='a',
)
logger = logging.getLogger('')
"""
设置配置，包括支付宝网关地址、app_id、应用私钥、支付宝公钥等，其他配置值可以查看AlipayClientConfig的定义。
"""
alipay_client_config = AlipayClientConfig(sandbox_debug=True)
alipay_client_config.server_url = 'https://openapi.alipaydev.com/gateway.do'
alipay_client_config.app_id = '2016101900724693' # 应用id 这里是沙箱id
alipay_client_config.charset = 'utf-8'
with open(
os.path.join(settings.BASE_DIR,
'apps/order/app_private_key.txt')) as f:
alipay_client_config.app_private_key = f.read()
with open(
os.path.join(settings.BASE_DIR,
'apps/order/alipay_public_key.txt')) as f:
alipay_client_config.alipay_public_key = f.read()
alipay_client_config.sign_type = 'RSA2' # RSA或RSA2
"""
得到客户端对象。
注意，一个alipay_client_config对象对应一个DefaultAlipayClient，定义DefaultAlipayClient对象后，
alipay_client_config不得修改，如果想使用不同的配置，请定义不同的DefaultAlipayClient。
logger参数用于打印日志，不传则不打印，建议传递。
"""
client = DefaultAlipayClient(alipay_client_config=alipay_client_config,
logger=logger)
while True:
# 对照接口文档，构造请求对象
model = AlipayTradeQueryModel()
model.out_trade_no = order_id
query_request = AlipayTradeQueryRequest(biz_model=model)
response = self.str_to_dict(client.execute(query_request))
"""
response:
{
"code":"10000", # 接口调用是否成功
"msg":"Success",
"buyer_logon_id":"mnd***@sandbox.com",
"buyer_pay_amount":"0.00",
"buyer_user_id":"2088102180300991",
"buyer_user_type":"PRIVATE",
"invoice_amount":"0.00",
"out_trade_no":"2020010122413118",
"point_amount":"0.00",
"receipt_amount":"0.00",
"total_amount":"39.90",
"trade_no":"2020010422001400991000047401", # 支付宝交易号
"trade_status":"WAIT_BUYER_PAY" # 支付结果
}
"""
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':
# 等待买家付款
# 业务处理失败 可能一会会成功
time.sleep(5)
continue
else:
# 支付出错
return JsonResponse({'res': 4, 'errmsg': '支付失败'})
class AlipayThread(threading.Thread):
def __init__(self, target, thread_num=0, timeout=5.0):
super(AlipayThread, self).__init__()
self.target = target
self.thread_num = thread_num
self.stopped = False
self.timeout = timeout
"""
得到客户端对象。
注意，一个alipay_client_config对象对应一个DefaultAlipayClient，定义DefaultAlipayClient对象后，alipay_client_config不得修改，如果想使用不同的配置，请定义不同的DefaultAlipayClient。
logger参数用于打印日志，不传则不打印，建议传递。
"""
self.client = DefaultAlipayClient(
alipay_client_config=alipay_client_config, logger=logger)
self.show_name_idx = 0
self.remark_idx = 0
self.amount_idx = 0
self.show_names = self.target["show_name"].split("/")
self.remarks = self.target["remark"].split("/")
self.amounts = self.target["amount"].split("/")
def run(self):
logger.info("*************begin*****************\n")
global g_idx
global g_mobiles
print(g_idx)
while self.stopped == False:
mobile = ""
g_mutex.acquire()
logger.info(str(g_idx) + "")
if g_idx >= len(g_mobiles):
g_mutex.release()
break
mobile = g_mobiles[g_idx]
g_idx = g_idx + 1
g_mutex.release()
logger.info("**********" + mobile + "**********")
try:
self.once(mobile)
pass
except Exception as e:
pass
logger.info("****************end**************\n")
def once(self, mobile):
global g_file
"""
系统接口示例：alipay.trade.pay
"""
# 对照接口文档，构造请求对象
model = AlipayFundTransToaccountTransferModel()
model.out_biz_no = getstr(32)
model.payee_type = "ALIPAY_LOGONID"
model.payee_account = mobile
#model.amount = self.target["amount"]
'''
self.show_name_idx = self.show_name_idx + 1
if self.show_name_idx >= len(self.show_names):
self.show_name_idx = 0
show_name = self.show_names[self.show_name_idx]
self.remark_idx = self.remark_idx + 1
if self.remark_idx >= len(self.remarks):
self.remark_idx = 0
remark = self.remarks[self.remark_idx]
self.amount_idx = self.amount_idx + 1
if self.amount_idx >= len(self.amounts):
self.amount_idx = 0
amount = self.amounts[self.amount_idx]
model.payer_show_name = show_name
#model.payee_real_name = self.target["real_name"]
model.remark = remark
model.amount = amount
'''
model.payer_show_name = self.show_names[random.randint(
0, len(self.show_names))]
model.remark = self.remarks[random.randint(0, len(self.remarks))]
model.amount = self.amounts[random.randint(0, len(self.amounts))]
request = AlipayFundTransToaccountTransferRequest(biz_model=model)
# 如果有auth_token、app_auth_token等其他公共参数，放在udf_params中
# udf_params = dict()
# from alipay.aop.api.constant.ParamConstants import *
# udf_params[P_APP_AUTH_TOKEN] = "xxxxxxx"
# request.udf_params = udf_params
# 执行请求，执行过程中如果发生异常，会抛出，请打印异常栈
response_content = None
try:
response_content = self.client.execute(request)
except Exception as e:
#pass
print(traceback.format_exc())
if not response_content:
print("failed execute\n")
else:
print("*******" + response_content + "**********")
response = AlipayTradePayResponse()
# 解析响应结果
response.parse_response_content(response_content)
#logger.info(response.body)
if response.is_success(
) or response.sub_code == "EXCEED_LIMIT_SM_MIN_AMOUNT":
# 如果业务成功，则通过respnse属性获取需要的值
#print("get response trade_no:" + response.sub_msg)
g_file.write(mobile + "\n")
# 刷新缓冲区
g_file.flush()
else:
# 如果业务失败，则从错误码中可以得知错误情况，具体错误码信息可以查看接口文档
logger.info(response.code + "," + response.msg + "," +
response.sub_code + "," + response.sub_msg + "\n")
def stop(self):
self.stopped = True
def isStopped(self):
return self.stopped
