# @Author : Rocky # @File : InAppPurchaseController.py # @Time : 2024/6/21 9:10 import logging import time import json import threading import requests from appstoreserverlibrary.models.Environment import Environment from appstoreserverlibrary.api_client import AppStoreServerAPIClient, GetTransactionHistoryVersion from appstoreserverlibrary.models.AccountTenure import AccountTenure from appstoreserverlibrary.models.ConsumptionRequest import ConsumptionRequest from appstoreserverlibrary.models.ConsumptionStatus import ConsumptionStatus from appstoreserverlibrary.models.DeliveryStatus import DeliveryStatus from appstoreserverlibrary.models.Environment import Environment from appstoreserverlibrary.models.LifetimeDollarsPurchased import LifetimeDollarsPurchased from appstoreserverlibrary.models.LifetimeDollarsRefunded import LifetimeDollarsRefunded from appstoreserverlibrary.models.Platform import Platform from appstoreserverlibrary.models.PlayTime import PlayTime from appstoreserverlibrary.models.RefundPreference import RefundPreference from appstoreserverlibrary.models.UserStatus import UserStatus from appstoreserverlibrary.receipt_utility import ReceiptUtility 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, 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, InAppRefund, OrderPayLog from Object.AWS.S3Email import S3Email from Object.AliSmsObject import AliSmsObject from Object.AppleInAppPurchaseSubscriptionObject import InAppPurchase from Object.RedisObject import RedisObject from Service.CommonService import CommonService ENV = Environment.SANDBOX if CONFIG_INFO == CONFIG_TEST else Environment.PRODUCTION logger = logging.getLogger('apple_pay') class InAppPurchaseView(View): def get(self, request, *args, **kwargs): request.encoding = 'utf-8' operation = kwargs.get('operation') return self.validation(request.GET, request, operation) def post(self, request, *args, **kwargs): request.encoding = 'utf-8' operation = kwargs.get('operation') return self.validation(request.POST, request, operation) def validation(self, request_dict, request, operation): if operation == 'AppStoreServerNotifications': # App Store服务器通知（用于转发通知） return self.app_store_server_notifications(request, request_dict) elif operation == 'AppStoreServerNotificationsVsees': # App Store服务器通知（用于转发通知） return self.app_store_server_notifications_vsees(request, request_dict) elif operation == 'vseesNotifications': return self.vsees_notifications(request) elif operation == 'serverNotifications': # App Store服务器通知 return self.server_notifications(request) elif operation == 'putRefundOrder': # App Store服务器通知 return self.put_refund_order() token_code, user_id, response = CommonService.verify_token_get_user_id(request_dict, request) if token_code != 0: return response.json(token_code) if operation == 'verifyTransaction': # 认证交易 return self.verify_transaction(user_id, request_dict, response) @classmethod def verify_transaction(cls, user_id, request_dict, response): """ 认证交易 @param user_id: 用户id @param request_dict: 请求参数 @request_dict receipt: 收据 @param response: 响应对象 @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) app_type = request_dict.get('app_type', 1) logger.info( f"苹果内购认证交易订单orderID:{order_id}," f"transaction_id: {transaction_identifier}," f"original_transaction_id: {original_transaction_identifier}," f"receipt: {receipt}") if not all([uid, channel, order_id]): return response.json(444) # redis加锁，防止订单重复 redis_obj = RedisObject() redis_key = order_id + 'in_app_purchase' is_lock = redis_obj.CONN.setnx(redis_key, 1) if not is_lock: return response.json(5) redis_obj.CONN.expire(redis_key, 60) try: # 检查商品id是否正确 app_type = int(app_type) if app_type == 1: bundle_id = "com.ansjer.zccloud" elif app_type == 2: bundle_id = "com.cloudlife.commissionf" else: return response.json(444, "app_type不存在") # 验证订单是否存在 order_qs = Order_Model.objects.filter(orderID=order_id, UID=uid, app_type=app_type).values("rank_id") if not order_qs.exists(): return response.json(173) if order_qs["transaction_id"]: return response.json(0) if UID_Bucket.objects.filter(orderId=order_id).exists(): return response.json(0) if Unused_Uid_Meal.objects.filter(order_id=order_id).exists(): return response.json(0) # 实例化订阅类 in_app_purchase = InAppPurchase(bundle_id=bundle_id) # ReceiptUtility 用于解析收据为transaction_id receipt_util = in_app_purchase.receipt_util # AppStoreServerAPIClient 用于查询交易信息 client = in_app_purchase.client # SignedDataVerifier 用于解析查询到的交易信息 signed_data_verifier = in_app_purchase.verifier # 解析收据(循环扣款时不需要这一步, 直接获取transaction_id) transaction_id = transaction_identifier if transaction_identifier == "": transaction_id = receipt_util.extract_transaction_id_from_app_receipt(receipt) if not transaction_id: logger.info(f"苹果内购认证交易订单orderID:{order_id}, 没有transaction_id") pay_result_url = CommonService.get_payment_status_url(lang, 'fail') return response.json(0, {'url': pay_result_url}) logger.info(f"苹果内购认证交易订单orderID:{order_id}, transaction_id:{transaction_id}, 时间戳: {int(time.time())}") OrderPayLog.objects.create(order_id=order_id, order_no=transaction_id, business_name=f"内购验单", created_time=int(time.time()), updated_time=int(time.time()), access_result="SUCCESS") # 查询交易信息 transaction_info = "" attempts = 0 while attempts < 6: try: transaction_info = client.get_transaction_info(transaction_id) break except ConnectionError as err: attempts += 1 if attempts == 5: OrderPayLog.objects.create(order_id=order_id, order_no=transaction_id, business_name=f"{order_id}获取transactionInfo超时", created_time=int(time.time()), updated_time=int(time.time()), access_result="ERROR") return response.json(5) logger.info( f"订单orderId:{order_id}, transaction_id:{transaction_id}, 第{attempts}次获取支付信息超时") signed_transaction_info = transaction_info.signedTransactionInfo # 解析交易信息 payload = signed_data_verifier.verify_and_decode_signed_transaction(signed_transaction_info) # 获取交易的商品id product_id = payload.productId if payload and payload.productId else None if not product_id: logger.info(f"苹果内购认证交易订单orderID:{order_id}, product_id获取失败") pay_result_url = CommonService.get_payment_status_url(lang, 'fail') return response.json(0, {'url': pay_result_url}) in_app_purchase_package_qs = InAppPurchasePackage.objects.filter(product_id=product_id) if not in_app_purchase_package_qs.exists(): logger.info(f"苹果内购认证交易订单orderID:{order_id}, InAppPurchasePackage表未查询到product_id") return response.json(173, "内购商品id不存在") # 验证套餐是否存在 store_qs = Store_Meal.objects.filter(id=order_qs[0]['rank_id']).values( 'id', 'currency', 'price', 'lang__content', 'day', 'commodity_type', 'lang__title', 'expire', 'commodity_code', 'discount_price', 'bucket_id', 'bucket__mold', 'cycle_config_id', 'is_ai') if not store_qs.exists(): return response.json(173, "云存套餐不存在") # 验证内购套餐是否存在 in_app_purchase_package_qs = InAppPurchasePackage.objects.filter(product_id=product_id) if not in_app_purchase_package_qs.exists(): return response.json(173, "内购套餐不存在") # 循环扣款 if original_transaction_identifier != "" and in_app_purchase_package_qs[0].package_type == 1: 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服务器通知接口订阅 Order_Model.objects.filter(orderID=order_id).delete() 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服务器通知接口修改订阅状态 Order_Model.objects.filter(orderID=order_id).delete() 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 == 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}) else: return response.json(173, "内购套餐未分配") # 设备开通云存 now_time = int(time.time()) uid_bucket_id = cls.enable_cloud(channel, now_time, order_id, store_qs, uid) # 修改订阅状态 if payload.rawType == "Auto-Renewable Subscription": original_transaction_id = payload.originalTransactionId 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, ) order_qs.update(status=1, uid_bucket_id=uid_bucket_id, transaction_id=transaction_id, create_vod=1, payTime=now_time, updTime=now_time, original_transaction_id=original_transaction_id) else: order_qs.update(status=1, uid_bucket_id=uid_bucket_id, transaction_id=transaction_id, create_vod=1, payTime=now_time, updTime=now_time) # 构建云存套餐消息 sys_msg_text_list = cls.cloud_storage_message(uid) # 发送云存套餐购买消息 asy = threading.Thread(target=cls.do_vod_msg_notice, args=(uid, user_id, lang, sys_msg_text_list)) asy.start() redis_obj.del_data(redis_key) pay_result_url = CommonService.get_payment_status_url(lang, 'success') OrderPayLog.objects.create(order_id=order_id, order_no=transaction_id, business_name=f"内购充值成功", created_time=int(time.time()), updated_time=int(time.time()), access_result="SUCCESS") return response.json(0, {'url': pay_result_url}) except Exception as e: redis_obj.del_data(redis_key) LOGGER.info('苹果内购认证交易接口异常:{}'. format('error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))) pay_result_url = CommonService.get_payment_status_url(lang, 'fail') return response.json(0, {'url': pay_result_url}) @classmethod def cloud_storage_message(cls, uid): # 发送云存开通信息 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()))] return sys_msg_text_list @classmethod def enable_cloud(cls, channel, now_time, order_id, store_qs, uid): bucket_id = store_qs[0]['bucket_id'] is_ai = store_qs[0]['is_ai'] expire = store_qs[0]['expire'] end_time = CommonService.calcMonthLater(expire) # 查询设备是否已开过云存 use_flag = True uid_bucket_qs = UID_Bucket.objects.filter(uid=uid). \ values('id', 'bucket_id', 'bucket__region', 'endTime', 'use_status') 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) return uid_bucket_id @classmethod def do_vod_msg_notice(cls, uid, user_id, lang, sys_msg_text_list): """ 发送云存开通信息 @param uid: uid @param user_id: 用户id @param lang: 语言 @param sys_msg_text_list: 消息列表 @return: response """ if lang == 'cn': sys_msg_text = sys_msg_text_list[0] else: sys_msg_text = sys_msg_text_list[1] now_time = int(time.time()) create_data = { 'userID_id': user_id, 'msg': sys_msg_text, 'addTime': now_time, 'updTime': now_time, 'uid': uid, 'eventType': 0 } SysMsgModel.objects.create(**create_data) # 不接收邮件用户 if user_id == '167015836969813800138000': return user_qs = Device_User.objects.filter(userID=user_id) if user_qs.exists(): user = user_qs.first() username = user.username data_valid = DataValid() if data_valid.email_validate(username): S3Email().faEmail(sys_msg_text, username) elif data_valid.mobile_validate(username): # 如果存在序列号,消息提示用序列号 device_info_qs = Device_Info.objects.filter(UID=uid).values('serial_number', 'Type') if device_info_qs.exists(): 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 params = '{"devname":"%s","submittime":"%s"}' % ( device_name, time.strftime("%Y-%m-%d", time.localtime())) cls.send_message(username, params, 'SMS_219738485') @staticmethod def send_message(phone, params, temp_msg): """ 发送手机消息 @param phone: 用户名 @param params: 消息参数 @param temp_msg: sms码 """ sign_ms = '周视' ali_sms = AliSmsObject() 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): logger = logging.getLogger('apple_pay') if request.method != 'POST': logger.info(f'App Store服务器通知不是post请求, 参数{request_dict}') return HttpResponse(status=400) try: request_data = json.loads(request.body) except json.JSONDecodeError: logger.info('无法解析请求体为JSON') return HttpResponse(status=400) request_data['bundleId'] = 'com.ansjer.zccloud' updated_request_body = json.dumps(request_data) if CONFIG_INFO == CONFIG_TEST: logger.info('测试环境, App Store服务器通知发送到测试服') response_test = requests.post(url="https://test.zositechc.cn/inAppPurchase/serverNotifications", json=updated_request_body) return HttpResponse(status=response_test.status_code) response_us = requests.post(url="https://www.dvema.com/inAppPurchase/serverNotifications", json=updated_request_body) status_code = response_us.status_code if status_code != 200: response_eu = requests.post(url="https://api.zositeche.com/inAppPurchase/serverNotifications", json=updated_request_body) status_code = response_eu.status_code if status_code == 200: return HttpResponse(status=200) return HttpResponse(status=400) @classmethod def server_notifications(cls, request): try: 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(json.loads(request.body)) logger.info('App Store服务器通知payload:{}'.format(payload)) # 获取 signedPayload signed_payload = payload.get('signedPayload') bundle_id = payload.get('bundleId') if not signed_payload: return HttpResponse(status=400) if bundle_id == "com.ansjer.zccloud": app_type = 1 else: app_type = 2 in_app_purchase_obj = InAppPurchase(bundle_id=bundle_id) # AppStoreServerAPIClient 用于查询交易信息 client = in_app_purchase_obj.client # SignedDataVerifier 用于解析查询到的交易信息 signed_data_verifier = in_app_purchase_obj.verifier # 验证签名并解码 payload decoded_payload = signed_data_verifier.verify_and_decode_notification(signed_payload) logger.info(f"App Store服务器通知解码后decoded_payload:{decoded_payload}") raw_notification_type = str(decoded_payload.rawNotificationType) raw_subtype = str(decoded_payload.rawSubtype) logger.info(f"App Store服务器通知, 大类型{raw_notification_type}, 小类型{raw_subtype}") if str(decoded_payload.rawNotificationType) == "DID_RENEW": # 续订 decoded_transaction_information = signed_data_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) 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服务器通知, 未查询到旧订单信息, originalTransactionId:{original_transaction_id}, 返回状态 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) # 解决云存充值成功, 由于一些原因返回500 导致苹果未扣款的问题 if Order_Model.objects.filter(transaction_id=transaction_id, status=1).exists(): logger.info(f"App Store服务器通知云存续订订单已存在, transactionId:{transaction_id} 返回状态 200") return HttpResponse(status=200) order_id = CommonService.createOrderID() rank_id = store_qs[0]['id'] currency = store_qs[0]['currency'] price = store_qs[0]['price'] is_ai = store_qs[0]['is_ai'] 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 now_time = int(time.time()) 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 = '未知套餐' # 创建订单 order = 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, store_meal_name=store_meal_name, app_type=app_type ) # 充值云存套餐 uid_bucket_id = cls.enable_cloud(channel, now_time, order_id, store_qs, uid) # 修改订单信息 order.uid_bucket_id = uid_bucket_id order.transaction_id = transaction_id order.original_transaction_id = original_transaction_id order.save() # 构建云存套餐消息 sys_msg_text_list = cls.cloud_storage_message(uid) cls.do_vod_msg_notice(uid, user_id, lang, sys_msg_text_list) return HttpResponse(status=200) elif str(decoded_payload.rawNotificationType) == "SUBSCRIBED": # 处理订阅 ---> 首次充值逻辑写在了认证交易 if decoded_payload.rawSubtype == "RESUBSCRIBE": decoded_transaction_information = signed_data_verifier.verify_and_decode_signed_transaction( decoded_payload.data.signedTransactionInfo) # originalTransactionId 原始购买的交易标识符 original_transaction_id = decoded_transaction_information.originalTransactionId transaction_id = decoded_transaction_information.transactionId app_account_token = decoded_transaction_information.appAccountToken app_account_token = json.loads(app_account_token) 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) # 查旧订单消息 ord_order_qs = Order_Model.objects.filter(original_transaction_id=original_transaction_id) if not ord_order_qs.exists(): logger.info(f"App Store服务器通知未查询到旧订单信息, originalTransactionId:{original_transaction_id}, 返回状态 400") return HttpResponse(status=400) # 解决云存充值成功, 由于一些原因返回500 导致苹果未扣款的问题 if Order_Model.objects.filter(transaction_id=transaction_id, status=1).exists(): logger.info( f"App Store服务器通知云存续订订单已存在, transactionId:{transaction_id} 返回状态 200") return HttpResponse(status=200) ord_order = ord_order_qs.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"] new_user_id = app_account_token["user_id"] if new_user_id != user_id: uid = app_account_token["UID"] user_id = new_user_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'] currency = store_qs[0]['currency'] price = store_qs[0]['price'] is_ai = store_qs[0]['is_ai'] 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 now_time = int(time.time()) 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 = '未知套餐' order = 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, store_meal_name=store_meal_name, app_type=app_type ) # 充值云存套餐 uid_bucket_id = cls.enable_cloud(channel, now_time, order_id, store_qs, uid) # 修改订单信息 order.uid_bucket_id = uid_bucket_id order.transaction_id = transaction_id order.original_transaction_id = original_transaction_id order.save() DeviceApplePackage.objects.filter(userID=user_id, uid=uid).update(subscription_status=1, update_time=int(time.time())) # 构建云存套餐消息 sys_msg_text_list = cls.cloud_storage_message(uid) cls.do_vod_msg_notice(uid, user_id, lang, sys_msg_text_list) return HttpResponse(status=200) elif str(decoded_payload.rawNotificationType) == "EXPIRED": # 一种通知类型，与其子类型一起表示订阅已过期。如果subtype为 # VOLUNTARY（自愿），则表示订阅在用户禁用订阅续订后过期。如果subtype是 # BILLING_RETRY（计费重试），则表示订阅过期，因为计费重试期结束时没有成功的计费交易。如果subtype为 # PRICE_INCREASE，则表示订阅已过期，因为客户不同意需要客户同意的价格上涨。如果subtype为 # PRODUCT_NOT_FOR_SALE，则表示订阅已过期，因为在订阅尝试续订时，产品已不可购买。 # 没有子类型的通知表示订阅因其他原因过期。 decoded_transaction_information = signed_data_verifier.verify_and_decode_signed_transaction( decoded_payload.data.signedTransactionInfo) # originalTransactionId 原始购买的交易标识符 original_transaction_id = decoded_transaction_information.originalTransactionId if not original_transaction_id: logger.info(f"App Store服务器通知 originalTransactionId原始购买的交易标识符为空, 返回状态 400") return HttpResponse(status=400) device_apple_package_qs = DeviceApplePackage.objects.filter( original_transaction_id=original_transaction_id) if not device_apple_package_qs.exists(): return HttpResponse(status=400) device_apple_package_qs.update(subscription_status=2, update_time=int(time.time())) elif str(decoded_payload.rawNotificationType) == "CONSUMPTION_REQUEST": # 一种通知类型，指示客户发起了消费型 App 内购买项目或自动续期订阅的退款请求，并且 App Store 要求您提供消费数据。有关详细信息，请参阅发送消耗信息。 decoded_transaction_information = signed_data_verifier.verify_and_decode_signed_transaction( decoded_payload.data.signedTransactionInfo) transaction_id = decoded_transaction_information.transactionId app_account_token = decoded_transaction_information.appAccountToken if not app_account_token: app_account_token = "" orders_qs = Order_Model.objects.filter(transaction_id=transaction_id) if not orders_qs.exists(): return HttpResponse(status=400) orderID = orders_qs[0].orderID uid = orders_qs[0].UID now_time = int(time.time()) put_time = now_time + 11.5 * 60 * 60 in_app_refund_qs = InAppRefund.objects.filter(transaction_id=transaction_id) if in_app_refund_qs.exists(): in_app_refund_qs.update(refund_progress=0, updated_time=now_time, put_time=put_time, app_account_token=app_account_token) InAppRefund.objects.create(transaction_id=transaction_id, orderID=orderID, uid=uid, app_type=app_type, created_time=now_time, updated_time=now_time, put_time=put_time, app_account_token=app_account_token) return HttpResponse(status=200) elif str(decoded_payload.rawNotificationType) == "DID_CHANGE_RENEWAL_STATUS": decoded_transaction_information = signed_data_verifier.verify_and_decode_signed_transaction( decoded_payload.data.signedTransactionInfo) original_transaction_id = decoded_transaction_information.originalTransactionId if not original_transaction_id: logger.info(f"App Store服务器通知 originalTransactionId原始购买的交易标识符为空, 返回状态 400") return HttpResponse(status=400) if decoded_payload.rawSubtype == "AUTO_RENEW_ENABLED": # 自动续订被开启 device_apple_package_qs = DeviceApplePackage.objects.filter( original_transaction_id=original_transaction_id) if not device_apple_package_qs.exists(): return HttpResponse(status=400) device_apple_package_qs.update(subscription_status=1, update_time=int(time.time())) else: # 自动续订被禁用 device_apple_package_qs = DeviceApplePackage.objects.filter( original_transaction_id=original_transaction_id) if not device_apple_package_qs.exists(): return HttpResponse(status=400) device_apple_package_qs.update(subscription_status=3, update_time=int(time.time())) elif str(decoded_payload.rawNotificationType) == "REFUND": # 一种通知类型，表示 App Store 成功退还了消耗性应用内购买、非消耗性应用内购买、自动续订或不可续订的交易。 # revocationDate 包含退款交易的时间戳。originalTransactionId 和 productId 用于标识原始交易和产品。revocationReason 包含原因。 # 要请求客户所有退款交易的列表，请参阅 App Store 服务器 API 中的获取退款历史记录。 decoded_transaction_information = signed_data_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) if not orders_qs.exists(): return HttpResponse(status=400) orders_qs.update(status=5, updTime=int(time.time())) orderID = orders_qs[0].orderID uid = orders_qs[0].UID 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, orders=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}') InAppRefund.objects.filter(transaction_id=transaction_id).update(updated_time=int(time.time()), refund_progress=2) return HttpResponse(status=200) elif str(decoded_payload.rawNotificationType) == "REFUND_DECLINED": # 一种通知类型，表示 App Store 由于客户提出的争议而撤销了先前批准的退款。如果您的应用程序因相关退款而撤销了内容或服务，则需要恢复这些内容或服务。 # 此通知类型可适用于任何应用程序内购买类型：消耗品、非消耗品、不可续订订阅和自动续订订阅。对于自动续订，当 App Store 撤销退款时，续订日期保持不变。 decoded_transaction_information = signed_data_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)) elif str(decoded_payload.rawNotificationType) == "REFUND_DECLINED": decoded_transaction_information = signed_data_verifier.verify_and_decode_signed_transaction( decoded_payload.data.signedTransactionInfo) transaction_id = decoded_transaction_information.transactionId orders_qs = Order_Model.objects.filter(transaction_id=transaction_id) if not orders_qs.exists(): return HttpResponse(status=400) InAppRefund.objects.filter(transaction_id=transaction_id).update(refund_progress=3) else: logger.info(f"App Store服务器通知decoded_payload.rawNotificationType 未处理") 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) @classmethod def app_store_server_notifications_vsees(cls, request, request_dict): logger = logging.getLogger('apple_pay') if request.method != 'POST': logger.info(f'App Store服务器通知不是post请求, 参数{request_dict}') return HttpResponse(status=400) try: request_data = json.loads(request.body) except json.JSONDecodeError: logger.error('无法解析请求体为JSON') return HttpResponse(status=400) request_data['bundleId'] = 'com.ansjer.zccloud' updated_request_body = json.dumps(request_data) if CONFIG_INFO == CONFIG_TEST: logger.info('测试环境, App Store服务器通知发送到测试服') response_test = requests.post(url="https://test.zositechc.cn/inAppPurchase/serverNotifications", json=updated_request_body) return HttpResponse(status=response_test.status_code) response_us = requests.post(url="https://www.dvema.com/inAppPurchase/serverNotifications", json=updated_request_body) status_code = response_us.status_code if status_code != 200: response_eu = requests.post(url="https://api.zositeche.com/inAppPurchase/serverNotifications", json=updated_request_body) status_code = response_eu.status_code if status_code == 200: return HttpResponse(status=200) return HttpResponse(status=400) @classmethod def vsees_notifications(cls, request): logger = logging.getLogger('apple_pay') logger.info('Vsees: App Store服务器通知请求类型:{}'.format(request.method)) logger.info('Vsees: App Store服务器通知参数:{}'.format(request.POST)) logger.info('Vsees: App Store服务器通知请求body:{}'.format(request.body)) payload = json.loads(request.body.decode('utf-8')) logger.info('Vsees: App Store服务器通知payload:{}'.format(payload)) # 获取 signedPayload signed_payload = payload.get('signedPayload') if not signed_payload: return HttpResponse(status=400) in_app_purchase = InAppPurchase(bundle_id="com.cloudlife.commissionf") # SignedDataVerifier 用于解析查询到的交易信息 verifier = in_app_purchase.verifier decoded_payload = verifier.verify_and_decode_notification(signed_payload) logger.info('Vsees: 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('Vsees: 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') else: 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) @staticmethod def put_refund_order(): put_time = int(time.time()) in_app_refund_qs = InAppRefund.objects.filter(refund_progress=0, put_time__lt=put_time) for in_app_refund in in_app_refund_qs: transaction_id = in_app_refund.transaction_id app_type = in_app_refund.app_type if app_type == 1: bundle_id = "com.ansjer.zccloud" elif app_type == 2: bundle_id = "com.cloudlife.commissionf" else: return HttpResponse(status=200) in_app_purchase_obj = InAppPurchase(bundle_id=bundle_id) # AppStoreServerAPIClient 用于查询交易信息 client = in_app_purchase_obj.client orderID = in_app_refund.orderID app_account_token = in_app_refund.app_account_token unused_uid_meal_qs = Unused_Uid_Meal.objects.filter(order_id=orderID) uid_bucket_qs = UID_Bucket.objects.filter(orderId=orderID, endTime__gt=int(time.time())) if unused_uid_meal_qs.exists(): consumptionStatus = ConsumptionStatus.NOT_CONSUMED deliveryStatus = DeliveryStatus.DELIVERED_AND_WORKING_PROPERLY elif uid_bucket_qs.exists(): consumptionStatus = ConsumptionStatus.PARTIALLY_CONSUMED deliveryStatus = DeliveryStatus.DELIVERED_AND_WORKING_PROPERLY elif UID_Bucket.objects.filter(orderId=orderID, endTime__lt=int(time.time())): consumptionStatus = ConsumptionStatus.FULLY_CONSUMED deliveryStatus = DeliveryStatus.DELIVERED_AND_WORKING_PROPERLY else: consumptionStatus = ConsumptionStatus.UNDECLARED deliveryStatus = DeliveryStatus.DID_NOT_DELIVER_FOR_OTHER_REASON if in_app_refund.refund_preference == 1: refundPreference = RefundPreference.PREFER_GRANT else: refundPreference = RefundPreference.PREFER_DECLINE consumption_request = ConsumptionRequest( customerConsented=True, consumptionStatus=consumptionStatus, platform=Platform.UNDECLARED, sampleContentProvided=True, deliveryStatus=deliveryStatus, appAccountToken=app_account_token, accountTenure=AccountTenure.UNDECLARED, playTime=PlayTime.UNDECLARED, lifetimeDollarsRefunded=LifetimeDollarsRefunded.UNDECLARED, lifetimeDollarsPurchased=LifetimeDollarsPurchased.UNDECLARED, userStatus=UserStatus.ACTIVE, refundPreference=refundPreference, ) client.send_consumption_data(transaction_id, consumption_request) logger.info(f'内购退款消费数据提交, 订单orderID:{orderID}, transaction_id:{transaction_id}') in_app_refund.refund_progress = 1 in_app_refund.save() return HttpResponse(status=200)