优化ai支付回调接口

Controller/AiController.py

@@ -39,10 +39,10 @@ class AiView(View):
     def validation(self, request_dict, request, operation):
         response = ResponseObject()
         if operation is None:
-            return response.json(444, 'error path')
+            return response.json(414)
         # 支付回调接口
         elif operation == 'doPayPalCallBack':  # paypal支付回调
-            return self.do_pay_by_paypal_callback(request_dict, response)
+            return self.do_paypal_callback(request_dict, response)
         elif operation == 'doAlipayCallBack':  # 支付宝支付回调
             return self.do_alipay_callback(request_dict, response)
         elif operation == 'doWechatCallBack':  # 微信支付回调
@@ -57,11 +57,11 @@ class AiView(View):
 
             # 套餐相关接口
             if operation == 'commoditylist':        # 查询套餐列表
-                return self.do_commodity_list(request_dict, response)
+                return self.commodity_list(request_dict, response)
             elif operation == 'experienceOrder':    # 体验套餐
                 return self.experience_order(request_dict, user_id, response)
             elif operation == 'createpayorder':     # 创建支付订单
-                return self.do_create_pay_order(request_dict, request, user_id, response)
+                return self.create_pay_order(request_dict, request, user_id, response)
             elif operation == 'queryorderlist':     # 查询订单列表
                 return self.query_order_list(request_dict, user_id, response)
             elif operation == 'getUsingPackage':    # 获取当前使用套餐
@@ -70,12 +70,12 @@ class AiView(View):
             elif operation == 'getAiStatus':        # 获取开关状态
                 return self.get_ai_status(request_dict, response)
             elif operation == 'changeaistatus':     # 修改开关状态
-                return self.do_change_ai_status(request_dict, user_id, response)
+                return self.change_ai_status(request_dict, user_id, response)
             else:
                 return response.json(414)
 
     @staticmethod
-    def do_commodity_list(request_dict, response):
+    def commodity_list(request_dict, response):
         """
         查询套餐列表
         @param request_dict: 请求数据
@@ -231,7 +231,7 @@ class AiView(View):
             return response.json(474)
 
     @classmethod
-    def do_create_pay_order(cls, request_dict, request, user_id, response):
+    def create_pay_order(cls, request_dict, request, user_id, response):
         """
         创建支付订单
         @param request_dict: 请求数据
@@ -453,7 +453,7 @@ class AiView(View):
             return response.json(500, repr(e))
 
     @staticmethod
-    def do_change_ai_status(request_dict, user_id, response):
+    def change_ai_status(request_dict, user_id, response):
         """
         修改AI开关状态
         @param request_dict: 请求数据
@@ -680,102 +680,131 @@ class AiView(View):
             print(e)
             return {}
 
-    def do_pay_by_paypal_callback(self, request_dict, response):
+    @classmethod
+    def do_paypal_callback(cls, request_dict, response):
+        """
+        paypal支付回调
+        @param request_dict: 请求数据
+        @request_dict paymentId: 支付id
+        @request_dict PayerID: 支付账号id
+        @request_dict orderID: 订单id
+        @request_dict lang: 语言
+        @param response: 响应
+        @return: response
+        """
         logger = logging.getLogger('info')
         logger.info('AI订单---paypal支付回调')
-        paymentId = request_dict.get('paymentId', None)
-        PayerID = request_dict.get('PayerID', None)
-        orderID = request_dict.get('orderID', None)
+        payment_id = request_dict.get('paymentId', None)
+        payer_id = request_dict.get('PayerID', None)
+        order_id = request_dict.get('orderID', None)
         lang = request_dict.get('lang', 'en')
 
-        if not orderID:
+        if not order_id:
             pay_failed_url = CommonService.get_payment_status_url(lang, 'fail')
             return HttpResponseRedirect(pay_failed_url)
 
-        logger.info("paymentID: {}, payerID: {}".format(paymentId, PayerID))
-
         # redis加锁，防止订单重复
-        redisObj = RedisObject()
-        isLock = redisObj.CONN.setnx(orderID + 'do_notify', 1)
-        redisObj.CONN.expire(orderID + 'do_notify', 60)
+        redis_obj = RedisObject()
+        isLock = redis_obj.CONN.setnx(order_id + 'creating_ai_order', 1)
+        redis_obj.CONN.expire(order_id + 'creating_ai_order', 60)
         if not isLock:
             return response.json(5)
 
-        try:
-            order_qs = Order_Model.objects.filter(orderID=orderID, status=0)
-            if not order_qs.exists():
-                return response.json(173)
+        order_qs = Order_Model.objects.filter(orderID=order_id, status=0)
+        if not order_qs.exists():
+            return response.json(173)
 
+        try:
             paypalrestsdk.configure(PAYPAL_CRD)
-            payment = paypalrestsdk.Payment.find(paymentId)
-            logger.info("payment: {}".format(payment))
-
-            payer = payment.execute({"payer_id": PayerID})
-            logger.info('payres: {}'.format(payer))
+            payment = paypalrestsdk.Payment.find(payment_id)
+            payer = payment.execute({'payer_id': payer_id})
             if not payer:
                 pay_failed_url = CommonService.get_payment_status_url(lang, 'fail')
-                redisObj.del_data(key=orderID + 'do_notify')
+                redis_obj.del_data(key=order_id + 'creating_ai_order')
                 return HttpResponseRedirect(pay_failed_url)
-            return self.payment_success(orderID, lang, order_qs, redisObj)
+            return cls.payment_success(order_id, lang, order_qs, redis_obj)
         except Exception as e:
             logger.info('AI订单paypal支付回调异常:{}'.format(repr(e)))
             order_qs.update(status=10)
             pay_failed_url = CommonService.get_payment_status_url(lang, 'fail')
-            redisObj.del_data(key=orderID + 'do_notify')
+            redis_obj.del_data(key=order_id + 'creating_ai_order')
             return HttpResponseRedirect(pay_failed_url)
 
-    def do_alipay_callback(self, request_dict, response):  # 支付宝支付回调
+    @classmethod
+    def do_alipay_callback(cls, request_dict, response):
+        """
+        支付宝支付回调
+        @param request_dict: 请求数据
+        @param response: 响应
+        @return: response
+        """
         logger = logging.getLogger('info')
         logger.info('AI订单---支付宝支付回调')
-        try:
-            data = request_dict.dict()
-            passback_params = data['passback_params']
-            parmap = dict([(k, v[0]) for k, v in parse_qs(unquote(passback_params)).items()])
-            lang = parmap['lang']
-            signature = data['sign']
-            data.pop('sign')
-            orderID = data['out_trade_no']
-
-            # redis加锁，防止订单重复
-            redisObj = RedisObject()
-            isLock = redisObj.CONN.setnx(orderID + 'do_notify', 1)
-            redisObj.CONN.expire(orderID + 'do_notify', 60)
-            if not isLock:
-                return response.json(5)
-
-            order_qs = Order_Model.objects.filter(orderID=orderID, status=0)
-            if not order_qs.exists():
-                return response.json(173)
 
-            aliPayObj = AliPayObject()
-            alipay = aliPayObj.conf()
+        data = request_dict.dict()
+        passback_params = data['passback_params']
+        params = dict([(k, v[0]) for k, v in parse_qs(unquote(passback_params)).items()])
+        lang = params['lang']
+        signature = data['sign']
+        data.pop('sign')
+        order_id = data['out_trade_no']
+
+        # redis加锁，防止订单重复
+        redis_obj = RedisObject()
+        isLock = redis_obj.CONN.setnx(order_id + 'creating_ai_order', 1)
+        redis_obj.CONN.expire(order_id + 'creating_ai_order', 60)
+        if not isLock:
+            return response.json(5)
+
+        order_qs = Order_Model.objects.filter(orderID=order_id, status=0)
+        if not order_qs.exists():
+            return response.json(173)
+
+        try:
+            alipay_obj = AliPayObject()
+            alipay = alipay_obj.conf()
             success = alipay.verify(data, signature)
-            if not success or data["trade_status"] not in ("TRADE_SUCCESS", "TRADE_FINISHED"):
+            if not success or data['trade_status'] not in ('TRADE_SUCCESS', 'TRADE_FINISHED'):
                 return response.json(0, signature)
-            return self.payment_success(orderID, lang, order_qs, redisObj)
+            return cls.payment_success(order_id, lang, order_qs, redis_obj)
         except Exception as e:
             logger.info('AI订单支付宝支付回调异常:{}'.format(repr(e)))
             order_qs.update(status=10)
-            redisObj.del_data(key=orderID + 'do_notify')
+            redis_obj.del_data(key=order_id + 'creating_ai_order')
             pay_failed_url = CommonService.get_payment_status_url(lang, 'fail')
-            redisObj.del_data(key=orderID + 'do_notify')
+            redis_obj.del_data(key=order_id + 'creating_ai_order')
             return HttpResponseRedirect(pay_failed_url)
 
-    def do_wechat_callback(self, request, response):  # 微信支付回调
+    @classmethod
+    def do_wechat_callback(cls, request, response):
+        """
+        微信支付回调
+        @param request: 请求体
+        @param response: 响应
+        @return: response
+        """
         logger = logging.getLogger('info')
         logger.info('AI订单---微信支付回调')
-        try:
-            pay = WechatPayObject()
-            data = pay.weixinpay_call_back(request.body)
-            attach = data["attach"]
-            parmap = dict([(k, v[0]) for k, v in parse_qs(unquote(attach)).items()])
-            lang = parmap['lang']
-            trade_status = data['result_code']  # 业务结果  SUCCESS/FAIL
-            orderID = data['out_trade_no']  # 商户订单号
-            order_qs = Order_Model.objects.filter(orderID=orderID, status=0)
-            if not order_qs.exists():
-                return response.json(173)
 
+        pay = WechatPayObject()
+        data = pay.weixinpay_call_back(request.body)
+        attach = data["attach"]
+        params = dict([(k, v[0]) for k, v in parse_qs(unquote(attach)).items()])
+        lang = params['lang']
+        trade_status = data['result_code']  # 业务结果  SUCCESS/FAIL
+        order_id = data['out_trade_no']  # 商户订单号
+
+        # redis加锁，防止订单重复
+        redis_obj = RedisObject()
+        isLock = redis_obj.CONN.setnx(order_id + 'creating_ai_order', 1)
+        redis_obj.CONN.expire(order_id + 'creating_ai_order', 60)
+        if not isLock:
+            return response.json(5)
+
+        order_qs = Order_Model.objects.filter(orderID=order_id, status=0)
+        if not order_qs.exists():
+            return response.json(173)
+        try:
             if trade_status != 'SUCCESS':
                 order_qs.update(status=10)
                 return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL'}))
@@ -783,23 +812,26 @@ class AiView(View):
             if not check_sign:
                 return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL', 'return_msg': '签名失败'}))
 
-            # redis加锁，防止订单重复
-            redisObj = RedisObject()
-            isLock = redisObj.CONN.setnx(orderID + 'do_notify', 1)
-            redisObj.CONN.expire(orderID + 'do_notify', 60)
-            if not isLock:
-                return response.json(5)
-
-            return self.payment_success(self, orderID, lang, order_qs, redisObj, True)
+            return cls.payment_success(order_id, lang, order_qs, redis_obj, True)
         except Exception as e:
             order_qs.update(status=10)
-            redisObj.del_data(key=orderID + 'do_notify')
+            redis_obj.del_data(key=order_id + 'creating_ai_order')
             return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL', 'return_msg': repr(e)}))
 
-    def payment_success(self, orderID, lang, order_qs, redisObj, is_wechat_pay=False):
-        nowTime = int(time.time())
-        order_list = order_qs.values("UID", "channel", "commodity_code", "ai_rank__effective_day", "isSelectDiscounts",
-                                     "userID__userID", "userID__username", "coupon_id")
+    @staticmethod
+    def payment_success(order_id, lang, order_qs, redis_obj, is_wechat_pay=False):
+        """
+        支付成功
+        @param order_id: 订单id
+        @param lang: 语言
+        @param order_qs: 订单QuerySet对象
+        @param redis_obj: redis对象
+        @param is_wechat_pay: 是否为微信支付
+        @return: HttpResponse or HttpResponseRedirect
+        """
+        now_time = int(time.time())
+        order_list = order_qs.values('UID', 'channel', 'commodity_code', 'ai_rank__effective_day', 'isSelectDiscounts',
+                                     'userID__userID', 'userID__username', 'coupon_id')
         userid = order_list[0]['userID__userID']
         username = order_list[0]['userID__username']
         UID = order_list[0]['UID']
@@ -807,29 +839,29 @@ class AiView(View):
         effective_day = order_list[0]['ai_rank__effective_day']
 
         ai_service_qs = AiService.objects.filter(Q(uid=UID), Q(channel=channel), Q(use_status=1))
-        ai_service_dict = {'orders_id': orderID,
+        ai_service_dict = {'orders_id': order_id,
                            'uid': UID,
                            'channel': channel,
                            'detect_status': 1,
-                           'addTime': nowTime,
-                           'updTime': nowTime,
+                           'addTime': now_time,
+                           'updTime': now_time,
                            }
         if ai_service_qs.exists():  # 有正在使用的套餐,套餐结束时间保存为套餐有效期
             ai_service_dict['endTime'] = effective_day * 24 * 60 * 60
         else:
             ai_service_dict['use_status'] = 1
-            ai_service_dict['endTime'] = nowTime + effective_day * 24 * 60 * 60
+            ai_service_dict['endTime'] = now_time + effective_day * 24 * 60 * 60
         with transaction.atomic():
             # 更新设备主用户
             Device_Info.objects.filter(UID=UID, vodPrimaryUserID='', vodPrimaryMaster=''). \
                 update(vodPrimaryUserID=userid, vodPrimaryMaster=username)
             # 更新订单数据,返回支付成功url
-            order_qs.update(status=1, updTime=nowTime)
+            order_qs.update(status=1, updTime=now_time)
             # 创建AiService数据
             AiService.objects.create(**ai_service_dict)
 
         pay_success_url = CommonService.get_payment_status_url(lang, 'success')
-        redisObj.del_data(key=orderID + 'do_notify')
+        redis_obj.del_data(key=order_id + 'creating_ai_order')
         if is_wechat_pay:
             return HttpResponse("<xml>\
               <return_code><![CDATA[SUCCESS]]></return_code>\