生成云盘订单

Ansjer/server_urls/icloud_url.py

@@ -8,6 +8,6 @@ from django.urls import re_path
 from Controller.IcloudService import IcloudMeal, IcloudService
 
 urlpatterns = [
-    re_path(r'^meal/(?P<operation>.*)$', IcloudMeal.UserRelatedView.as_view()),
-    re_path(r'^service/(?P<operation>.*)$', IcloudService.UserRelatedView.as_view()),
+    re_path(r'^meal/(?P<operation>.*)$', IcloudMeal.IcloudMeal.as_view()),
+    re_path(r'^service/(?P<operation>.*)$', IcloudService.IcloudService.as_view()),
 ]

Controller/IcloudService/IcloudMeal.py

@@ -4,18 +4,29 @@
 @Time ： 2023-6-7 18:26:35
 @File ：IcloudMeal.py
 """
+import logging
+import time
+from urllib.parse import quote, parse_qs, unquote
 
-from django.http import HttpResponse
+import paypalrestsdk
+from django.db import transaction
+from django.http import HttpResponse, HttpResponseRedirect
 from django.views import View
 
-from Model.models import ICloudStoreMeal, Pay_Type
+from Model.models import Device_User, ICloudStoreMeal, Order_Model, IcloudUseDetails, IcloudService, Pay_Type
+from Object.AliPayObject import AliPayObject
 from Object.RedisObject import RedisObject
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
-from Ansjer.config import ACCESS_KEY_ID, SECRET_ACCESS_KEY, REGION_NAME, SERVER_DOMAIN
+from Ansjer.config import ACCESS_KEY_ID, SECRET_ACCESS_KEY, REGION_NAME, SERVER_DOMAIN, PAYPAL_CRD, SERVER_DOMAIN_SSL
+from Object.WechatPayObject import WechatPayObject
+from Service.CommonService import CommonService
+from Controller.AiController import AiView
 
+logger = logging.getLogger('info')
 
-class UserRelatedView(View):
+
+class IcloudMeal(View):
     def get(self, request, *args, **kwargs):
         request.encoding = 'utf-8'
         operation = kwargs.get('operation')
@@ -28,20 +39,27 @@ class UserRelatedView(View):
 
     def validation(self, request_dict, operation, request):
         response = ResponseObject()
-        tko = TokenObject(request.META.get('HTTP_AUTHORIZATION'))
-        response.lang = tko.lang
-        user_id = tko.userID
-        if tko.code != 0:
-            return response.json(tko.code)
-        if operation == 'getMeal':  # 获取套餐
-            return self.get_meal(request_dict, response, user_id)
-        elif operation == 'createPayOrder':  # 购买订单
-            return self.create_pay_order(request_dict, response)
+        if operation == 'doPayPalCallBack':  # paypal支付回调
+            return self.do_paypal_callback(request_dict, response)
+        elif operation == 'doAlipayCallBack':  # 支付宝支付回调
+            return self.do_alipay_callback(request_dict, response)
+        elif operation == 'doWechatCallBack':  # 微信支付回调
+            return self.do_wechat_callback(request, response)
         else:
-            return response.json(404)
+            tko = TokenObject(request.META.get('HTTP_AUTHORIZATION'))
+            if tko.code != 0:
+                return response.json(tko.code)
+            response.lang = tko.lang
+            user_id = tko.userID
+            if operation == 'getMeal':  # 获取套餐
+                return self.get_meal(request_dict, response)
+            elif operation == 'createPayOrder':  # 购买订单
+                return self.create_pay_order(request_dict, request, user_id, response)
+            else:
+                return response.json(414)
 
     @staticmethod
-    def get_meal(request_dict, response, user_id):
+    def get_meal(request_dict, response):
         """
         获取套餐
         @param request_dict: 请求参数
@@ -67,20 +85,378 @@ class UserRelatedView(View):
             print(e)
             return response.json(500)
 
-    @staticmethod
-    def create_pay_order(request_dict, response):
+    @classmethod
+    def create_pay_order(cls, request_dict, request, user_id, response):
         """
         购买订单
         @param request_dict: 请求参数
+        @param user_id: 用户id
+        @param request: 请求对象
         @request_dict serial_number: 序列号
         @param response: 响应对象
         @return: response
         """
-        uuid_number = request_dict.get('uuid', None)
-        if not uuid_number:
-            return response.json(444, {'error param': 'uuid'})
+        pay_type = request_dict.get('pay_type', None)
+        rank = request_dict.get('rank', None)
+        lang = request_dict.get('lang', 'en')
+        if not all([pay_type, rank]):
+            return response.json(444, {'error param': 'rank, pay_type'})
+        user_qs = Device_User.objects.filter(userID=user_id)
+        if not user_qs.exists():
+            return response.json(173)
+        meal_qs = ICloudStoreMeal.objects.filter(id=rank, is_show=1, is_delete=0, lang__lang=lang,
+                                                 pay_type=pay_type).values('lang__title', 'lang__content', 'currency',
+                                                                           'price', 'bucket_id')
+        if not meal_qs.exists():
+            return response.json(173)
+        # 查询中文套餐名
+        icloud_meal_qs = ICloudStoreMeal.objects.filter(id=rank, is_show=1, is_delete=0, lang__lang='cn').values(
+            'lang__title',
+            'lang__content')
+        if icloud_meal_qs.exists():
+            store_meal_name = icloud_meal_qs[0]['lang__title'] + '-' + icloud_meal_qs[0]['lang__content']
+        else:
+            store_meal_name = '未知套餐'
+        pay_type = int(pay_type)
+        title = meal_qs[0]['lang__title']
+        content = meal_qs[0]['lang__content']
+        currency = meal_qs[0]['currency']
+        price = meal_qs[0]['price']
+        bucket_id = meal_qs[0]['bucket_id']
+        now_time = int(time.time())
+        order_id = CommonService.createOrderID()
+        price = round(float(price), 2)
+        order_dict = {
+            'orderID': order_id,
+            'UID': '',
+            'userID_id': user_id,
+            'desc': content,
+            'payType': pay_type,
+            'payTime': now_time,
+            'price': price,
+            'currency': currency,
+            'addTime': now_time,
+            'updTime': now_time,
+            'ai_rank_id': 1,
+            'rank_id': 1,
+            'order_type': 4,
+            'store_meal_name': store_meal_name,
+            'unify_combo_id': rank,
+            'uid_bucket_id': bucket_id
+        }
         try:
-            return response.json(0)
+            # 创建订单数据和返回支付回调链接
+            if pay_type == 1:  # PayPal支付
+                res_dict = cls.create_paypal_payment(lang, order_id, price, currency, content)
+                if not res_dict:
+                    return response.json(10, 'create ai order failed')
+                order_dict['paymentID'], order_dict['pay_url'] = res_dict['payment_id'], res_dict['pay_url']
+                res_data = {'orderID': order_id, 'redirectUrl': order_dict['pay_url']}
+
+            elif pay_type == 2:  # 支付宝支付
+                res_dict = cls.create_alipay_payment(lang, order_id, price, title, content)
+                if not res_dict:
+                    return response.json(10, 'create ai order failed')
+                order_dict['pay_url'] = res_dict['pay_url']
+                res_data = {'orderID': order_id, 'redirectUrl': order_dict['pay_url']}
+
+            elif pay_type == 3:  # 微信支付
+                ip = CommonService.get_ip_address(request)
+                res_dict = cls.create_wechat_payment(lang, order_id, price, ip, content)
+                if not res_dict:
+                    return response.json(10, 'create ai order failed')
+                order_dict['pay_url'], sign_params = res_dict['pay_url'], res_dict['sign_params']
+                res_data = {'orderID': order_id, 'redirectUrl': order_dict['pay_url'], 'result': sign_params}
+            else:
+                return response.json(444, {'param': 'pay_type'})
+
+            Order_Model.objects.create(**order_dict)
+            return response.json(0, res_data)
         except Exception as e:
-            print(e)
+            logger.info('云盘生成订单异常:{}'.format(repr(e)))
             return response.json(500)
+
+    @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.info('云盘订单---paypal支付回调')
+        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 order_id:
+            pay_failed_url = CommonService.get_payment_status_url(lang, 'fail')
+            return HttpResponseRedirect(pay_failed_url)
+
+        # redis加锁，防止订单重复
+        redis_obj = RedisObject()
+        is_lock = redis_obj.CONN.setnx(order_id + 'creating_icloud_order', 1)
+        redis_obj.CONN.expire(order_id + 'creating_icloud_order', 60)
+        if not is_lock:
+            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:
+            paypalrestsdk.configure(PAYPAL_CRD)
+            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')
+                redis_obj.del_data(key=order_id + 'creating_icloud_order')
+                return HttpResponseRedirect(pay_failed_url)
+            return cls.payment_success(order_id, lang, order_qs, redis_obj)
+        except Exception as e:
+            logger.info('云盘订单paypal支付回调异常:{}'.format(repr(e)))
+            order_qs.update(status=10)
+            pay_failed_url = CommonService.get_payment_status_url(lang, 'fail')
+            redis_obj.del_data(key=order_id + 'creating_icloud_order')
+            return HttpResponseRedirect(pay_failed_url)
+
+    @classmethod
+    def do_alipay_callback(cls, request_dict, response):
+        """
+        支付宝支付回调
+        @param request_dict: 请求数据
+        @param response: 响应
+        @return: response
+        """
+        logger.info('云盘订单---支付宝支付回调')
+
+        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()
+        is_lock = redis_obj.CONN.setnx(order_id + 'creating_icloud_order', 1)
+        redis_obj.CONN.expire(order_id + 'creating_icloud_order', 60)
+        if not is_lock:
+            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'):
+                return response.json(0, signature)
+            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)
+            redis_obj.del_data(key=order_id + 'creating_icloud_order')
+            pay_failed_url = CommonService.get_payment_status_url(lang, 'fail')
+            redis_obj.del_data(key=order_id + 'creating_icloud_order')
+            return HttpResponseRedirect(pay_failed_url)
+
+    @classmethod
+    def do_wechat_callback(cls, request, response):
+        """
+        微信支付回调
+        @param request: 请求体
+        @param response: 响应
+        @return: response
+        """
+        logger.info('云盘订单---微信支付回调')
+
+        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()
+        is_lock = redis_obj.CONN.setnx(order_id + 'creating_icloud_order', 1)
+        redis_obj.CONN.expire(order_id + 'creating_icloud_order', 60)
+        if not is_lock:
+            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'}))
+            check_sign = pay.get_notifypay(data)
+            if not check_sign:
+                return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL', 'return_msg': '签名失败'}))
+
+            return cls.payment_success(order_id, lang, order_qs, redis_obj, True)
+        except Exception as e:
+            order_qs.update(status=10)
+            redis_obj.del_data(key=order_id + 'creating_icloud_order')
+            return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL', 'return_msg': repr(e)}))
+
+    @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('unify_combo_id', 'userID__userID', 'userID__username')
+        user_id = order_list[0]['userID__userID']
+        rank_id = order_list[0]['unify_combo_id']
+
+        icloud_meal_qs = ICloudStoreMeal.objects.filter(rank=rank_id).values('size', 'bucket_id', 'expire')
+        size = icloud_meal_qs[0]['size']
+        bucket_id = icloud_meal_qs[0]['bucket_id']
+        expire = icloud_meal_qs[0]['expire']
+        end_time = CommonService.calcMonthLater(expire)
+        icloud_service_dict = {'orders_id': order_id,
+                               'add_time': now_time,
+                               'upd_time': now_time,
+                               'type': 2,
+                               'size': size,
+                               'end_time': end_time
+                               }
+        icloud_use_qs = IcloudUseDetails.objects.filter(user_id=user_id).values('id')
+        if not icloud_use_qs.exists():
+            icloud_use_qs = IcloudUseDetails.objects.create(add_time=now_time, upd_time=now_time, detect_status=1,
+                                                            user_id=user_id,
+                                                            bucket_id=bucket_id)
+            icloud_service_dict['use_details_id'] = icloud_use_qs.id
+        else:
+            icloud_service_dict['use_details_id'] = icloud_use_qs[0]['id']
+
+
+        with transaction.atomic():
+            # 更新订单数据,返回支付成功url
+            order_qs.update(status=1, updTime=now_time)
+            # 创建AiService数据
+            IcloudService.objects.create(**icloud_service_dict)
+
+        pay_success_url = CommonService.get_payment_status_url(lang, 'success')
+        redis_obj.del_data(key=order_id + 'creating_icloud_order')
+        if is_wechat_pay:
+            return HttpResponse("<xml>\
+              <return_code><![CDATA[SUCCESS]]></return_code>\
+              <return_msg><![CDATA[OK]]></return_msg>\
+            </xml>")
+        else:
+            return HttpResponseRedirect(pay_success_url)
+
+    @staticmethod
+    def create_paypal_payment(lang, order_id, price, currency, content):
+        """
+        创建PayPal支付
+        @param lang: 语言
+        @param order_id: 订单id
+        @param price: 价格
+        @param currency: 货币
+        @param content: 内容
+        @return: pay_dict
+        """
+        cancel_url = CommonService.get_payment_status_url(lang, 'fail')
+        call_sub_url = "{}icloud/meal/doPayPalCallBack?orderID={}&lang={}".format(SERVER_DOMAIN_SSL, order_id, lang)
+
+        try:
+            paypalrestsdk.configure(PAYPAL_CRD)
+            payment = paypalrestsdk.Payment({
+                "intent": "sale",
+                "payer": {"payment_method": "paypal"},
+                "redirect_urls": {"return_url": call_sub_url, "cancel_url": cancel_url},
+                "transactions": [{
+                    "item_list": {"items": [
+                        {"name": "Cloud video", "sku": "1", "price": price, "currency": "USD", "quantity": 1}]},
+                    "amount": {"total": price, "currency": currency},
+                    "description": content}]})
+
+            pay_dict = {}
+            if not payment.create():  # 创建失败
+                return pay_dict
+            payment_id = payment['id']  # 获取payment id
+            for link in payment.links:
+                if link.rel == "approval_url":
+                    pay_url = str(link.href)
+                    pay_dict['payment_id'] = payment_id
+                    pay_dict['pay_url'] = pay_url
+                    return pay_dict
+            return pay_dict
+        except Exception as e:
+            print(e)
+            return {}
+
+    @staticmethod
+    def create_alipay_payment(lang, order_id, price, title, content):
+        """
+        创建支付宝支付
+        @param lang: 语言
+        @param order_id: 订单id
+        @param price: 价格
+        @param title: 标题
+        @param content: 内容
+        @return: pay_dict
+        """
+        try:
+            aliPayObj = AliPayObject()
+            alipay = aliPayObj.conf()
+            subject = title + content
+            order_string = alipay.api_alipay_trade_wap_pay(
+                out_trade_no=order_id,
+                total_amount=price,
+                subject=subject,
+                return_url="{}web/paid2/success.html".format(SERVER_DOMAIN_SSL),
+                notify_url="{}icloud/meal/doAlipayCallBack".format(SERVER_DOMAIN_SSL),
+                quit_url="{}web/paid2/fail.html".format(SERVER_DOMAIN_SSL),
+                passback_params=quote("lang=" + lang)
+            )
+            if not order_string:
+                return {}
+            return {'pay_url': aliPayObj.alipay_prefix + order_string}
+        except Exception as e:
+            print(e)
+            return {}
+
+    @staticmethod
+    def create_wechat_payment(lang, order_id, price, ip, content):
+        """
+        创建微信支付
+        @param lang: 语言
+        @param order_id: 订单id
+        @param price: 价格
+        @param ip: ip
+        @param content: 内容
+        @return: pay_dict
+        """
+        pay_url = "{}icloud/meal/doWechatCallBack".format(SERVER_DOMAIN_SSL)
+        try:
+            pay = WechatPayObject()
+            content = CommonService.Package_Type(4, content)  # 云盘套餐
+            pay.get_parameter(order_id, content, float(price) * 100, ip, pay_url, quote("lang=" + lang))
+            sign_params = pay.re_finall(orderid=order_id)
+            if not sign_params:
+                return {}
+            return {'pay_url': pay_url, 'sign_params': sign_params}
+        except Exception as e:
+            print(e)
+            return {}

Controller/IcloudService/IcloudService.py

@@ -14,7 +14,7 @@ from Object.TokenObject import TokenObject
 from Ansjer.config import ACCESS_KEY_ID, SECRET_ACCESS_KEY, REGION_NAME, SERVER_DOMAIN
 
 
-class UserRelatedView(View):
+class IcloudService(View):
     def get(self, request, *args, **kwargs):
         request.encoding = 'utf-8'
         operation = kwargs.get('operation')

Model/models.py

@@ -3600,6 +3600,8 @@ class IcloudService(models.Model):
     upd_time = models.BigIntegerField(verbose_name='更新时间', default=0)
     use_status = models.IntegerField(verbose_name='使用状态', default=0)  # 0:使用中, 1:已过期
     use_details_id = models.IntegerField(default=0, verbose_name='关联云盘使用表id')
+    type = models.SmallIntegerField(default=0, verbose_name='云盘购买类型')  # 0：注册永久送，1：购买运存附送，2：单独购买套餐
+    order_id = models.CharField(default='', max_length=20, verbose_name='关联订单id')
 
     class Meta:
         db_table = 'icloud_service'

Service/CommonService.py

@@ -727,6 +727,10 @@ GCqvlyw5dfxNA+EtxNE2wCW/LW7ENJlACgcfgPlBZtpLheWoZB/maw4=
             return content
         elif order_type == 2:
             pass
+        elif order_type == 4:
+            content = content + '(' + '云盘' + ')'
+            return content
+
 
     @staticmethod
     def is_cloud_device(ucode, device_type):