苹果内购 - 测试服同步正式服代码

Controller/InAppPurchaseController.py

@@ -4,6 +4,8 @@
 import logging
 import time
 import json
+
+import requests
 from appstoreserverlibrary.api_client import AppStoreServerAPIClient, GetTransactionHistoryVersion
 from appstoreserverlibrary.models.Environment import Environment
 from appstoreserverlibrary.receipt_utility import ReceiptUtility
@@ -18,10 +20,10 @@ from django.db.models import Q
 from django.views import View
 from django.http import HttpResponse
 
-from Ansjer.config import LOGGER, CONFIG_INFO, CONFIG_TEST, PAY_TYPE_IN_APP_PURCHASE, BASE_DIR
+from Ansjer.config import LOGGER, CONFIG_INFO, CONFIG_TEST, PAY_TYPE_IN_APP_PURCHASE, BASE_DIR, CONFIG_US
 from Controller.CheckUserData import DataValid
 from Model.models import Order_Model, Store_Meal, Device_Info, UID_Bucket, Unused_Uid_Meal, AiService, Device_User, \
-    SysMsgModel, DeviceApplePackage, InAppPurchasePackage
+    SysMsgModel
 from Object.AWS.S3Email import S3Email
 from Object.AliSmsObject import AliSmsObject
 from Object.RedisObject import RedisObject
@@ -43,7 +45,7 @@ class InAppPurchaseView(View):
 
     def validation(self, request_dict, request, operation):
         if operation == 'AppStoreServerNotifications':  # App Store服务器通知
-            return self.app_store_server_notifications(request, request_dict)
+            return self.app_store_server_notifications(request)
         token_code, user_id, response = CommonService.verify_token_get_user_id(request_dict, request)
         if token_code != 0:
             return response.json(token_code)
@@ -61,15 +63,12 @@ class InAppPurchaseView(View):
         @return: response
         """
         receipt = request_dict.get('receipt', None)
-        transaction_identifier = request_dict.get('transactionIdentifier', "")
-        original_transaction_identifier = request_dict.get('originalTransactionIdentifier', "")
         order_id = request_dict.get('orderID', None)
         uid = request_dict.get('uid', None)
         lang = request_dict.get('lang', 'en')
         channel = request_dict.get('channel', None)
         logger = logging.getLogger('apple_pay')
-        logger.info(
-            f"transactionIdentifier:{transaction_identifier}, original_transaction_identifier:{original_transaction_identifier} ,订单orderId:{order_id}")
+        logger.info(f"receipt: {receipt}, 订单orderId: {order_id}, uid: {uid}")
 
         if not all([receipt, uid, channel, order_id]):
             return response.json(444)
@@ -79,8 +78,8 @@ class InAppPurchaseView(View):
         redis_key = order_id + 'in_app_purchase'
         is_lock = redis_obj.CONN.setnx(redis_key, 1)
         redis_obj.CONN.expire(redis_key, 60)
-        # if not is_lock:
-        #     return response.json(5)
+        if not is_lock:
+            return response.json(5)
 
         try:
             # 从交易信息中获取product_id
@@ -95,10 +94,10 @@ class InAppPurchaseView(View):
             environment = ENV
 
             client = AppStoreServerAPIClient(private_key, key_id, issuer_id, bundle_id, environment)
-            transaction_id = transaction_identifier
-            if transaction_identifier == "":
-                receipt_util = ReceiptUtility()
-                transaction_id = receipt_util.extract_transaction_id_from_app_receipt(receipt)
+            receipt_util = ReceiptUtility()
+
+            transaction_id = receipt_util.extract_transaction_id_from_app_receipt(receipt)
+            logger.info(f"订单orderId:{order_id}, transaction_id:{transaction_id}")
 
             if transaction_id is None:
                 pay_result_url = CommonService.get_payment_status_url(lang, 'fail')
@@ -108,36 +107,6 @@ class InAppPurchaseView(View):
 
             signed_transaction_info = transaction_info.signedTransactionInfo
 
-            if original_transaction_identifier != "":
-                device_apple_package_qs = DeviceApplePackage.objects.filter(
-                    original_transaction_id=original_transaction_identifier)
-                if device_apple_package_qs.exists():
-                    # 第一种情况: 套餐已过期再次订阅
-                    if device_apple_package_qs[0].uid == uid and device_apple_package_qs[0].subscription_status == 2:
-                        # 使用App Store服务器通知接口订阅
-                        pay_result_url = CommonService.get_payment_status_url(lang, 'success')
-                        return response.json(0, {'url': pay_result_url})
-
-                    # 第二种情况: 套餐未过期已取消再次订阅
-                    elif device_apple_package_qs[0].uid == uid and device_apple_package_qs[0].subscription_status == 3:
-                        # 使用App Store服务器通知接口修改订阅状态
-                        pay_result_url = CommonService.get_payment_status_url(lang, 'fail')
-                        return response.json(0, {'url': pay_result_url})
-
-                    # 第三种情况: 首次订阅
-                    elif device_apple_package_qs[0].uid == uid and device_apple_package_qs[0].subscription_status == 0:
-                        logger.info(f"首次订阅直接充值,orderID:{order_id}")
-
-                    else:
-                        logger.info(f"错误调用此借口,orderID:{order_id}, uid:{uid}, 订阅状态:{device_apple_package_qs[0].subscription_status}")
-                        pay_result_url = CommonService.get_payment_status_url(lang, 'fail')
-                        return response.json(0, {'url': pay_result_url})
-
-            # transaction_id相同的情况 ---- 本次订阅未过期，用户在苹果设置中将订阅重新打开时会传上次订阅相同的 transaction_id。
-            if Order_Model.objects.filter(payType=5, transaction_id=transaction_id).exists():
-                logger.info(f"该transaction_id已订阅过:{transaction_id}")
-                return response.json(10048)
-
             root_certificates = []
             for cert_name in [
                 'AppleIncRootCertificate.cer', 'AppleComputerRootCertificate.cer',
@@ -149,14 +118,13 @@ class InAppPurchaseView(View):
                     root_certificates.append(file.read())
 
             enable_online_checks = True
-            app_apple_id = None  # 生产环境必需
+            app_apple_id = 1355964934  # 生产环境必需
             signed_data_verifier = SignedDataVerifier(
                 root_certificates, enable_online_checks, environment, bundle_id, app_apple_id)
 
             payload = signed_data_verifier.verify_and_decode_signed_transaction(signed_transaction_info)
 
             product_id = None
-            original_transaction_id = ""
 
             if payload and payload.productId:
                 product_id = payload.productId
@@ -165,9 +133,6 @@ class InAppPurchaseView(View):
                 pay_result_url = CommonService.get_payment_status_url(lang, 'fail')
                 return response.json(0, {'url': pay_result_url})
 
-            if payload.rawType == "Auto-Renewable Subscription":
-                original_transaction_id = payload.originalTransactionId
-
             now_time = int(time.time())
             order_qs = Order_Model.objects.filter(orderID=order_id, UID=uid).values("rank_id")
             if not order_qs.exists():
@@ -219,21 +184,7 @@ class InAppPurchaseView(View):
                         uid=uid, channel=channel, detect_status=1, use_status=1, orders_id=order_id,
                         addTime=now_time, updTime=now_time, endTime=end_time)
 
-            # 修改订阅状态
-            if payload.rawType == "Auto-Renewable Subscription":
-                in_app_purchase_package_qs = InAppPurchasePackage.objects.filter(product_id=product_id)
-                if not in_app_purchase_package_qs.exists():
-                    return response.json(173, "内购套餐不存在")
-                in_app_purchase_package = in_app_purchase_package_qs.values('id').first()
-                package_id = in_app_purchase_package['id']
-                DeviceApplePackage.objects.filter(userID=user_id, uid=uid, package_id=package_id).update(
-                    subscription_status=1,
-                    original_transaction_id=original_transaction_id,
-                    update_time=int(time.time())
-                )
-            order_qs.update(status=1, uid_bucket_id=uid_bucket_id,
-                            transaction_id=transaction_id, create_vod=1,
-                            original_transaction_id=original_transaction_id)
+            order_qs.update(status=1, uid_bucket_id=uid_bucket_id, transaction_id=transaction_id, create_vod=1)
 
             # 发送云存开通信息
             date_time = time.strftime("%Y-%m-%d", time.localtime())
@@ -254,6 +205,7 @@ class InAppPurchaseView(View):
             redis_obj.del_data(redis_key)
             pay_result_url = CommonService.get_payment_status_url(lang, 'success')
             return response.json(0, {'url': pay_result_url})
+
         except Exception as e:
             redis_obj.del_data(redis_key)
             LOGGER.info('苹果内购认证交易接口异常:{}'.
@@ -324,387 +276,79 @@ class InAppPurchaseView(View):
         ali_sms.send_code_sms_cloud(phone=phone, params=params, sign_name=sign_ms, temp_msg=temp_msg)
 
     @classmethod
-    def app_store_server_notifications(cls, request, request_dict):
+    def app_store_server_notifications(cls, request):
         logger = logging.getLogger('apple_pay')
-        try:
-            logger.info('App Store服务器通知请求类型:{}'.format(request.method))
-            logger.info('App Store服务器通知参数:{}'.format(request.POST))
-            logger.info('App Store服务器通知请求body:{}'.format(request.body))
-            if request.method != 'POST':
-                logger.info(f'App Store服务器通知不是post请求, 参数{request_dict}')
-                return HttpResponse(status=400)
-
-            payload = json.loads(request.body.decode('utf-8'))
-            logger.info('App Store服务器通知payload:{}'.format(payload))
-            # 获取 signedPayload
-            signed_payload = payload.get('signedPayload')
-            if not signed_payload:
-                return HttpResponse(status=400)
-
-            bundle_id = 'com.ansjer.zccloud'
-            environment = ENV
-            root_certificates = []
-            for cert_name in [
-                'AppleIncRootCertificate.cer', 'AppleComputerRootCertificate.cer',
-                'AppleRootCA-G2.cer', 'AppleRootCA-G3.cer'
-            ]:
-                cert_path = '{}/Ansjer/file/in_app_purchase/{}'.format(BASE_DIR, cert_name)
-                with open(cert_path, 'rb') as file:
-                    # 读取文件内容
-                    root_certificates.append(file.read())
-
-            enable_online_checks = True
-            app_apple_id = None  # 生产环境必需
-
-            # 验证签名并解码 payload
-            verifier = SignedDataVerifier(
-                root_certificates, enable_online_checks, environment, bundle_id, app_apple_id)
-            decoded_payload = verifier.verify_and_decode_notification(signed_payload)
-
-            logger.info(f"App Store服务器通知解码后decoded_payload:{decoded_payload}")
-            logger.info(
-                f"App Store服务器通知decoded_payload.rawNotificationType{str(decoded_payload.rawNotificationType)}")
-            if str(decoded_payload.rawNotificationType) == "DID_RENEW":
-                decoded_transaction_information = verifier.verify_and_decode_signed_transaction(
-                    decoded_payload.data.signedTransactionInfo)
-
-                # originalTransactionId 原始购买的交易标识符
-                original_transaction_id = decoded_transaction_information.originalTransactionId
-                transaction_id = decoded_transaction_information.transactionId
-
-                logger.info(
-                    f"App Store服务器通知originalTransactionId原始购买的交易标识符{original_transaction_id}")
-                if not original_transaction_id:
-                    logger.info(f"App Store服务器通知originalTransactionId原始购买的交易标识符为空, 返回状态 400")
-                    return HttpResponse(status=400)
-                else:
-                    ord_order = Order_Model.objects.filter(original_transaction_id=original_transaction_id).order_by(
-                        '-addTime').values("channel", "UID", "payType", "userID_id", "rank_id")
-                    if not ord_order.exists():
-                        logger.info(f"App Store服务器通知未查询到旧订单信息, 返回状态 400")
-                        return HttpResponse(status=400)
-                    channel = ord_order[0]["channel"]
-                    uid = ord_order[0]["UID"]
-                    pay_type = ord_order[0]["payType"]
-                    user_id = ord_order[0]["userID_id"]
-
-                    store_qs = Store_Meal.objects.filter(id=ord_order[0]["rank_id"]). \
-                        values(
-                        'id', 'currency', 'price', 'lang__content', 'day', 'commodity_type', 'lang__title',
-                        'expire', 'lang__lang',
-                        'commodity_code', 'discount_price', 'bucket_id', 'bucket__mold', 'cycle_config_id', 'is_ai')
-                    if not store_qs.exists():
-                        logger.info(f"App Store服务器通知云存套餐不存在, 返回状态 400")
-                        return HttpResponse(status=400)
-
-                    order_id = CommonService.createOrderID()
-                    rank_id = store_qs[0]['id']
-                    bucket_id = store_qs[0]['bucket_id']
-                    currency = store_qs[0]['currency']
-                    price = store_qs[0]['price']
-                    is_ai = store_qs[0]['is_ai']
-                    expire = store_qs[0]['expire']
-                    end_time = CommonService.calcMonthLater(expire)
-                    content = store_qs[0]['lang__content']
-                    commodity_code = store_qs[0]['commodity_code']
-                    commodity_type = store_qs[0]['commodity_type']
-                    lang = store_qs[0]['lang__lang']
-                    order_type = 1 if is_ai else 0
-
-                    store_meal_qs = Store_Meal.objects.filter(id=rank_id, lang__lang='cn', is_show=0). \
-                        values('lang__title', 'lang__content')
-                    if store_meal_qs.exists():
-                        store_meal_name = store_meal_qs[0]['lang__title'] + '-' + store_meal_qs[0]['lang__content']
-                    else:
-                        store_meal_name = '未知套餐'
-
-                    # 查询设备是否已开过云存
-                    use_flag = True
-                    uid_bucket_qs = UID_Bucket.objects.filter(uid=uid). \
-                        values('id', 'bucket_id', 'bucket__region', 'endTime', 'use_status')
-                    now_time = int(time.time())
-                    if uid_bucket_qs.exists():
-                        uid_bucket = uid_bucket_qs.first()
-                        uid_bucket_id = uid_bucket['id']
-                        # 叠加相同套餐的过期时间
-                        if uid_bucket['use_status'] == 1 and uid_bucket['endTime'] > now_time:
-                            Unused_Uid_Meal.objects.create(
-                                uid=uid, channel=channel, addTime=now_time, order_id=order_id, expire=expire,
-                                is_ai=is_ai,
-                                bucket_id=bucket_id)
-                            UID_Bucket.objects.filter(id=uid_bucket_id).update(has_unused=1)
-                            use_flag = False
-                        # 更新套餐的过期时间
-                        else:
-                            UID_Bucket.objects.filter(id=uid_bucket_id).update(
-                                channel=channel, bucket_id=bucket_id, endTime=end_time, updateTime=now_time,
-                                use_status=1,
-                                orderId=order_id)
-                    else:
-                        uid_bucket = UID_Bucket.objects.create(
-                            uid=uid, channel=channel, bucket_id=bucket_id, endTime=end_time, use_status=1,
-                            orderId=order_id,
-                            addTime=now_time, updateTime=now_time)
-                        uid_bucket_id = uid_bucket.id
-
-                    # 开通AI服务
-                    if is_ai and use_flag:
-                        ai_service = AiService.objects.filter(uid=uid, channel=channel)
-                        # 有正在使用的套餐,叠加套餐时间,否则创建
-                        if ai_service.exists():
-                            ai_service.update(updTime=now_time, use_status=1, orders_id=order_id,
-                                              endTime=end_time)
-                        else:
-                            AiService.objects.create(
-                                uid=uid, channel=channel, detect_status=1, use_status=1, orders_id=order_id,
-                                addTime=now_time, updTime=now_time, endTime=end_time)
-
-                    Order_Model.objects.create(
-                        orderID=order_id, UID=uid, channel=channel, userID_id=user_id, desc=content,
-                        payType=pay_type,
-                        payTime=now_time, price=price, currency=currency, addTime=now_time, updTime=now_time,
-                        order_type=order_type, commodity_code=commodity_code, commodity_type=commodity_type,
-                        rank_id=rank_id,
-                        ai_rank_id=1, status=1, create_vod=1, store_meal_name=store_meal_name,
-                        uid_bucket_id=uid_bucket_id, transaction_id=transaction_id,
-                        original_transaction_id=original_transaction_id
-                    )
-
-                    # 发送云存开通信息
-                    date_time = time.strftime("%Y-%m-%d", time.localtime())
-                    # 如果存在序列号,消息提示用序列号
-                    device_info_qs = Device_Info.objects.filter(UID=uid).values('serial_number', 'Type')
-                    serial_number = device_info_qs[0]['serial_number']
-                    device_type = device_info_qs[0]['Type']
-                    if serial_number:
-                        device_name = CommonService.get_full_serial_number(uid, serial_number, device_type)
-                    else:
-                        device_name = uid
-                    sys_msg_text_list = [
-                        '温馨提示：尊敬的客户，您的{}设备在{}已成功续订云存套餐'.format(device_name, date_time),
-                        'Dear customer,you already subscribed the cloud storage package successfully for device {} on '.
-                        format(device_name, time.strftime('%b %dth,%Y', time.localtime()))]
-                    cls.do_vod_msg_notice(uid, user_id, lang, sys_msg_text_list)
-
-            elif str(decoded_payload.rawNotificationType) == "SUBSCRIBED":
-                # 处理订阅 ---> 首次充值逻辑写在了认证交易
-                if decoded_payload.rawSubtype == "RESUBSCRIBE":
-                    decoded_transaction_information = verifier.verify_and_decode_signed_transaction(
-                        decoded_payload.data.signedTransactionInfo)
-                    # originalTransactionId 原始购买的交易标识符
-                    original_transaction_id = decoded_transaction_information.originalTransactionId
-                    transaction_id = decoded_transaction_information.transactionId
-                    logger.info(
-                        f"App Store服务器通知originalTransactionId原始购买的交易标识符{original_transaction_id}")
-                    if not original_transaction_id:
-                        logger.info(f"App Store服务器通知originalTransactionId原始购买的交易标识符为空, 返回状态 400")
-                        return HttpResponse(status=400)
-                    else:
-                        ord_order = Order_Model.objects.filter(
-                            original_transaction_id=original_transaction_id).order_by('-addTime').values("channel",
-                                                                                                         "UID",
-                                                                                                         "payType",
-                                                                                                         "userID_id")
-                        channel = ord_order[0]["channel"]
-                        uid = ord_order[0]["UID"]
-                        pay_type = ord_order[0]["payType"]
-                        user_id = ord_order[0]["userID_id"]
-                        # 用产品id找到使用的套餐
-                        product_id = decoded_transaction_information.productId
-                        rank_id = InAppPurchasePackage.objects.filter(product_id=product_id).values("rank")[0]["rank"]
-                        store_qs = Store_Meal.objects.filter(id=rank_id). \
-                            values(
-                            'id', 'currency', 'price', 'lang__content', 'day', 'commodity_type', 'lang__title',
-                            'expire', 'lang__lang',
-                            'commodity_code', 'discount_price', 'bucket_id', 'bucket__mold', 'cycle_config_id', 'is_ai')
-                        if not store_qs.exists():
-                            logger.info(f"App Store服务器通知云存套餐不存在, 返回状态 400")
-                            return HttpResponse(status=400)
-
-                        order_id = CommonService.createOrderID()
-                        rank_id = store_qs[0]['id']
-                        bucket_id = store_qs[0]['bucket_id']
-                        currency = store_qs[0]['currency']
-                        price = store_qs[0]['price']
-                        is_ai = store_qs[0]['is_ai']
-                        expire = store_qs[0]['expire']
-                        end_time = CommonService.calcMonthLater(expire)
-                        content = store_qs[0]['lang__content']
-                        commodity_code = store_qs[0]['commodity_code']
-                        commodity_type = store_qs[0]['commodity_type']
-                        lang = store_qs[0]['lang__lang']
-                        order_type = 1 if is_ai else 0
-
-                        store_meal_qs = Store_Meal.objects.filter(id=rank_id, lang__lang='cn', is_show=0). \
-                            values('lang__title', 'lang__content')
-                        if store_meal_qs.exists():
-                            store_meal_name = store_meal_qs[0]['lang__title'] + '-' + store_meal_qs[0]['lang__content']
-                        else:
-                            store_meal_name = '未知套餐'
-
-                        # 查询设备是否已开过云存
-                        use_flag = True
-                        uid_bucket_qs = UID_Bucket.objects.filter(uid=uid). \
-                            values('id', 'bucket_id', 'bucket__region', 'endTime', 'use_status')
-                        now_time = int(time.time())
-                        if uid_bucket_qs.exists():
-                            uid_bucket = uid_bucket_qs.first()
-                            uid_bucket_id = uid_bucket['id']
-                            # 叠加相同套餐的过期时间
-                            if uid_bucket['use_status'] == 1 and uid_bucket['endTime'] > now_time:
-                                Unused_Uid_Meal.objects.create(
-                                    uid=uid, channel=channel, addTime=now_time, order_id=order_id, expire=expire,
-                                    is_ai=is_ai,
-                                    bucket_id=bucket_id)
-                                UID_Bucket.objects.filter(id=uid_bucket_id).update(has_unused=1)
-                                use_flag = False
-                            # 更新套餐的过期时间
-                            else:
-                                UID_Bucket.objects.filter(id=uid_bucket_id).update(
-                                    channel=channel, bucket_id=bucket_id, endTime=end_time, updateTime=now_time,
-                                    use_status=1,
-                                    orderId=order_id)
-                        else:
-                            uid_bucket = UID_Bucket.objects.create(
-                                uid=uid, channel=channel, bucket_id=bucket_id, endTime=end_time, use_status=1,
-                                orderId=order_id,
-                                addTime=now_time, updateTime=now_time)
-                            uid_bucket_id = uid_bucket.id
-
-                        # 开通AI服务
-                        if is_ai and use_flag:
-                            ai_service = AiService.objects.filter(uid=uid, channel=channel)
-                            # 有正在使用的套餐,叠加套餐时间,否则创建
-                            if ai_service.exists():
-                                ai_service.update(updTime=now_time, use_status=1, orders_id=order_id,
-                                                  endTime=end_time)
-                            else:
-                                AiService.objects.create(
-                                    uid=uid, channel=channel, detect_status=1, use_status=1, orders_id=order_id,
-                                    addTime=now_time, updTime=now_time, endTime=end_time)
-
-                        DeviceApplePackage.objects.filter(userID=user_id, uid=uid).update(subscription_status=1,
-                                                                                          update_time=int(time.time()))
-                        Order_Model.objects.create(
-                            orderID=order_id, UID=uid, channel=channel, userID_id=user_id, desc=content,
-                            payType=pay_type,
-                            payTime=now_time, price=price, currency=currency, addTime=now_time, updTime=now_time,
-                            order_type=order_type, commodity_code=commodity_code, commodity_type=commodity_type,
-                            rank_id=rank_id,
-                            ai_rank_id=1, status=1, create_vod=1, store_meal_name=store_meal_name,
-                            uid_bucket_id=uid_bucket_id, transaction_id=transaction_id,
-                            original_transaction_id=original_transaction_id
-                        )
-
-                        # 发送云存开通信息
-                        date_time = time.strftime("%Y-%m-%d", time.localtime())
-                        # 如果存在序列号,消息提示用序列号
-                        device_info_qs = Device_Info.objects.filter(UID=uid).values('serial_number', 'Type')
-                        serial_number = device_info_qs[0]['serial_number']
-                        device_type = device_info_qs[0]['Type']
-                        if serial_number:
-                            device_name = CommonService.get_full_serial_number(uid, serial_number, device_type)
-                        else:
-                            device_name = uid
-                        sys_msg_text_list = [
-                            '温馨提示：尊敬的客户，您的{}设备在{}已成功续订云存套餐'.format(device_name, date_time),
-                            'Dear customer,you already subscribed the cloud storage package successfully for device {} on '.
-                            format(device_name, time.strftime('%b %dth,%Y', time.localtime()))]
-                        cls.do_vod_msg_notice(uid, user_id, lang, sys_msg_text_list)
-
-            elif str(decoded_payload.rawNotificationType) == "EXPIRED":
-                # 一种通知类型，与其子类型一起表示订阅已过期。如果subtype为
-                # VOLUNTARY（自愿），则表示订阅在用户禁用订阅续订后过期。如果subtype是
-                # BILLING_RETRY（计费重试），则表示订阅过期，因为计费重试期结束时没有成功的计费交易。如果subtype为
-                # PRICE_INCREASE，则表示订阅已过期，因为客户不同意需要客户同意的价格上涨。如果subtype为
-                # PRODUCT_NOT_FOR_SALE，则表示订阅已过期，因为在订阅尝试续订时，产品已不可购买。
-                # 没有子类型的通知表示订阅因其他原因过期。
-                decoded_transaction_information = verifier.verify_and_decode_signed_transaction(
-                    decoded_payload.data.signedTransactionInfo)
-
-                # originalTransactionId 原始购买的交易标识符
-                original_transaction_id = decoded_transaction_information.originalTransactionId
-                if original_transaction_id:
-                    DeviceApplePackage.objects.filter(original_transaction_id=original_transaction_id).update(
-                        subscription_status=2, update_time=int(time.time()))
-
-            elif str(decoded_payload.rawNotificationType) == "CONSUMPTION_REQUEST":
-                # 一种通知类型，指示客户发起了消费型 App 内购买项目或自动续期订阅的退款请求，并且 App Store 要求您提供消费数据。有关详细信息，请参阅发送消耗信息。
-                pass
-
-            elif str(decoded_payload.rawNotificationType) == "DID_CHANGE_RENEWAL_STATUS":
-                if decoded_payload.rawSubtype == "AUTO_RENEW_DISABLED":
-                    # 自动续订被禁用
-                    decoded_transaction_information = verifier.verify_and_decode_signed_transaction(
-                        decoded_payload.data.signedTransactionInfo)
-                    original_transaction_id = decoded_transaction_information.originalTransactionId
-                    if original_transaction_id:
-                        DeviceApplePackage.objects.filter(original_transaction_id=original_transaction_id).update(
-                            subscription_status=3, update_time=int(time.time()))
-
-                elif decoded_payload.rawSubtype == "AUTO_RENEW_ENABLED":
-                    # 自动续订被开启
-                    decoded_transaction_information = verifier.verify_and_decode_signed_transaction(
-                        decoded_payload.data.signedTransactionInfo)
-                    original_transaction_id = decoded_transaction_information.originalTransactionId
-                    if original_transaction_id:
-                        DeviceApplePackage.objects.filter(original_transaction_id=original_transaction_id).update(
-                            subscription_status=1, update_time=int(time.time()))
-
-
-            elif str(decoded_payload.rawNotificationType) == "REFUND":
-                # 一种通知类型，表示 App Store 成功退还了消耗性应用内购买、非消耗性应用内购买、自动续订或不可续订的交易。
-                # revocationDate 包含退款交易的时间戳。originalTransactionId 和 productId 用于标识原始交易和产品。revocationReason 包含原因。
-                # 要请求客户所有退款交易的列表，请参阅 App Store 服务器 API 中的获取退款历史记录。
-                # 1. 找套餐 使用 transaction_id 找orders
-                decoded_transaction_information = verifier.verify_and_decode_signed_transaction(
-                    decoded_payload.data.signedTransactionInfo)
-                transaction_id = decoded_transaction_information.transactionId
-                logger.info('App Store服务器通知退款, transaction_id:{}'.format(transaction_id))
-                orders_qs = Order_Model.objects.filter(transaction_id=transaction_id)
-                # 2. 查找云存套餐使用表 和 云存套餐
-                if orders_qs.exists():
-                    orders_qs.update(status=11)
-                    orderID = orders_qs[0].orderID
-                    uid = orders_qs[0].UID
-                    user_id = orders_qs[0].userID
-                    # 3. 未使用则删除未使用套餐表，已使用过则删除设备正在使用套餐，并关闭设备云存
-                    uid_bucket_qs = UID_Bucket.objects.filter(uid=uid, orderId=orderID, use_status=1,
-                                                              endTime__gt=int(time.time()))
-                    unused_uid_meal_qs = Unused_Uid_Meal.objects.filter(order_id=orderID)
-                    ai_service_qs = AiService.objects.filter(uid=uid, orderId=orderID, use_status=1,
-                                                             endTime__gt=int(time.time()))
-                    if unused_uid_meal_qs.exists():
-                        unused_uid_meal_qs.delete()
-                    if uid_bucket_qs.exists():
-                        uid_bucket_qs.update(status=0, use_status=2, endTime=int(time.time()),
-                                             updateTime=int(time.time()))
-                    if ai_service_qs.exists():
-                        ai_service_qs.update(detect_status=0, use_status=2, endTime=int(time.time()),
-                                             updTime=int(time.time()))
-                        # 关闭ai
-                        msg = {'commandType': 'AIDisable'}
-                        thing_name = CommonService.query_serial_with_uid(uid)  # 存在序列号则为使用序列号作为物品名
-                        topic_name = 'ansjer/generic/{}'.format(thing_name)
-                        req_success = CommonService.req_publish_mqtt_msg(thing_name, topic_name, msg)
-                        LOGGER.info(f'App Store服务器通知用户退款, 关闭AI:{req_success}')
-
-                    # 4.发送邮件告知用户退款
-                    email_content = f'用户{user_id}, 订单:{orderID}, 设备{uid}退款'
-                else:
-                    email_content = f'transaction_id:{transaction_id}退款, 未查询到订单'
+        logger.info('App Store服务器通知请求类型:{}'.format(request.method))
+        logger.info('App Store服务器通知参数:{}'.format(request.POST))
+        logger.info('App Store服务器通知请求body:{}'.format(request.body))
+        payload = json.loads(request.body.decode('utf-8'))
+        logger.info('App Store服务器通知payload:{}'.format(payload))
+        # 获取 signedPayload
+        signed_payload = payload.get('signedPayload')
+        if not signed_payload:
+            return HttpResponse(status=400)
+
+        bundle_id = 'com.ansjer.zccloud'
+        environment = ENV
+        root_certificates = []
+        for cert_name in [
+            'AppleIncRootCertificate.cer', 'AppleComputerRootCertificate.cer',
+            'AppleRootCA-G2.cer', 'AppleRootCA-G3.cer'
+        ]:
+            cert_path = '{}/Ansjer/file/in_app_purchase/{}'.format(BASE_DIR, cert_name)
+            with open(cert_path, 'rb') as file:
+                # 读取文件内容
+                root_certificates.append(file.read())
+
+        enable_online_checks = True
+        app_apple_id = 1355964934  # 生产环境必需
+
+        # 验证签名并解码 payload
+        verifier = SignedDataVerifier(
+            root_certificates, enable_online_checks, environment, bundle_id, app_apple_id)
+        decoded_payload = verifier.verify_and_decode_notification(signed_payload)
+        logger.info('App Store服务器通知decoded_payload: {}'.format(decoded_payload))
+        status_code = 200
+        if str(decoded_payload.rawNotificationType) == "REFUND":
+            # 一种通知类型，表示 App Store 成功退还了消耗性应用内购买、非消耗性应用内购买、自动续订或不可续订的交易。
+            # revocationDate 包含退款交易的时间戳。originalTransactionId 和 productId 用于标识原始交易和产品。revocationReason 包含原因。
+            # 要请求客户所有退款交易的列表，请参阅 App Store 服务器 API 中的获取退款历史记录。
+            # 1. 找套餐 使用 transaction_id 找orders
+            decoded_transaction_information = verifier.verify_and_decode_signed_transaction(
+                decoded_payload.data.signedTransactionInfo)
+            transaction_id = decoded_transaction_information.transactionId
+            logger.info('App Store服务器通知退款, transaction_id:{}'.format(transaction_id))
+            orders_qs = Order_Model.objects.filter(transaction_id=transaction_id)
+            # 2. 查找云存套餐使用表 和 云存套餐
+            if orders_qs.exists():
+                orders_qs.update(status=11)
+                orderID = orders_qs[0].orderID
+                uid = orders_qs[0].UID
+                user_id = orders_qs[0].userID
+                # 3. 未使用则删除未使用套餐表，已使用过则删除设备正在使用套餐，并关闭设备云存
+                uid_bucket_qs = UID_Bucket.objects.filter(uid=uid, orderId=orderID, use_status=1, endTime__gt=int(time.time()))
+                unused_uid_meal_qs = Unused_Uid_Meal.objects.filter(order_id=orderID)
+                ai_service_qs = AiService.objects.filter(uid=uid, orderId=orderID, use_status=1, endTime__gt=int(time.time()))
+                if unused_uid_meal_qs.exists():
+                    unused_uid_meal_qs.delete()
+                if uid_bucket_qs.exists():
+                    uid_bucket_qs.update(status=0, use_status=2, endTime=int(time.time()), updateTime=int(time.time()))
+                if ai_service_qs.exists():
+                    ai_service_qs.update(detect_status=0, use_status=2, endTime=int(time.time()), updTime=int(time.time()))
+                    # 关闭ai
+                    msg = {'commandType': 'AIDisable'}
+                    thing_name = CommonService.query_serial_with_uid(uid)  # 存在序列号则为使用序列号作为物品名
+                    topic_name = 'ansjer/generic/{}'.format(thing_name)
+                    req_success = CommonService.req_publish_mqtt_msg(thing_name, topic_name, msg)
+                    LOGGER.info(f'App Store服务器通知用户退款, 关闭AI:{req_success}')
+
+                # 4.发送邮件告知用户退款
+                email_content = f'{CONFIG_INFO}用户{user_id}, 订单:{orderID}, 设备{uid}退款'
                 S3Email().faEmail(email_content, 'servers@ansjer.com')
-
-            elif str(decoded_payload.rawNotificationType) == "REFUND_DECLINED":
-                # 一种通知类型，表示 App Store 由于客户提出的争议而撤销了先前批准的退款。如果您的应用程序因相关退款而撤销了内容或服务，则需要恢复这些内容或服务。
-                # 此通知类型可适用于任何应用程序内购买类型：消耗品、非消耗品、不可续订订阅和自动续订订阅。对于自动续订，当 App Store 撤销退款时，续订日期保持不变。
-                pass
-
             else:
-                logger.info(f"App Store服务器通知decoded_payload.rawNotificationType 未处理")
-                return HttpResponse(status=500)
-            return HttpResponse(status=200)
-        except Exception as e:
-            logger.info('App Store服务器通知异常:{}'.
-                        format('error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e))))
-            return HttpResponse(status=500)
+                if CONFIG_INFO == CONFIG_US:
+                    url = "https://api.zositeche.com/inAppPurchase/AppStoreServerNotifications"
+                    eur_response = requests.post(url=url, json=json.loads(request.body))
+                    status_code = eur_response.status_code
+
+        return HttpResponse(status=status_code)