django实现多种支付方式

  1. '''
  2. #思路
  4.    我们希望，通过插拔的方式来实现多方式登录，比如新增一种支付方式，那么只要在项目中新增一个py文件，导入里面的pay方法就可以了，这样在支付业务中支付语句是不发生变化的。
  5.    所以就可以使用python的鸭子类型及面向对象的反射方法来实现功能
  7. '''
  9. ##新建一个Pay文件夹，里面放支付方式.py文件
  10. #Alipay.py
  11. class Alipay:
  12.     def pay(self):
  13.         pass
  14. #Visapay.py
  15. class Visapay:
  16.     def pay(self):
  17.         pass
  18. #Wxpay.py（完全按照接口文档来得）
  19. import time
  20. #记得导入商户号和key哦！
  21. from app01.wx import settings
  22. class Wxpay:
  23.     def pay(self,order_data):
  24.         self.order_id = order_data["order_id"]
  25.         self.open_id = order_data['open_id']
  26.         self.ip = order_data['ip']
  27.         data_body = self.get_body_data()
  28.         import requests
  29.         url = "https://api.mch.weixin.qq.com/pay/unifiedorder"
  30.         response = requests.post(url, data_body.encode("utf-8"), headers={'content-type': "application/xml"})
  31.         res_dict = self.xml_to_dic(response.content)
  32.         timeStamp = str(int(time.time()))
  33.         paySign = self.get_pay_sign(res_dict, timeStamp)
  35.         data_dic = {
  36.             'timeStamp': timeStamp,
  37.             'nonceStr': res_dict['nonce_str'],
  38.             'package': f"prepay_id={res_dict['prepay_id']}",
  39.             'signType': 'MD5',
  40.             "paySign": paySign,
  41.         }
  43.         return data_dic
  45.     def get_pay_sign(self, res_dict, timeStamp):
  46.         print("res_dict", res_dict)
  47.         data_dic = {
  48.             'appId': res_dict['appid'],
  49.             'timeStamp': timeStamp,
  50.             'nonceStr': res_dict['nonce_str'],
  51.             'package': f"prepay_id={res_dict['prepay_id']}",
  52.             "signType": "MD5"
  53.         }
  54.         sign_str = "&".join([f"{k}={data_dic[k]}" for k in sorted(data_dic)])
  55.         sign_str = f"{sign_str}&key={settings.pay_apikey}"
  56.         import hashlib
  57.         md5 = hashlib.md5()
  58.         md5.update(sign_str.encode("utf-8"))
  59.         sign = md5.hexdigest()
  60.         return sign.upper()
  62.     def xml_to_dic(self, xml_data):
  63.         import xml.etree.ElementTree as ET
  64.         '''
  65.         xml to dict
  66.         :param xml_data:
  67.         :return:
  68.         '''
  69.         xml_dict = {}
  70.         root = ET.fromstring(xml_data)
  71.         for child in root:
  72.             xml_dict[child.tag] = child.text
  73.         return xml_dict
  75.     def get_random(self):
  76.         import random
  77.         data = "123456789zxcvbnmasdfghjklqwertyuiopZXCVBNMASDFGHJKLQWERTYUIOP"
  78.         nonce_str = "".join(random.sample(data, 30))
  79.         return nonce_str
  81.     def get_sign(self):
  82.         data_dic = {
  83.             "nonce_str": self.nonce_str,
  84.             "out_trade_no": self.out_trade_no,
  85.             "spbill_create_ip": self.spbill_create_ip,
  86.             "notify_url": self.notify_url,
  87.             "openid": self.open_id,
  88.             "body": self.body,
  89.             "trade_type": "JSAPI",
  90.             "appid": self.appid,
  91.             "total_fee": "1",
  92.             "mch_id": self.mch_id
  93.         }
  95.         sign_str = "&".join([f"{k}={data_dic[k]}" for k in sorted(data_dic)])
  96.         sign_str = f"{sign_str}&key={settings.pay_apikey}"
  97.         import hashlib
  98.         md5 = hashlib.md5()
  99.         md5.update(sign_str.encode("utf-8"))
  100.         sign = md5.hexdigest()
  101.         return sign.upper()
  103.     def get_body_data(self):
  104.         self.appid = settings.AppId
  105.         # openid=self.open_id
  106.         self.mch_id = str(settings.pay_mchid)
  107.         self.nonce_str = self.get_random()
  108.         self.out_trade_no = self.order_id
  109.         self.spbill_create_ip = self.ip
  110.         self.notify_url = "https://www.test.com"
  111.         self.body = "老男孩学费"
  112.         self.sign = self.get_sign()
  113.         body_data = f"""
  114.            <xml>
  115.                <appid>{self.appid}</appid>
  116.                <mch_id>{self.mch_id}</mch_id>
  117.                <nonce_str>{self.nonce_str}</nonce_str>
  118.                <sign>{self.sign}</sign>
  119.                <body>{self.body}</body>
  120.                <out_trade_no>{self.out_trade_no}</out_trade_no>
  121.                <total_fee>1</total_fee>
  122.                <spbill_create_ip>{ self.spbill_create_ip}</spbill_create_ip>
  123.                <notify_url>{self.notify_url}</notify_url>
  124.                <openid>{self.open_id}</openid>
  125.                <trade_type>JSAPI</trade_type>
  126.            </xml>"""
  127.         return body_data
  129. ##调用支付方法的语句（一般支付都是发生在订单创建好之后）
  130. import importlib
  131. from rest_framework.response import Response
  132. pay_method = "Wxpay" #这里是举例子，所以把pay_method写死了，正常情况下，应该是外面传来的支付方式，然后用pay_method接收
  133. try:
  134.     #用字符串导入支付方式的py文件,例如这里的app01.Pay.{pay_method}
  135.     pay_field = importlib.import_module(f"app01.Pay.{pay_method}")
  137.     #用反射拿到该文件下面的类
  138.     pay_method_class = getattr(pay_field, pay_method)
  139. except:
  140.     return Response({"code": 205, "msg": "错误的支付方式"})
  142. order_data['ip'] = host_ip
  143. order_data['open_id'] = open_id
  145. #完成支付，并把支付数据返回
  146. pay_data = pay_method_class().pay(order_data)
  147. '''
  148. 这里直接用反射拿到的支付类，然后使用它的pay方法，完成支付
  149. '''
  150. return Response({"code": 200, "msg": "ok", "data": pay_data})

django实现订单创建及支付

  1. '''
  2. 几个注意点：
  3. 	1.a,b两个用户同时买一个库存为1的商品，这样为了保证数据安全（即a买了，库存没更新，b又买了，这样就存在安全问题）,需要在数据库操作时加锁，有两个选择：悲观锁和乐观锁。
  4. 	悲观锁：冲突比较多的时候，使用悲观锁。悲观锁获取数据时对数据行了锁定，其他事务要想获取锁，必须等原事务结束。
  5. 	乐观锁：冲突比较少的时候，使用乐观锁。查询时不锁数据，提交更改时进行判断.使用乐观锁前，要先 设置mysql事务的隔离级别transaction-isolation = READ-COMMITTED
  6. 	2.a用户的订单有两种商品，这样提交订单后，假如第一种成功，第二种失败，很显然在订单一个函数里面写一个逻辑是行不通的，应该要么同时成功，要么同时失败。于是自然而然就用到了事务。
  7. '''
  8. #urls.py
  9. from django.urls import path
  10. from app01.view import order
  11. urlpattern = [
  12.     path('order/create', order.Create.as_view()),
  13. ]
  15. #common文件夹下的func.py文件
  16. import  time,random
  17. def get_order_id():
  18.     str_all="1242356796734534"
  19.     return  time.strftime("%Y%m%d%H%M%S")+"".join(random.sample(str_all,5))
  21. #view文件夹下的order.py文件
  22. from rest_framework.views import APIView
  23. from rest_framework.response import Response
  24. from django.db import transaction
  25. from django import forms
  26. from django.core.cache import cache
  27. from common import func
  29. class OrderForm():
  30.     phone = forms.CharField(
  31.     	error_message = {
  32.             'required': "手机号不能为空"
  33.         },
  34.               # 调用Form组件中的验证器来校验手机号
  35.        # validators=[RegexValidator(r'1[1-9][0-9]{9}', '手机号格式不正确')],
  36.     )
  38.         token = forms.CharField( error_messages={
  39.             "required": "token不能为空"
  40.         })
  41.     province=forms.CharField( error_messages={
  42.             "required": "省份不能为空"
  43.         })
  44.     city = forms.CharField(error_messages={
  45.         "required": "城市不能为空"
  46.     })
  47.     county = forms.CharField(error_messages={
  48.         "required": "县/区不能为空"
  49.     })
  50.     address = forms.CharField(error_messages={
  51.         "required": "详细地址不能为空"
  52.     })
  53.     name = forms.CharField(error_messages={
  54.         "required": "姓名不能为空"
  55.     })
  57. class Create(APIView):
  58.     @transaction.atomic
  59.     def post(self, requset):
  60. 		param = request.data
  61.         #form表单检验订单数据是否符合规范
  62.         for_obj = OrderForm(param)
  63.         #校验成功，并且买东西了
  64.         if for_obj.is_valid() and param.get('buy_list'):
  65.              buy_list = param.get("buy_list")
  66.                 #固定方法拿到付款用户的id
  67.                 if request.META.get("HTTP_X_FORWARDED_FOR"):
  68.                     host_ip = request.META["HTTP_X_FROWARDED_FOR"]
  69.                 else:
  70.                     host_ip = request.META["REMOTE_ADDR"]
  71.                 #校验token，保证登入状态
  72.                 cache_data = cache.get(param["token"])
  73.                 if not cache_data:
  74.                     return Response({"code": 202, "msg": "错误的token"})
  75.                 openid = cache_data.split("&")[0]
  76.                 #通过openid查找用户
  77.                 user_data = models.Wxuser.objects.filter(openid=openid).first()
  79.                 #组织部分总订单数据
  81.                order_data = {"consignee_mobile": param['phone'],
  82.                               'consignee_name': param['name'],
  83.                               'wxuser_id': user_data.id,
  84.                               "memo": param['remark'],
  85.                               "consignee_area": f"{param['province']},{param['city']},{param['county']}",
  86.                               "consignee_address": param['address'],
  87.                               }
  89.                 order_data['order_id']=func.get_order_id()
  90.                 order_data["order_total"]=0
  92.                 #获取用户购买商品的id
  93.                 all_product_id=list(buy_list.keys())
  94.                 #通过id来获取商品的信息
  95.                 product_data=models.Product.objects.filter(product_id__in=all_product_id).all()
  97.                 #开启事务
  98.  sid = transaction.savepoint()
  99.                 for product in product_data:
  100.                     product.product_id=str(product.product_id)
  101.                     # num=buy_list[product.id]
  102.                     #获取商品的库存
  103.                     for  i in  range(3):
  104.                         product_stock = product.stock.quantity
  105.                         new_product_stock = product_stock-buy_list[product.product_id]
  106.                         if new_product_stock<0:
  107.                             transaction.savepoint_rollback(sid)
  108.                             return Response({"code": 204, "msg": f"{product.name}库存不足"})
  109.                         #乐观锁
  110.                         res=models.Stock.objects.filter(quantity=product_stock,stock_id=product.stock.stock_id).update(quantity=new_product_stock)
  111.                         if  not res :
  112.                             #如果两次都不成功，就让用户重新下单
  113.                             if i==2:
  114.                                 transaction.savepoint_rollback(sid)
  115.                                 return Response({"code": 205, "msg": "下单失败从新下单"})
  116.                             else:
  117.                                 continue
  118.                         else:
  119.                             break
  121.                     #组织子订单数据
  122.                     order_item_data = {'order_id': order_data['order_id'], 'product_id': product.product_id,"name": product.name, "image": product.image, "price": product.price,
  123.                                        "nums": buy_list[product.product_id], "brief": product.brief}
  124.                     #创建数据
  125.                     models.Order_items.objects.create(**order_item_data)
  127.                     #获取订单总金额
  128.                     order_data["order_total"] += buy_list[product.product_id]*product.price
  130.                 #创建总订单
  131.                 models.Order.objects.create(**order_data)
  133.                 transaction.savepoint_commit(sid)
  135.                 #提交延时任务，判断订单再指定时间内，有没有支付，如果没有支付，回滚库存，取消订单
  136.                 func.check_order(order_data['order_id'])
  138.                 #如果pay_methon是外面传的
  139.                 pay_methon= "Wxpay"
  140.                 try:
  141.                     #导入app01.Pay.{pay_methon}
  142.                     pay_filed=importlib.import_module(f"app01.Pay.{pay_methon}")
  144.                     #用反射获取，这个文件中的类
  145.                     pay_methon_class=getattr(pay_filed,pay_methon)
  146.                 except:
  147.                     return Response({"code": 205, "msg": "错误的支付方式"})
  149.                 order_data['ip'] = host_ip
  150.                 order_data['open_id'] = openid
  152.                 #获取小程序所需的支付数据
  153.                 pay_data= pay_methon_class().pay(order_data)
  155.                 # pay_methon ="Alipay"
  156.                 # if pay_methon=="Wxpay":
  157.                 #     Wxpay().pay
  158.                 # elif:...
  159.                 # pay_methon
  160.                 return Response({"code": 200, "msg": "ok","data":pay_data})
  161.         else:
  162.             return Response({"code": 203, "msg": "缺少参数"})
  164. class Notify(APIView):
  165.     def post(self,request,paymethon):
  166.         pay_filed = importlib.import_module(f"app01.Pay.{paymethon}")
  167.         pay_methon_class = getattr(pay_filed, paymethon)
  168.         data=pay_methon_class().notify(request.data)
  169.         if  data['stauts']=="suc":
  170.             models.Order.objects.filter(order_id=data['order_id']).update(pay_status="")

celery实现库存回滚

  1. #proj_celery文件夹下的celery.py文件
  2. import celery
  3. import time
  5. # broker='redis://127.0.0.1:6379/2' 不加密码
  6. backend = 'redis://127.0.0.1:6379/1'
  7. broker = 'redis://127.0.0.1:6379/2'
  8. cel = celery.Celery('test', backend=backend, broker=broker)
  10. import os, sys
  11. import django
  13. BASE_DIR = os.path.dirname(os.path.dirname(__file__))  # 定位到你的django根目录
  14. # sys.path.append(os.path.join(BASE_DIR, "app01"))
  15. sys.path.append(os.path.abspath(BASE_DIR))
  16. os.environ.setdefault("DJANGO_SETTINGS_MODULE", "shop.settings")
  17. django.setup()
  18. from django.db import transaction
  20. @cel.task
  21. @transaction.atomic
  22. def del_order(order_id):
  24.     from app01 import models
  26.     # 查看订单数据
  27.     order_data = models.Order.objects.filter(order_id=order_id, pay_status=False).first()
  29.     # 如果有数据表示没有支付，要进行库存回滚，和取消订单
  30.     if order_data:
  32.         # 获取该订单下的所有子订单
  33.         order_items = models.Order_items.objects.filter(order_id=order_id).all()
  35.         # 将子订单中的数据转变成 {商品id:购买数量，。。。}的格式
  36.         product_all_dic = {item.product_id: item.nums for item in order_items}
  38.         # 获取所有商品的id，成为list格式
  39.         product_all_id = list(product_all_dic.keys())
  41.         # 获取所有的商品
  42.         all_product = models.Product.objects.filter(product_id__in=product_all_id).all()
  44.         sid = transaction.savepoint()
  46.         # 把对应的商品进行库存回滚
  47.         for product in all_product:
  48.             for i in range(3):
  49.                 stock = product.stock.quantity
  50.                 new_stock = stock + product_all_dic[product.product_id]
  52.                 #乐观锁
  53.                 res = models.Stock.objects.filter(stock_id=product.stock.stock_id, quantity=stock).update(
  54.                     quantity=new_stock)
  56.                 if not res:
  57.                     if i == 2:
  58.                         transaction.savepoint_rollback(sid)
  60.                         # 如果这个执行失败了，那我们要从新提交任务，不然库存无法回滚
  61.                         from app01.common import func
  62.                         func.check_order(order_id, 1)
  63.                         return
  64.                     else:
  65.                         continue
  66.                 else:
  67.                     break
  68.         # 修改订单状态
  69.         res1 = models.Order.objects.filter(order_id=order_id, pay_status=False).update(status="dead")
  70.         if res1:
  71.             transaction.savepoint_commit(sid)
  72.         else:
  73.             transaction.savepoint_rollback(sid)

悲观锁和乐观锁

悲观锁和乐观锁与并发订单处理

django实现多种支付、并发订单处理的更多相关文章

  1. 递归与树的写法-多种支付的设计-支付的接通-celery订单的回退实现

    递归与树的写法 data: data=[ {"cat_id":1,"name":"北京","parent_id":0}, ...

  2. 微信支付 统一订单 $order = WxPayApi::unifiedOrder($input); 断点调试

    定位至 CODE /** * 将xml转为array * @param string $xml * @throws WxPayException */ public static function I ...

  3. 如何在Django模型中管理并发性 orm select_for_update

    如何在Django模型中管理并发性 为单用户服务的桌面系统的日子已经过去了 - 网络应用程序现在正在为数百万用户提供服务,许多用户出现了广泛的新问题 - 并发问题. 在本文中,我将介绍在Django模 ...

  4. Django实现支付宝支付

    一 去支付宝申请 - 正式:营业执照 - 测试: 沙箱测试环境    APPID:2016092000554391    买家: esnrce2727@sandbox.com    登录和支付密码: ...

  5. django 实现电子支付功能

    思路:调用第三方支付 API 接口实现支付功能.本来想用支付宝来实现第三方网站的支付功能的,但是在实际操作中发现支付宝没有 Python 接口,网上虽然有他人二次封装的的 Python 接口,但是对我 ...

  6. Django 对接 支付宝支付, 回调

    平台 点击这里进入 蚂蚁金服开放平台 沙箱 点击这里进入 沙箱环境 初始界面 设置公钥 下载创建秘钥工具 1.  进入文档中心 这里 2. 选中 电脑网站支付 3. 进入后选中 API 列表 中的 统 ...

  7. 利用微信支付的订单查询接口可以在APP 中提高支付的可靠性

    最近公司有一个应用,用户可以在微信公众号上面下单,也可以在APP 中下单. 当用户在公共号上面下单时,微信支付成功可以返回微信支付单号,但是在APP 中用户微信支付时,个别时候会出现用户已经付款成功, ...

  8. python -django 之第三方支付

    神魔是第三方支付: 第三方支付是指具有一定实力和信誉保障的第三方独立机构.通过与各大银行签订合同,建立连接用户和银行支付结算系统的平台,从而实现电子支付模式.从另一个角度来看,第三方支付就是非金融机构 ...

  9. java 高并发 订单编号递增（解决方案）

    业务描述: 首先从数据中查找最近的一条订单数据,然后将之前的订单号码+1作为新的订单号码,插入到数据库当中.(需求不能改变) 当出现并发操作时,A从数据库中获取最近一条订单的订单号为N,这是A还没有完 ...

随机推荐

  1. My97DatePicker-WdatePicker日历日期插件详细示例

    <!DOCTYPE html> <html> <head> <title>排行</title> <meta charset=" ...

  2. SAP用户角色分配函数权限

    事务码 PFCG修改角色 选择[权限缺省] 选择 RFC 输入的函数只能是允许远程连接的函数,否则不能调用和添加到角色. 完成添加.

  3. 数据库 tcp协程实现并发 回调函数

    数据库 tcp协程实现并发 回顾 一.回顾 进程池,线程池,回调函数 # from gevent import monkey;monkey.patch_all() #补丁 from gevent im ...

  4. DBUtils的使用之查询的操作

    1.1 查询的代码实现1.1.1.1 查询一条记录 l 创建一个对象:Account l 查询代码实现 1.1.1.2 查询多条记录

  5. OpenCV-3.4.3图像通道处理

    图像通道处理 图像读取和处理都是按BGR通道顺序进行的 #include <iostream> #include <opencv2/opencv.hpp> #include & ...

  6. sshd服务安装-ssh命令使用方法

    SSHD服务概述 介绍:SSH协议:安全外壳协议.为 Secure Shell的缩写.SSH 为建立在应用层和传输层基础上的安全协议. 作用:SSHD服务使用SSH协议可以用来进行远程控制,或在计算机 ...

  7. CSS权重的进制问题

    这是复习篇的第一个知识点,(CSS权重进制在IE6为256,后来扩大到了65536.而现代浏览器则采用更大的数量)在说这个知识点之前我们先来看一个例子 <!DOCTYPE html> &l ...

  8. Mac PyCharm2019激活码

    此教程支持最新2019.2版本Pycharm及其他软件 此教程实时更新,请放心使用:如果有新版本出现猪哥都会第一时间尝试激活: pycharm官网下载地址:http://www.jetbrains.c ...

  9. netty源码解析(4.0)-21 ByteBuf的设计原理

        io.netty.buffer包中是netty ByteBuf的实现.ByteBuf是一个二进制缓冲区的抽象接口,它的功能有: 可以随机访问.顺序访问. 支持基本数据类型(byte, shor ...

  10. C++ 深入浅出工厂模式（进阶篇）

    介绍 前文初始篇C++ 深入浅出工厂模式(初始篇),主要阐述了简单工厂模式.工厂方法模式和抽象工厂模式的结构.特点和缺陷等.以上三种方式,在新增产品时,要么修改工厂类,要么需新增具体的工厂类,说明工厂 ...