def post(self, request):
'''
处理支付宝的notify_url
通过POST进行判断，通知商家是否支付成功
扩展：为什么不能用本地调试，因为notify_url时返回给服务器的，而不是返回给浏览器处理，而且放在浏览器会不安全。
第三方登录可以本地调试，是因为服务器只执行重定向操作，其他都是服务器处理，而且返回只是基本信息，并不是敏感信息。
'''
processed_dict = {}
for key, value in request.POST.items():
# django的request默认把请求（返回url参数）列表转换为字符串
# 循环出URL的参数
processed_dict[key] = value
# URL参数里的sign参数
sign = processed_dict.pop('sign', None)
# 生成一个Alipay对象
alipay = AliPay(
appid="2016092700609030", # 沙箱的APPID
# 异步url：支付宝获取商家传递的notify_url，通过POST进行判断，通知商家是否支付成功，
# 另外的用途：用户扫码(没有进行支付),支付宝会生成订单url，用户可以通过此url进行支付或者修改订单
app_notify_url=notify_url,
app_private_key_path=private_key_path, # 自己生成的私钥
alipay_public_key_path=
ali_pub_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # debug为true时使用沙箱的url。如果不是用正式环境的url
# 同步url：电脑支付页面成功，回跳的url；（支付宝获取商家的return_url，通过GET请求返回部分支付信息）
return_url=return_url)
# 验证URL参数
verify_re = alipay.verify(processed_dict, sign)
# 验证成功
if verify_re is True:
# get：获取字典的元素
# 先提交订单再进行支付，所以支付完成后就拿到自己生成的out_trade_no
out_trade_no = processed_dict.get('out_trade_no', None)
# 支付宝系统交易流水号
trade_no = processed_dict.get('trade_no', None)
# 交易状态
trade_status = processed_dict.get('trade_status', None)
# 查询数据库有此订单
existed_orders = OrderInfo.objects.filter(trade_no=out_trade_no)
for existed_order in existed_orders:
# 支付成功再增加商品销量
# 卖出n商品，即销售量为n
order_goods = existed_order.goods.all(
) # 所有订单商品对象（列表），OrderGoods外键是OrderInfo
for order_good in order_goods:
goods = order_good.goods # goods对象，OrderGoods外键是Goods
# 商品销售量 = 订单（卖出）所有商品数量
goods.sold_num += order_good.goods_num
goods.save()
# 更新订单状态
existed_order.pay_status = trade_status # 订单状态（重点）
existed_order.trade_no = trade_no # 支付宝系统交易流水号
existed_order.pay_time = datetime.now() # 支付时间
existed_order.save()
# 需要返回一个'success'给支付宝，如果不返回，支付宝会一直发送订单支付成功的消息
return Response("success")
def get_alipay_url(self, obj):
from MxShop.settings import private_key_path, ali_key_path
alipay = AliPay(
# 沙箱里面的appid值
appid="2016092800616929",
# notify_url是异步的url
app_notify_url="http://113.16.255.12:11032/alipay/return/",
# 我们自己商户的密钥
app_private_key_path=private_key_path,
# 支付宝的公钥
alipay_public_key_path=ali_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
# debug为true时使用沙箱的url。如果不是用正式环境的url
debug=True, # 默认False,
return_url="http://113.16.255.12:11032/alipay/return/")
# 直接支付:生成请求的字符串。
url = alipay.direct_pay(
# 订单标题
subject=obj.order_sn,
# 我们商户自行生成的订单号
out_trade_no=obj.order_sn,
# 订单金额
total_amount=obj.order_mount,
)
# 将生成的请求字符串拿到我们的url中进行拼接
re_url = "https://openapi.alipaydev.com/gateway.do?{data}".format(
data=url)
return re_url
def get_alipay_url(self, obj):
'''
:param obj: 为serializer.data
:return:
'''
alipay = AliPay(
# 沙箱的appid
appid="2016101200669671",
# 这里一定要改为线上服务器的地址
app_notify_url="http://线上服务器地址:8000/alipay/return",
# 使用静态文件路径
app_private_key_path=private_key_path,
# 使用静态文件路径
alipay_public_key_path=
ali_public_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥
# debug为True，适用沙箱接口
debug=True, # 默认False,
# 这里一定要改为线上服务器的地址
return_url="http://线上服务器地址:8000/alipay/return")
url = alipay.direct_pay(subject=obj.order_sn,
out_trade_no=obj.order_sn,
total_amount=obj.order_mount)
re_url = "https://openapi.alipaydev.com/gateway.do?{data}".format(
data=url)
return re_url
def get(self, request):
"""
支付宝同步调用返回
:param request:
:return:
"""
# 将支付宝post的数据保存到字典中
processed_dict = {}
for key, value in request.GET.items():
processed_dict[key] = value
# 将sign从字典中移除
sign = processed_dict.pop('sign')
alipay = AliPay(
appid="2016082100304253",
app_notify_url="http://123.206.229.93:8000/alipay/return/",
app_private_key_path=alipay_private_key,
alipay_public_key_path=alipay_pub_key, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://123.206.229.93:8000/alipay/return/" # 支付宝付款完成后返回的url
)
# 使用alipay_public_key为字典重新生成sign，与上面取出的的sign做比较，看数据是否有被修改
verify_re = alipay.verify(processed_dict, sign)
if verify_re is True:
response = redirect('index')
response.set_cookie('nextPath','pay',max_age=2)
return response
else:
response = redirect('index')
return response
def post(self, request):
processed_dict = {}
for key, value in request.GET.items():
processed_dict[key] = value
sign = processed_dict.pop('sign', None)
alipay = AliPay(appid=ALI_APP_ID,
app_notify_url=ALI_NOTIFY_URL,
app_private_key_path=PRIVATE_KEY_PATH,
alipay_public_key_path=ALI_PUB_KEY_PATH,
debug=ALI_Test_DEBUG,
return_url=ALI_RETURN_URL)
# 校验返回的数据
verify_re = alipay.verify(processed_dict, sign)
if verify_re is True:
order_sn = processed_dict.get('out_trade_no', None)
trade_no = processed_dict.get('trade_no', None)
trade_status = processed_dict.get('trade_status', None)
existed_orders = OrderInfo.objects.filter(order_sn=order_sn)
for existed_order in existed_orders:
# 更新商品的卖出数量
order_goods = existed_order.goods.all()
for order_good in order_goods:
goods = order_good.goods
goods.sold_num += order_good.goods_num
goods.save()
# 更新 order 状态
existed_order.pay_status = trade_status
existed_order.trade_no = trade_no
existed_order.pay_time = datetime.now()
existed_order.save()
# 给支付宝返回成功，如果不返回支付宝会不停的给接口发送数据
# 如果 校验返回的数据 和 sign 不匹配，则不处理。
return Response('success')
def post(self, request):
"""
处理支付宝的notify_url
:param request:
:return:
"""
processed_dict = {}
for key, value in request.POST.items():
processed_dict[key] = value
sign = processed_dict.pop("sign", None)
alipay = AliPay(
appid="2016091700530193",
app_notify_url="http://123.206.43.75:8080/alipay/return/",
app_private_key_path=private_key_path,
alipay_public_key_path=
ali_pub_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://123.206.43.75:8080/alipay/return/")
verify_re = alipay.verify(processed_dict, sign)
if verify_re is True:
order_sn = processed_dict("out_trade_no", None)
trade_no = processed_dict('trade_no', None)
trade_status = processed_dict("trade_status", None)
existed_orders = OrderInfo.objects.filter(order_sn=order_sn)
for existed_order in existed_orders:
existed_order.pay_status = trade_status
existed_order.trade_no = trade_no
existed_order.pay_time = datetime.now()
existed_order.save()
return Response("success")
def get(self, request):
"""
返回哪个页面 即redirect 到订单列表页
:param request:
:return:
"""
data_dict = dict()
for k, v in request.GET.items(): # 把类字典转换为字典，包括签名
data_dict[k] = v
sign = data_dict.pop('sign', None) # 此时数据只有数据了
alipay = AliPay(
appid=app_id,
app_notify_url="http://47.105.33.27:8000/alipay_return/",
app_private_key_path=private_key,
alipay_public_key_path=ali_key, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://47.105.33.27:8000/alipay_return/" # 这个最终需要配置成线上的
)
res = alipay.verify(data_dict, sign)
if res: # 比对成功即验签成功 返回 True
# 此时我们可以更新订单流水号等信息
order_sn = data_dict.get('out_trade_no', '')
trade_no = data_dict.get('trade_no', '')
pay_time = datetime.now()
pay_status = data_dict.get('trade_status', 'TRADE_SUCCESS')
order_list = OrderInfo.objects.filter(order_sn=order_sn)
if order_list:
order = order_list[0]
order.pay_status = pay_status
order.pay_time = pay_time
order.trade_no = trade_no
order.save()
ret = redirect(reverse('index'))
ret.set_cookie('nextPath', 'pay', 2)
return ret
def get(self,request):
"""
处理支付宝的retrun_url返回
:param request:
:return:
"""
# 1. 先将sign剔除掉
processed_dict = {}
for key,value in request.GET.items():
processed_dict[key] = value
sign = processed_dict.pop("sing",None)
# 2. 生成一个Alipay对象
alipay = AliPay(
appid=alipay_appid,
app_notify_url="http://127.0.0.1:8000/alipay/retrun",
app_private_key_path=private_key_path,
alipay_public_key_path=ali_pub_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://127.0.0.1:8000/alipay/retrun"
)
# 3. 进行验签，确保这是支付宝给我们的
verify_re = alipay.verify(processed_dict,sign)
# 如果验签成功
if verify_re is True:
#商家订单号
order_sn = processed_dict.get("out_trade_no",None)
#支付宝支付订单号
trade_no = processed_dict.get("trade_no",None)
#支付状态
trade_status = processed_dict.get('trade_status', None)
# 查询数据库中存在的订单
existed_orders = OrderInfo.objects.filter(order_sn=order_sn)
for existed_order in existed_orders:
# 订单商品项
order_goods = existed_order.goods.all()
for order_good in order_goods:
goods = order_good.goods
goods.sold_num += order_good.goods_num
goods.save()
# 更新订单状态，填充支付宝给的交易凭证号。
existed_order.pay_status = trade_status
existed_order.trade_no = trade_no
existed_order.pay_time = datetime.now()
existed_order.save()
response = redirect("index")
# 希望跳转到vue项目的时候直接帮我们跳转到支付的页面
response.set_cookie("nextPath","pay",max_age=2)
return response
else:
response = redirect("index")
return response
def pay(request):
'''封装后'''
# 拿出数据校验
conn = get_redis_connection()
key = 'payment_{}'.format(request.saas.user.phone)
context_string = conn.get(key)
if not context_string:
return redirect('price')
context = json.loads(context_string.decode('utf-8'))
# １．数据库生成交易记录（待支付）,
order_id = uid(request.saas.user.phone) # 根据手机号生成随机字符串
total_price = context['total_price']
Transaction.objects.create(status=1,
order=order_id,
user=request.saas.user,
price_policy_id=context['policy_id'],
count=context['number'],
price=total_price)
# 生成支付宝链接
ali_pay = AliPay(appid=settings.ALI_APPID,
app_notify_url=settings.ALI_NOTIFY_URL,
return_url=settings.ALI_RETURN_URL,
app_private_key_path=settings.ALI_PRI_KEY_PATH,
alipay_public_key_path=settings.ALI_PUB_KEY_PATH)
query_params = ali_pay.direct_pay(
subject="Saas 系统会员", # 商品简单描述
out_trade_no=order_id, # 商户订单号
total_amount=total_price)
pay_url = "{}?{}".format(settings.ALI_GATEWAY, query_params)
return redirect(pay_url)
def get(self, request):
"""
处理支付宝的return_url返回
"""
processed_dict = {}
# 1. 获取GET中参数
for key, value in request.GET.items():
processed_dict[key] = value
# 2. 取出sign
sign = processed_dict.pop("sign", None)
# 3. 生成ALipay对象
alipay = AliPay(
appid="2016090900469819",
app_notify_url="http://47.95.8.70:8000/alipay/return/",
app_private_key_path=private_key_path,
alipay_public_key_path=
ali_pub_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://47.95.8.70:8000/alipay/return/")
verify_re = alipay.verify(processed_dict, sign)
# 这里可以不做操作。因为不管发不发return url。notify url都会修改订单状态。
if verify_re is True:
response = redirect("index")
response.set_cookie("nextPath", "pay", max_age=3)
return response
else:
response = redirect("index")
return response
def get_ailpay_url(self, obj):
"""
系列化ailpay_url，返回ailpay_url（数据）给前端
:param obj: 当前函数对象
:return: 支付页面
"""
# AliPay对象
alipay = AliPay(
appid="2016092700609030", # 沙箱的APPID
# 异步url：支付宝获取商家传递的notify_url，通过POST进行判断，通知商家是否支付成功，
# 另外的用途：用户扫码(没有进行支付),支付宝会生成订单url，用户可以通过此url进行支付或者修改订单
app_notify_url=notify_url,
app_private_key_path=private_key_path, # 自己生成的私钥
alipay_public_key_path=ali_pub_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # debug为true时使用沙箱的url。如果不是用正式环境的url
# 同步url：电脑支付页面成功，回跳的url；（支付宝获取商家的return_url，通过GET请求返回部分支付信息）
return_url=return_url
)
# 请求参数
url = alipay.direct_pay(
subject=obj.order_sn, # 订单标题
out_trade_no=obj.order_sn, # 我们商户自行生成的订单号
total_amount=obj.order_mount, # 订单金额
return_url=return_url
)
re_url = "https://openapi.alipaydev.com/gateway.do?{data}".format(data=url)
return re_url
def post(self, request):
"""
处理notifyUrl
"""
processed_dict = {}
for key, value in request.POST.items():
processed_dict[key] = value
sign = processed_dict.pop("sign", None)
alipay = AliPay(
appid="id",
app_notify_url="url",
app_private_key_path=private_key,
alipay_public_key_path=
ali_public_key, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
return_url="url")
verify_result = alipay.verify(processed_dict, sign)
if verify_result is True:
order_sn = processed_dict.get('out_trade_no', None)
trade_no = processed_dict.get('trade_no', None)
trade_status = processed_dict.get('trade_status', None)
existed_orders = OrderInfo.objects.filter(order_sn=order_sn)
for existed_order in existed_orders:
existed_order.pay_status = trade_status
existed_order.trade_no = trade_no
existed_order.pay_time = datetime.now()
existed_order.save()
return Response("success")
def get(self, request):
processed_dict = {}
for key, value in request.GET.items():
processed_dict[key] = value
sign = processed_dict.pop("sign", None)
alipay = AliPay(
appid="id",
app_notify_url="url",
app_private_key_path=private_key,
alipay_public_key_path=
ali_public_key, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
return_url="url")
verify_result = alipay.verify(processed_dict, sign)
if verify_result is True:
order_sn = processed_dict.get('out_trade_no', None)
trade_no = processed_dict.get('trade_no', None)
trade_status = 'TRADE_SUCCESS'
existed_orders = OrderInfo.objects.filter(order_sn=order_sn)
for existed_order in existed_orders:
order_goods = existed_order.goods.all()
for order_good in order_goods:
goods = order_good.goods
goods.sold_num += order_good.goods_num
goods.save()
existed_order.pay_status = trade_status
existed_order.trade_no = trade_no
existed_order.pay_time = datetime.now()
existed_order.save()
response = redirect("url")
response.set_cookie("nextPath", "pay", max_age=3, domain='url')
return response
else:
response = redirect("url")
return response
def post(self, request):
process_query = {k: v for k, v in request.POST.items()}
ali_sign = process_query.pop('sign')
alipay = AliPay(
appid=APPID,
app_notify_url=RETURN_URL,
app_private_key_path=APP_PRIVATE_KEY_PATH,
alipay_public_key_path=
ALIPAY_PUBLIC_KEY_PATH, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=ALIPAY_DEBUG, # 默认False,
return_url=RETURN_URL)
check_result = alipay.verify(process_query, ali_sign)
response = redirect('index')
if check_result:
order_sn = process_query.get('out_trade_no', None)
trade_no = process_query.get('trade_no', None)
order_infos = OrderInfo.objects.filter(order_sn=order_sn)
# 交易信息保存
for order_info in order_infos:
order_goods = order_info.goods.all()
for order_good in order_goods:
# 根据某个个订单得到对应的商品
goods = order_good.goods
# 商品的销量等于购物车的销量加上原来的
goods.sold_num += order_good.goods_num
goods.save()
order_info.trade_no = trade_no
order_info.pay_status = "TRADE_SUCCESS"
order_info.pay_time = datetime.datetime.now()
order_info.save()
response.set_cookie('nextPath', 'pay', max_age=2)
return response
def retrieve(self, request, *args, **kwargs):
"""
重写 获取某个订单的方法 因为 用户在支付的过程中 可能直接关闭支付 那这个时候这个订单即为未支付状态，也需要把支付链接返回
:param request:
:param args:
:param kwargs:
:return:
"""
instance = self.get_object() # 获取到某个订单实例
alipay = AliPay(
appid=app_id,
app_notify_url="http://47.105.33.27:8000/alipay_return/",
app_private_key_path=private_key,
alipay_public_key_path=ali_key, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://47.105.33.27:8000/alipay_return/")
url = alipay.direct_pay(subject=instance.order_sn,
out_trade_no=instance.order_sn,
total_amount=instance.order_mount)
# 沙箱环境
re_url = "https://openapi.alipaydev.com/gateway.do?{data}".format(
data=url)
serializer = self.get_serializer(instance)
ret = serializer.data
ret['alipay_url'] = re_url
return Response(ret)
def post(self, request):
"""
处理notify_url
"""
process_dict = dict()
for key, value in request.POST.items():
process_dict[key] = value
ali_sign = process_dict.pop('sign')
alipay = AliPay(
appid="2016091500518447",
app_notify_url="http://47.106.173.70:8000/alipay/return/",
app_private_key_path=PRIVATE_KEY_PATH,
alipay_public_key_path=
ALIPAY_KEY_PATH, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://47.106.173.70:8000/alipay/return/")
res_verify = alipay.verify(process_dict, ali_sign)
if res_verify:
order_infos = OrderInfo.objects.filter(
order_sn=process_dict['out_trade_no'])
for order_info in order_infos:
order_info.trade_no = process_dict.get('trade_no', None)
order_info.pay_status = process_dict.get('trade_status', None)
order_info.pay_time = datetime.now()
order_info.save()
return Response("success")
def post(self, request):
processed_dict = {}
for key, value in request.POST.items():
processed_dict[key] = value
sign = processed_dict.pop('sign', None)
# 将剩余的参数重新进行签名
alipay = AliPay(
appid="2016091100484002",
app_notify_url="http://114.116.83.180:8000/trades/alipay/redirect/",
app_private_key_path=settings.app_private_key_path,
alipay_public_key_path=settings.alipay_public_key_path,
debug=True, # 默认False,
return_url="http://114.116.83.180:8000/trades/alipay/redirect/")
result = alipay.verify(processed_dict, sign)
if result:
# 是支付宝回调
# 获取支付宝回传的订单号，利用这个订单号，修改数据库中订单的状态
order_sn = processed_dict.get('out_trade_no', None)
order = OrderInfo.objects.filter(order_sn=order_sn).first()
order.pay_status = processed_dict.get('trade_status')
order.trade_no = processed_dict.get('trade_no')
order.pay_time = datetime.now()
order.save()
return Response('success')
else:
return Response('')
def post(self, request):
processed_dict = {}
for key, value in request.POST.items():
processed_dict[key] = value
sign = processed_dict.pop('sign', None)
alipay = AliPay(
appid=alipay_id,
app_notify_url="http://127.0.0.1:8000/alipay/return/",
app_private_key_path=private_key_path,
alipay_public_key_path=
ali_pub_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://127.0.0.1:8000/alipay/return/")
verify_re = alipay.verify(processed_dict, sign)
if verify_re is True:
order_sn = processed_dict.get('out_trade_no', None)
trade_no = processed_dict.get('trade_no', None)
trade_status = processed_dict.get('trade_status', None)
existed_orders = OrderInfo.objects.filter(order_sn=order_sn)
for existed_order in existed_orders:
existed_order.pay_status = trade_status
existed_order.trade_no = trade_no
existed_order.pay_time = datetime.now()
existed_order.save()
return Response("success")
def get(self, request):
processed_dict = {}
for key, value in request.GET.item():
processed_dict[key] = value
sign = processed_dict.pop('sign', None)
alipay = AliPay(
appid="",
app_notify_url="http://127.0.0.1:8000/alipay/return/",
app_private_key_path=private_key_path,
alipay_public_key_path=
ali_pub_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://127.0.0.1:8000/alipay/return/")
verify_re = alipay.verify(processed_dict, sign)
if verify_re is True:
order_sn = processed_dict.get('out_trade_no', None)
trade_no = processed_dict.get('trade_no', None)
trade_status = processed_dict.get('trade_status', None)
existed_orders = OrderInfo.objects.filter(order_sn=order_sn)
for existed_order in existed_orders:
existed_order.pay_status = trade_status
existed_order.trade_no = trade_no
existed_order.pay_time = datetime.now()
existed_order.save()
response = redirect("index")
response.set_cookie("nextPath", "pay", max_age=3)
return response
else:
response = redirect("index")
return response
def get(self, request):
"""
处理支付宝的return_url返回
:param request:
:return:
"""
processed_dict = {}
for key, value in request.GET.items():
processed_dict[key] = value
sign = processed_dict.pop("sign", None)
alipay = AliPay(
appid="2016101000652414",
app_notify_url="http://139.199.123.96:8000/alipay/return/",
app_private_key_path=private_key,
alipay_public_key_path=
alipay_public_key, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://139.199.123.96:8000/alipay/return/")
verify_re = alipay.verify(processed_dict, sign)
if verify_re is True:
return HttpResponse('支付成功')
response = redirect("index")
response.set_cookie("nextPath", "pay", max_age=3)
return response
else:
response = redirect("index")
return response
def get(self, request):
"""
处理支付宝的return_url返回
"""
processed_dict = {}
# 1. 获取GET中参数
for key, value in request.GET.items():
processed_dict[key] = value
# 2. 取出sign
sign = processed_dict.pop("sign", None)
# 3. 生成ALipay对象
alipay = AliPay(
appid="2016101800715734",
app_notify_url="http://101.200.163.151:7800/alipay/return/",
app_private_key_path=private_key_path,
alipay_public_key_path=
ali_pub_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://101.200.163.151:7800/alipay/return/")
verify_re = alipay.verify(processed_dict, sign)
# 这里可以不做操作。因为不管发不发return url。notify url都会修改订单状态。
if verify_re is True:
order_sn = processed_dict.get('out_trade_no', None)
trade_no = processed_dict.get('trade_no', None)
trade_status = processed_dict.get('trade_status', None)
existed_orders = OrderInfo.objects.filter(order_sn=order_sn)
for existed_order in existed_orders:
existed_order.pay_status = trade_status
existed_order.trade_no = trade_no
existed_order.pay_time = datetime.now()
existed_order.save()
def pay(request):
conn = get_redis_connection()
key = 'payment_{}'.format(request.tracer.user.mobile_phone)
context_string = conn.get(key)
if not context_string:
return redirect('price')
context = json.loads(context_string.decode('utf-8'))
# 1. 数据库中生成交易记录（待支付）
# 等支付成功之后，我们需要把订单的状态更新为已支付、开始&结束时间
order_id = uid(request.tracer.user.mobile_phone)
total_price = context['total_price']
models.Transaction.objects.create(status=1,
order=order_id,
user=request.tracer.user,
price_policy_id=context['policy_id'],
count=context['number'],
price=total_price)
# 生成支付链接
ali_pay = AliPay(appid=settings.ALI_APPID,
app_notify_url=settings.ALI_NOTIFY_URL,
return_url=settings.ALI_RETURN_URL,
app_private_key_path=settings.ALI_PRI_KEY_PATH,
alipay_public_key_path=settings.ALI_PUB_KEY_PATH)
query_params = ali_pay.direct_pay(
subject="trace rpayment", # 商品简单描述
out_trade_no=order_id, # 商户订单号
total_amount=total_price)
pay_url = "{}?{}".format(settings.ALI_GATEWAY, query_params)
return redirect(pay_url)
def get_alipay_url(self, obj):
alipay = AliPay(
# 自己沙箱应用的APPID
appid="2016091100484002",
# 如果用户没有再浏览器生成的支付订单中支付，而是通过支付宝app进行了订单支付，此时需要指定一个跳转地址。
# app_notify_url：只要用户通过支付宝支付成功，支付宝就会回调这个notify_url
app_notify_url="http://114.116.83.180:8000/trades/alipay/redirect/",
app_private_key_path=settings.app_private_key_path,
# 支付宝的公钥，验证支付宝回传消息使用，不是自己生成的应用公钥
alipay_public_key_path=settings.alipay_public_key_path,
debug=True, # 默认False,
# 如果用户是在浏览器上的支付宝订单页面进行的支付操作，支付完成之后会自动跳转到网站的指定页面return_url。如果用户没有在浏览器上支付，return_url就失效了。
return_url="http://114.116.83.180:8000/trades/alipay/redirect/"
# app_notify_url和return_url，只有在支付成功的前提下，支付宝才会回调。
# app_notify_url: 相当于是支付宝给后台发送的一个通知，告诉后台用户已经支付完成了，当后台接收到这个通知之后，必须给支付宝返回一个success结果，告诉支付宝后台已经接收到这个支付结果通知了。
# return_url：就是一个简单的支付宝回调，支付宝只负责回调这个url地址，至于这个url地址做了什么事情，与支付宝就无关了，支付宝也不会关心这个url的返回值。
)
url = alipay.direct_pay(subject=obj.order_sn,
out_trade_no=obj.order_sn,
total_amount=obj.order_mount)
# 这个re_url就是支付宝提供的一个扫码支付页面的Url
re_url = "https://openapi.alipaydev.com/gateway.do?{data}".format(
data=url)
return re_url
def post(self, request):
# 处理支付宝回调notify_url时，发送的POST请求
# 只要用户支付成功，只要是通过支付宝完成的支付，支付宝服务器肯定会回调这个notify_url
# 在接收到支付宝回调请求(GET/POST)的时候，后台需要对这个回调进行验证，如果判断出来不是支付宝回调，可以对这个请求不做任何处理。
# 1. 将支付宝回调时传递的参数进行整理，将sign这个参数获取出来，然后利用剩余的那些参数进行签名(支付宝公钥)，签名之后会得到一个新的sign，然后用这个新的sign和回调传过来的sign进行对比，如果值一样，说明是支付宝在回调。
processed_dict = {}
for key, value in request.POST.items():
processed_dict[key] = value
sign = processed_dict.pop('sign', None)
# 然后将剩余的参数重新进行签名
alipay = AliPay(
appid="2016091100484002",
app_notify_url="http://114.116.83.180:8000/trades/alipay/redirect/",
app_private_key_path=settings.app_private_key_path,
alipay_public_key_path=settings.alipay_public_key_path,
debug=True, # 默认False,
return_url="http://114.116.83.180:8000/trades/alipay/redirect/"
)
result = alipay.verify(processed_dict, sign)
if result:
# 是支付宝回调
# 获取支付宝回传的订单号，利用这个订单号，修改数据库中订单的状态
order_sn = processed_dict.get('out_trade_no', None)
order = OrderInfo.objects.filter(order_sn=order_sn).first()
order.pay_status = processed_dict.get('trade_status')
order.trade_no = processed_dict.get('trade_no')
order.pay_time = datetime.now()
order.save()
return Response('success')
else:
return Response('')
def get(self, request):
"""
处理支付宝url_return返回
:param request:
:return:
"""
process_dict = {}
for key, value in request.GET.items():
process_dict[key] = value
sign = process_dict.pop('sign', None)
alipay = AliPay(
appid="2016091500519386",
app_notify_url="http://122.152.225.37:8000/alipay/return/",
app_private_key_path=private_key_path,
alipay_public_key_path=ali_pub_key_path,
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://122.152.225.37:8000/alipay/return/")
verify_result = alipay.verify(process_dict, sign)
if verify_result:
order_sn = process_dict.get('out_trade_no', None)
trade_no = process_dict.get('trade_no', None)
trade_status = process_dict.get('trade_status', None)
exist_orders = OrderInfo.objects.filter(order_sn=order_sn)
for exist_order in exist_orders:
exist_order.pay_status = trade_status
exist_order.trade_no = trade_no
exist_order.pay_time = datetime.now()
exist_order.save()
return Response('success')
def get_alipay_url(self, obj):
alipay = AliPay(
# 沙箱里面的appid值
appid=ali_appid,
# notify_url是异步的url
app_notify_url="http://39.107.94.185:8000/alipay/return/",
# 我们自己商户的密钥
app_private_key_path=private_key_path,
# 支付宝的公钥
alipay_public_key_path=
ali_pub_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
# debug为true时使用沙箱的url。如果不是用正式环境的url
debug=True, # 默认False,
return_url="http://39.107.94.185:8000/alipay/return/")
url = alipay.direct_pay(
# 订单标题
subject=obj.order_sn,
# 我们商户自行生成的订单号
out_trade_no=obj.order_sn,
# 订单金额
total_amount=obj.order_mount,
# 成功付款后跳转到的页面，return_url同步的url
# return_url="http://39.107.94.185:8000/alipay/return/"
)
# 将生成的请求字符串拿到我们的url中进行拼接
re_url = "https://openapi.alipaydev.com/gateway.do?{data}".format(
data=url)
return re_url
def get_alipay_url(self, obj):
"""
动态返回alipay_url的值
:param obj:
:return:
"""
alipay = AliPay(
appid="2016082100304253",
app_notify_url="http://123.206.229.93:8000/alipay/return/",
app_private_key_path=alipay_private_key,
alipay_public_key_path=
alipay_pub_key, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url=
"http://123.206.229.93:8000/alipay/return/" # 支付宝付款完成后返回的url
)
# 生成支付url
url = alipay.direct_pay(
subject=obj.order_sn,
out_trade_no=obj.order_sn,
total_amount=obj.order_mount,
# return_url="http://123.206.229.93:8000/" # 返回链接
)
re_url = "https://openapi.alipaydev.com/gateway.do?{data}".format(
data=url)
return re_url
def post(self,request):
""" 处理支付宝的notify_url"""
print("post request==", request)
process_dict = {}
for key, value in request.POST.items():
process_dict[key] = value
print(process_dict)
alipay = AliPay(
appid="2016091300503705",
# post请求
app_notify_url="http://118.190.202.67:8000/alipay/return/",
app_private_key_path=app_private_key_path,
alipay_public_key_path=alipay_public_key_path,
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
# get请求
return_url="http://118.190.202.67:8000/alipay/return/"
)
# 把签名删除掉
sign_type = process_dict.pop("sign", None)
# 如果是True,数据没有修改；False校验不通过
verify_result = alipay.verify(process_dict, sign_type)
print(verify_result)
if verify_result:
# 支付宝交易号
trade_no = process_dict.get("trade_no", None)
# 商品号，网站唯一商品号
goods_sn = process_dict.get("out_trade_no", None)
pay_status = process_dict.get("pay_status", "TRADE_SUCCESS")
# 查询订单
exsited_orders = OrderInfo.objects.filter(order_sn=goods_sn)
for exsited_order in exsited_orders:
# 支付宝交易号
exsited_order.trade_no = trade_no
# 支付状态
exsited_order.pay_status = pay_status
# 支付时间
exsited_order.pay_time = datetime.now()
# 保存
exsited_order.save()
# 返回支付成功状态
# return Response("success")
response = redirect("index")
# 设置cookie
response.set_cookie("nextPath", "pay", max_age=2)
return response
else:
# 跳转到首页
response = redirect("index")
return response
def post(self, request):
"""
处理支付宝notify_url异步通知
:param request:
:return:
"""
processed_dict = {}
for key, value in request.POST.items():
processed_dict[key] = value
print('request.POST的值：', processed_dict)
sign = processed_dict.pop('sign', None) # 直接就是字符串了
server_ip = get_server_ip()
alipay = AliPay(
app_id=app_id, # 自己支付宝沙箱 APP ID
notify_url="http://{}:8000/alipay/return/".format(server_ip),
app_private_key_path=app_private_key_path, # 可以使用相对路径那个
alipay_public_key_path=
alipay_public_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=alipay_debug, # 默认False,
return_url="http://{}:8000/alipay/return/".format(server_ip))
verify_result = alipay.verify(processed_dict, sign) # 验证签名，如果成功返回True
if verify_result:
order_sn = processed_dict.get('out_trade_no') # 原支付请求的商户订单号
trade_no = processed_dict.get('trade_no') # 支付宝交易凭证号
trade_status = processed_dict.get('trade_status') # 交易目前所处的状态
# 更新数据库订单状态
"""
OrderInfo.objects.filter(order_sn=order_sn).update(
trade_no=trade_no, # 更改交易号
pay_status=trade_status, # 更改支付状态
pay_time=timezone.now() # 更改支付时间
)
"""
orderinfos = OrderInfo.objects.filter(order_sn=order_sn)
for orderinfo in orderinfos:
orderinfo.trade_no = trade_no, # 更改交易号
orderinfo.pay_status = trade_status, # 更改支付状态
orderinfo.pay_time = timezone.now() # 更改支付时间
# 更改商品的销量
order_goods = orderinfo.order_goods.all()
for item in order_goods:
# 获取订单中商品和商品数量，然后将商品的销量进行增加
goods = item.goods
goods.sold_num += item.goods_nums
goods.save()
orderinfo.save()
# 给支付宝返回一个消息，证明已收到异步通知
# 当商户收到服务器异步通知并打印出 success 时，服务器异步通知参数 notify_id 才会失效。
# 也就是说在支付宝发送同一条异步通知时（包含商户并未成功打印出 success 导致支付宝重发数次通知），服务器异步通知参数 notify_id 是不变的。
return Response('success')
def get(self, request):
"""
处理支付宝的return_url返回
:param request:
:return:
"""
processed_dict = {} #新建一个字典
for key, value in request.GET.items():
processed_dict[
key] = value #将 request中POST请求中数据放到processed_dict字典中
sign = processed_dict.pop("sign", None) #将processed_dict中的sign删除
alipay = AliPay(
appid="2016080600180695",
app_notify_url="http://127.0.0.1:9000/alipay/return/",
app_private_key_path=private_key_path, # 应用私钥的路径
alipay_public_key_path=
ali_pub_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://127.0.0.1:9000/alipay/return/")
verify_re = alipay.verify(processed_dict,
sign) #验证是否是支付宝请求过来的数据，验证支付是否有效
if verify_re is True: #如果是True就进行处理，如果不是就认为是恶意攻击，不进行处理
order_sn = processed_dict.get(
'out_trade_no', None) #获取processed_dict中的out_trade_no值
trade_no = processed_dict.get('trade_no', None)
trade_status = processed_dict.get('trade_status', None)
#对商品的售卖数量进行修改
existed_orders = OrderInfo.objects.filter(order_sn=order_sn) #获取订单
for existed_order in existed_orders:
order_goods = existed_order.goods.all(
) #反向去用related_name即可，goods为反向取的related_name
for order_good in order_goods:
goods = order_good.goods #获取goods
goods.sold_num += order_good.goods_num #商品的售卖量加等于 订单里的商品数量
goods.save() #保存 #对商品的售卖数量进行修改
existed_order.pay_status = trade_status
existed_order.trade_no = trade_no
existed_order.pay_time = datetime.now()
existed_order.save() #保存
response = redirect("index") #跳转到index路径
response.set_cookie("nextPath", "pay",
max_age=2) #跳转到Vue中的pay页面，max_age设置为2秒 ，
# max_age尽量设置时间短点，保证使用一次就过期
# 在cookie中 添加nextPath,值为pay
#设置cookie
return response #返回
else: #如果验证不通过，则直接返回，跳转到index路径
response = redirect("index") #跳转到index路径
return response # 返回
