微信每日对账

AdminController/DeviceManagementController.py

@@ -275,6 +275,7 @@ class DeviceManagement(View):
                 LogModel.objects.create(**log)
                 # 删除和更新设备云存相关数据
                 UID_Bucket.objects.filter(uid=uid).delete()
+                AiService.objects.filter(uid=uid).delete()
                 Unused_Uid_Meal.objects.filter(uid=uid).delete()
                 Order_Model.objects.filter(UID=uid, order_type=0).delete()
                 StsCrdModel.objects.filter(uid=uid).delete()
@@ -428,6 +429,7 @@ class DeviceManagement(View):
                     Order_Model.objects.filter(UID__in=uidList, order_type=1).delete()
                 if '设备云存数据' in delDataOptions:
                     UID_Bucket.objects.filter(uid__in=uidList).delete()
+                    AiService.objects.filter(uid__in=uidList).delete()
                     StsCrdModel.objects.filter(uid__in=uidList).delete()
                     VodHlsModel.objects.filter(uid__in=uidList).delete()
                     # 删除vod_hls分表数据

AdminController/ServeManagementController.py

@@ -307,6 +307,8 @@ class serveManagement(View):
                 'currency',
                 'symbol',
                 'is_show',
+                'is_ai',
+                'pixel_level',
                 'add_time',
                 'update_time')
             total = len(store_meal_val)
@@ -333,6 +335,8 @@ class serveManagement(View):
                     'currency': store_meal['currency'],
                     'symbol': store_meal['symbol'],
                     'is_show': store_meal['is_show'],
+                    'is_ai': store_meal['is_ai'],
+                    'pixel_level': store_meal['pixel_level'],
                     'addTime': store_meal['add_time'].strftime("%Y-%m-%d %H:%M:%S"),
                     'updTime': store_meal['update_time'].strftime("%Y-%m-%d %H:%M:%S"),
                 })
@@ -362,6 +366,8 @@ class serveManagement(View):
         currency = request_dict.get('currency', '')
         symbol = request_dict.get('symbol', '')
         is_show = int(request_dict.get('is_show', 0))
+        is_ai = int(request_dict.get('is_ai', 0))
+        pixel_level = int(request_dict.get('pixel_level', 0))
         isEdit = request_dict.get('isEdit', None)
 
         if not all([bucket, pay_type, price, currency, symbol]):
@@ -383,6 +389,8 @@ class serveManagement(View):
                 'currency': currency,
                 'symbol': symbol,
                 'is_show': is_show,
+                'is_ai': is_ai,
+                'pixel_level': pixel_level,
             }
             if isEdit:
                 if not storeMealID:
@@ -605,7 +613,8 @@ class serveManagement(View):
             store_meal_list = []
             for item in store_meal:
                 pixel_content = '4k像素' if item['pixel_level'] == 1 else '4k像素以下'
-                store_meal_list.append({'id': item['id'], 'title': item['lang__title'] + '--' + item['lang__content'] + '(' + pixel_content + ')'})
+                store_meal_list.append({'id': item['id'], 'title': item['lang__title'] + '--' + item[
+                    'lang__content'] + '(' + pixel_content + ')'})
             return response.json(0, store_meal_list)
         except Exception as e:
             return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
@@ -1193,11 +1202,11 @@ class serveManagement(View):
                                 'UID', 'price', 'payType', 'userID__username', 'userID__phone',
                                 'userID__userEmail', 'userID__data_joined', 'agreement_id'):
                     # 套餐到期时间累加未使用套餐
-                    unused_qs = Unused_Uid_Meal.objects.filter(uid=uid_bucket.uid).values('num', 'expire')
+                    unused_qs = Unused_Uid_Meal.objects.filter(uid=uid_bucket.uid).values('expire')
                     if unused_qs.exists():
                         addMonth = 0
                         for unused in unused_qs:
-                            addMonth += unused['num'] * unused['expire']
+                            addMonth += unused['expire']
                         endTime = CommonService.calcMonthLater(addMonth, uid_bucket.endTime)
                         endTime = time.strftime("%Y--%m--%d %H:%M:%S", time.localtime(endTime))
                     else:

Controller/CloudStorage.py

@@ -21,13 +21,13 @@ from django.http import JsonResponse, HttpResponseRedirect, HttpResponse
 from django.views.generic.base import View
 
 from Ansjer.config import SERVER_DOMAIN, PAYPAL_CRD, SERVER_DOMAIN_SSL, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, \
-    AWS_ARN, OAUTH_ACCESS_TOKEN_SECRET
+    AWS_ARN, OAUTH_ACCESS_TOKEN_SECRET, DETECT_PUSH_DOMAINS, CONFIG_INFO, CONFIG_CN
 from Controller.CheckUserData import DataValid
 from Controller.CloudPhoto.CloudServiceController import CloudServiceController
 from Controller.PaymentCycle import Paypal
 from Model.models import Device_Info, Order_Model, Store_Meal, VodHlsModel, UID_Bucket, StsCrdModel, \
     ExperienceContextModel, Pay_Type, CDKcontextModel, Device_User, SysMsgModel, Unused_Uid_Meal, PromotionRuleModel, \
-    VideoPlaybackTimeModel, CouponModel, VodBucketModel, VodHlsSummary, VodHlsTagType, UidSetModel
+    VideoPlaybackTimeModel, CouponModel, VodBucketModel, VodHlsSummary, VodHlsTagType, UidSetModel, AiService
 from Object.AWS.AmazonS3Util import AmazonS3Util
 from Object.AWS.S3Email import S3Email
 from Object.AliPayObject import AliPayObject
@@ -180,21 +180,21 @@ class CloudStorageView(View):
         mold = request_dict.get('mold', None)
         uid = request_dict.get('uid', None)
         lang = request_dict.get('lang', 'en')
+        is_ai = request_dict.get('is_ai', 0)
         if not all([uid]):
             return response.json(444)
+        is_ai = int(is_ai)
         now_time = int(time.time())
         # DVR/NVR设备暂不返回云存套餐列表
         device_info_qs = Device_Info.objects.filter(Q(UID=uid), Q(Type__lte=4) | Q(Type=10001))
         if device_info_qs.exists():
             return response.json(0)
         # 查询设备像素
-        uid_set_qs = UidSetModel.objects.filter(uid=uid).values('ucode')
+        uid_set_qs = UidSetModel.objects.filter(uid=uid).values('ucode', 'is_ai')
         if not uid_set_qs.exists():
             return response.json(173)
         ucode = uid_set_qs[0]['ucode']
-        pixel_level = 0
-        if ucode and int(ucode[-5]) >= 8:
-            pixel_level = 1
+        pixel_level = 1 if ucode and int(ucode[-5]) >= 8 else 0
         store_qs = Store_Meal.objects.filter(Q(lang__lang=lang), Q(is_show=0), ~Q(pay_type='11'))  # 过滤激活码、隐藏套餐
         experience_context_qs = ExperienceContextModel.objects.filter(uid=uid, experience_type=0)
 
@@ -203,7 +203,14 @@ class CloudStorageView(View):
 
         # 没体验过的设备只返回体验套餐,体验过的不返回体验套餐
         if experience_context_qs.exists():
-            store_qs = store_qs.filter(~Q(pay_type='10'), Q(pixel_level=pixel_level))  # 筛选像素等级
+            if not is_ai:  # 返回云存套餐
+                store_qs = store_qs.filter(~Q(pay_type='10'), Q(pixel_level=pixel_level), Q(is_ai=0))  # 筛选像素等级
+            else:          # 返回云存+AI套餐
+                is_ai = uid_set_qs[0]['is_ai']
+                is_ai = 1 if is_ai != 2 and CONFIG_INFO != CONFIG_CN else 0  # 国内不支持AI服务
+                if not is_ai:
+                    return response.json(0)
+                store_qs = store_qs.filter(~Q(pay_type='10'), Q(pixel_level=pixel_level), Q(is_ai=1))  # 筛选像素等级
         else:
             store_qs = store_qs.filter(pay_type='10')  # 体验套餐不区分像素等级
 
@@ -777,13 +784,14 @@ class CloudStorageView(View):
                 channel = order_list[0]['channel']
                 rank = order_list[0]['rank']
 
-                store_qs = Store_Meal.objects.filter(id=rank).values("day", "bucket_id", "bucket__storeDay", "expire")
-                bucket_id = store_qs[0]['bucket_id']
+                store_qs = Store_Meal.objects.filter(id=rank).values('day', 'bucket_id', 'expire')
                 if not store_qs.exists():
                     return response.json(173)
-                uiu_bucket_qs = UID_Bucket.objects.filter(uid=uid).values("id", "bucket_id", "bucket__storeDay",
-                                                                          "bucket__region", "endTime", "use_status")
+                bucket_id = store_qs[0]['bucket_id']
                 expire = store_qs[0]['expire']
+                uid_bucket_qs = UID_Bucket.objects.filter(uid=uid).values("id", "bucket_id",
+                                                                          "bucket__region", "endTime", "use_status")
+
                 if order_list[0]['isSelectDiscounts'] == 1:
                     expire = store_qs[0]['expire'] * 2
                 # 是否有促销
@@ -793,28 +801,20 @@ class CloudStorageView(View):
                 if promotion.exists():
                     promotion_rule_id = promotion[0]['id']
                     expire = expire * 2
+                end_time = CommonService.calcMonthLater(expire)
                 with transaction.atomic():
-                    if uiu_bucket_qs.exists():
-                        uid_bucket = uiu_bucket_qs.first()
-                        if uid_bucket['use_status'] == 1 and uid_bucket['bucket_id'] == bucket_id:  # 套餐使用中并且相同套餐叠加过期时间
-                            end_time = CommonService.calcMonthLater(expire, uid_bucket['endTime'])
-                            UID_Bucket.objects.filter(id=uid_bucket['id']).update(uid=uid, channel=channel,
-                                                                                  bucket_id=bucket_id, endTime=end_time,
-                                                                                  updateTime=now_time)
-                        else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
-                            unused_uid_qs = Unused_Uid_Meal.objects.filter(uid=uid, bucket_id=bucket_id)
-                            nums = 2 if order_list[0]['isSelectDiscounts'] == 1 else 1
-                            if promotion.exists():
-                                nums = nums + 1
-                            if unused_uid_qs.exists():
-                                unused_uid_qs.update(num=F('num') + nums)
-                            else:
-                                Unused_Uid_Meal.objects.create(uid=uid, channel=channel, addTime=now_time, num=nums,
-                                                               expire=store_qs[0]['expire'], bucket_id=bucket_id)
-                            UID_Bucket.objects.filter(id=uid_bucket['id']).update(has_unused=1)
+                    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, is_ai=0,
+                                                           expire=expire, bucket_id=bucket_id, order_id=order_id)
+                            UID_Bucket.objects.filter(id=uid_bucket_id).update(has_unused=1)
+                        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)
                     else:
-                        end_time = CommonService.calcMonthLater(expire)
                         uid_bucket = UID_Bucket.objects.create(uid=uid, channel=channel, bucket_id=bucket_id,
                                                                endTime=end_time, addTime=now_time, updateTime=now_time,
                                                                use_status=1)
@@ -931,13 +931,14 @@ class CloudStorageView(View):
             uid = order_list[0]['UID']
             channel = order_list[0]['channel']
             rank = order_list[0]['rank']
-            store_qs = Store_Meal.objects.filter(id=rank).values("day", "bucket_id", "bucket__storeDay", "expire")
-            bucket_id = store_qs[0]['bucket_id']
+            store_qs = Store_Meal.objects.filter(id=rank).values("day", "bucket_id", "expire", "is_ai")
             if not store_qs.exists():
                 return response.json(173)
-            uid_bucket_qs = UID_Bucket.objects.filter(uid=uid).values("id", "bucket_id", "bucket__storeDay",
-                                                                      "bucket__region", "endTime", "use_status")
+            bucket_id = store_qs[0]['bucket_id']
+            is_ai = store_qs[0]['is_ai']
             expire = store_qs[0]['expire']
+            uid_bucket_qs = UID_Bucket.objects.filter(uid=uid).values("id", "bucket_id",
+                                                                      "bucket__region", "endTime", "use_status")
 
             if order_list[0]['isSelectDiscounts'] == 1:
                 expire = store_qs[0]['expire'] * 2
@@ -948,28 +949,22 @@ class CloudStorageView(View):
             if promotion_rule_qs.exists():
                 promotion_rule_id = promotion_rule_qs[0]['id']
                 expire = expire * 2
+            end_time = CommonService.calcMonthLater(expire)
+            use_flag = True
             with transaction.atomic():
                 if uid_bucket_qs.exists():
                     uid_bucket = uid_bucket_qs.first()
-                    if uid_bucket['use_status'] == 1 and uid_bucket['bucket_id'] == bucket_id:  # 套餐使用中并且相同套餐叠加过期时间
-                        end_time = CommonService.calcMonthLater(expire, uid_bucket['endTime'])
-                        UID_Bucket.objects.filter(id=uid_bucket['id']).update(uid=uid, channel=channel,
-                                                                              endTime=end_time,
-                                                                              bucket_id=bucket_id, updateTime=now_time)
-                    else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
-                        unused_uid_qs = Unused_Uid_Meal.objects.filter(uid=uid, bucket_id=bucket_id)
-                        nums = 2 if order_list[0]['isSelectDiscounts'] == 1 else 1
-                        if promotion_rule_qs.exists():
-                            nums = nums + 1
-                        if unused_uid_qs.exists():
-                            unused_uid_qs.update(num=F('num') + nums)
-                        else:
-                            Unused_Uid_Meal.objects.create(uid=uid, channel=channel, addTime=now_time, num=nums,
-                                                           expire=store_qs[0]['expire'], bucket_id=bucket_id)
-                        UID_Bucket.objects.filter(id=uid_bucket['id']).update(has_unused=1)
                     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)
                 else:
-                    end_time = CommonService.calcMonthLater(expire)
                     uid_bucket = UID_Bucket.objects.create(uid=uid, channel=channel, bucket_id=bucket_id,
                                                            endTime=end_time, addTime=now_time, updateTime=now_time,
                                                            use_status=1)
@@ -990,6 +985,14 @@ class CloudStorageView(View):
                 order_qs.update(status=1, updTime=now_time, uid_bucket_id=uid_bucket_id,
                                 promotion_rule_id=promotion_rule_id)
                 date_time = time.strftime("%Y-%m-%d", time.localtime())
+                # 开通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, addTime=now_time,
+                                                 updTime=now_time, endTime=end_time, use_status=1, orders_id=order_id)
                 # 如果存在序列号,消息提示用序列号
                 device_info_qs = Device_Info.objects.filter(UID=uid).values('serial_number', 'Type')
                 serial_number = device_info_qs[0]['serial_number']
@@ -1024,7 +1027,7 @@ class CloudStorageView(View):
 
     def do_pay_by_wechat_callback(self, request, response):  # 微信支付回调
         """
-        查询套餐列表
+        微信支付回调
         @param request: 请求体
         @request_dict result_code: 业务结果
         @request_dict out_trade_no: 商户订单号
@@ -1067,13 +1070,13 @@ class CloudStorageView(View):
                 uid = order_list[0]['UID']
                 channel = order_list[0]['channel']
                 rank = order_list[0]['rank']
-                store_qs = Store_Meal.objects.filter(id=rank).values("day", "bucket_id", "bucket__storeDay", "expire")
-                bucket_id = store_qs[0]['bucket_id']
+                store_qs = Store_Meal.objects.filter(id=rank).values("day", "bucket_id", "expire")
                 if not store_qs.exists():
                     return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL', 'return_msg': '套餐不存在'}))
-                uid_bucket_qs = UID_Bucket.objects.filter(uid=uid).values("id", "bucket_id", "bucket__storeDay",
-                                                                          "bucket__region", "endTime", "use_status")
+                bucket_id = store_qs[0]['bucket_id']
                 expire = store_qs[0]['expire']
+                uid_bucket_qs = UID_Bucket.objects.filter(uid=uid).values("id", "bucket_id",
+                                                                          "bucket__region", "endTime", "use_status")
                 if order_list[0]['isSelectDiscounts'] == 1:
                     expire = store_qs[0]['expire'] * 2
                 # 是否有促销
@@ -1083,28 +1086,20 @@ class CloudStorageView(View):
                 if promotion_rule_qs.exists():
                     promotion_rule_id = promotion_rule_qs[0]['id']
                     expire = expire * 2
+                end_time = CommonService.calcMonthLater(expire)
                 with transaction.atomic():
                     if uid_bucket_qs.exists():
                         uid_bucket = uid_bucket_qs.first()
-                        if uid_bucket['use_status'] == 1 and uid_bucket['bucket_id'] == bucket_id:  # 套餐使用中并且相同套餐叠加过期时间
-                            end_time = CommonService.calcMonthLater(expire, uid_bucket['endTime'])
-                            UID_Bucket.objects.filter(id=uid_bucket['id']).update(uid=uid, channel=channel,
-                                                                                  bucket_id=bucket_id,
-                                                                                  endTime=end_time, updateTime=now_time)
-                        else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
-                            unused_uid_qs = Unused_Uid_Meal.objects.filter(uid=uid, bucket_id=bucket_id)
-                            nums = 2 if order_list[0]['isSelectDiscounts'] == 1 else 1
-                            if promotion_rule_qs.exists():
-                                nums = nums + 1
-                            if unused_uid_qs.exists():
-                                unused_uid_qs.update(num=F('num') + nums)
-                            else:
-                                Unused_Uid_Meal.objects.create(uid=uid, channel=channel, addTime=now_time, num=nums,
-                                                               expire=store_qs[0]['expire'], bucket_id=bucket_id)
-                            UID_Bucket.objects.filter(id=uid_bucket['id']).update(has_unused=1)
                         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, is_ai=0,
+                                                           expire=expire, bucket_id=bucket_id, order_id=order_id)
+                            UID_Bucket.objects.filter(id=uid_bucket['id']).update(has_unused=1)
+                        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)
                     else:
-                        end_time = CommonService.calcMonthLater(expire)
                         uid_bucket = UID_Bucket.objects.create(uid=uid, channel=channel, bucket_id=bucket_id,
                                                                endTime=end_time, addTime=now_time,
                                                                updateTime=now_time, use_status=1)
@@ -1253,12 +1248,13 @@ class CloudStorageView(View):
                     return response.json(10048)
                 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,
+                                           price=price, currency=currency, addTime=now_time,
+                                           updTime=now_time,
                                            pay_url=sub_info['url'], isSelectDiscounts=is_select_discount,
                                            commodity_code=commodity_code, commodity_type=commodity_type,
-                                           rank_id=rank, plan_id=sub_info['plan_id'], coupon_id=coupon_id, ai_rank_id=1,
+                                           rank_id=rank, plan_id=sub_info['plan_id'], coupon_id=coupon_id,
+                                           ai_rank_id=1,
                                            store_meal_name=store_meal_name)
-
                 return response.json(0, {"redirectUrl": sub_info['url'], "orderID": order_id})
             # 正常扣款
             call_clc_url = "{}web/paid2/fail.html".format(SERVER_DOMAIN_SSL)
@@ -1287,10 +1283,12 @@ class CloudStorageView(View):
                     approval_url = str(link.href)
                     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,
+                                               price=price, currency=currency, addTime=now_time,
+                                               updTime=now_time,
                                                pay_url=approval_url, isSelectDiscounts=is_select_discount,
                                                commodity_code=commodity_code, commodity_type=commodity_type,
-                                               rank_id=rank, paymentID=payment_id, coupon_id=coupon_id, ai_rank_id=1,
+                                               rank_id=rank, paymentID=payment_id, coupon_id=coupon_id,
+                                               ai_rank_id=1,
                                                store_meal_name=store_meal_name)
                     return response.json(0, {"redirectUrl": approval_url, "orderID": order_id})
             return response.json(10, 'generate_order_false')
@@ -1317,7 +1315,8 @@ class CloudStorageView(View):
                     redirect_url = ali_pay_obj.alipay_prefix + order_string
                     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,
+                                               price=price, currency=currency, addTime=now_time,
+                                               updTime=now_time,
                                                pay_url=redirect_url, isSelectDiscounts=is_select_discount,
                                                commodity_code=commodity_code, commodity_type=commodity_type,
                                                rank_id=rank, coupon_id=coupon_id, ai_rank_id=1,
@@ -1347,7 +1346,8 @@ class CloudStorageView(View):
                                        desc=content, payType=pay_type, payTime=now_time,
                                        price=price, currency=currency, addTime=now_time, updTime=now_time,
                                        pay_url=notify_url, isSelectDiscounts=is_select_discount,
-                                       commodity_code=commodity_code, commodity_type=commodity_type, rank_id=rank,
+                                       commodity_code=commodity_code, commodity_type=commodity_type,
+                                       rank_id=rank,
                                        ai_rank_id=1, store_meal_name=store_meal_name)
             return JsonResponse(status=200, data={'result_code': 0, 'reason': 'success',
                                                   'result': response,
@@ -1422,36 +1422,36 @@ class CloudStorageView(View):
         order_id = CommonService.createOrderID()
         now_time = int(time.time())
         store_qs = Store_Meal.objects.filter(id=rank, lang__lang=lang, is_show=0).values("day", "bucket_id",
-                                                                                         "bucket__storeDay", "expire",
+                                                                                         "expire",
                                                                                          'lang__content', 'price',
                                                                                          'currency', 'commodity_type')
         if not store_qs.exists():
             return response.json(173)
         bucket_id = store_qs[0]['bucket_id']
-        uid_bucket_qs = UID_Bucket.objects.filter(uid=uid).values("id", "bucket_id", "bucket__storeDay",
-                                                                  "bucket__region", "endTime", "use_status")
+        uid_bucket_qs = UID_Bucket.objects.filter(uid=uid).values("id", "bucket_id", "bucket__region",
+                                                                  "endTime", "use_status")
         expire = store_qs[0]['expire']
+        uid_set_qs = UidSetModel.objects.filter(uid=uid, channel=channel).values('is_ai')
+        if not uid_set_qs.exists():
+            return response.json(173)
+        is_ai = 1 if uid_set_qs[0]['is_ai'] != 2 else 0
+        use_flag = True
+        end_time = CommonService.calcMonthLater(expire)
         try:
             with transaction.atomic():
                 if uid_bucket_qs.exists():
                     uid_bucket = uid_bucket_qs.first()
-                    if uid_bucket['use_status'] == 1 and uid_bucket['bucket_id'] == bucket_id:  # 套餐使用中并且相同套餐叠加过期时间
-                        end_time = CommonService.calcMonthLater(expire, uid_bucket['endTime'])
-                        UID_Bucket.objects.filter(id=uid_bucket['id']).update(uid=uid, channel=channel,
-                                                                              bucket_id=bucket_id,
-                                                                              endTime=end_time, updateTime=now_time)
-                    else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
-                        unused_uid_qs = Unused_Uid_Meal.objects.filter(uid=uid, bucket_id=bucket_id)
-                        nums = 1
-                        if unused_uid_qs.exists():
-                            unused_uid_qs.update(num=F('num') + nums)
-                        else:
-                            Unused_Uid_Meal.objects.create(uid=uid, channel=channel, addTime=now_time, num=nums,
-                                                           expire=store_qs[0]['expire'], bucket_id=bucket_id)
-                        UID_Bucket.objects.filter(id=uid_bucket['id']).update(has_unused=1)
                     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, is_ai=is_ai,
+                                                       order_id=order_id, expire=expire, 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)
                 else:
-                    end_time = CommonService.calcMonthLater(expire)
                     uid_bucket = UID_Bucket.objects.create(uid=uid, channel=channel, bucket_id=bucket_id,
                                                            endTime=end_time, addTime=now_time, updateTime=now_time,
                                                            use_status=1)
@@ -1470,6 +1470,14 @@ class CloudStorageView(View):
                                            pay_url="体验版", store_meal_name=store_meal_name,
                                            commodity_code=commodity_code, commodity_type=store_qs[0]['commodity_type'],
                                            rank_id=rank, status=1, uid_bucket_id=uid_bucket_id, ai_rank_id=1)
+                #  开通AI服务,国内不支持AI
+                if is_ai and use_flag and CONFIG_INFO != CONFIG_CN:
+                    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, addTime=now_time,
+                                                 updTime=now_time, endTime=end_time, use_status=1, orders_id=order_id)
 
                 device_user_qs = Device_User.objects.filter(userID=user_id).values('username')
                 device_info_qs = Device_Info.objects.filter(UID=uid, vodPrimaryUserID='', vodPrimaryMaster='')
@@ -1638,12 +1646,11 @@ class CloudStorageView(View):
             unused_uid_qs = Unused_Uid_Meal.objects.filter(uid=uid).annotate(unused_id=F('id')).values("unused_id",
                                                                                                        "uid",
                                                                                                        "bucket__content",
-                                                                                                       "num",
                                                                                                        "bucket__id",
                                                                                                        "expire")
             month = 'month' if lang != 'cn' else '个月'
             for unused_uid in unused_uid_qs:
-                storage_time = unused_uid['num'] * unused_uid['expire']
+                storage_time = unused_uid['expire']
                 if lang != 'cn' and storage_time > 1:  # 英文大于一个月使用复数
                     month += 's'
                 storage = str(storage_time) + month
@@ -1691,7 +1698,8 @@ class CloudStorageView(View):
         using_uid_bucket_qs = UID_Bucket.objects.filter(uid=uid, has_unused=1).values("id", "uid", "endTime",
                                                                                       "bucket__content", "addTime")
         unused_uid_bucket_qs = Unused_Uid_Meal.objects.filter(id=unused_id).values("id", "uid", "channel", "addTime",
-                                                                                   "expire", "num", "bucket_id")
+                                                                                   "expire", "is_ai", "bucket_id",
+                                                                                   "order_id")
         if not unused_uid_bucket_qs.exists() or not using_uid_bucket_qs.exists():
             return response.json(10030)
         unused_uid_bucket = unused_uid_bucket_qs.first()
@@ -1700,11 +1708,21 @@ class CloudStorageView(View):
             with transaction.atomic():
                 count_unused = Unused_Uid_Meal.objects.filter(uid=uid).count()
                 has_unused = 1 if count_unused > 1 else 0
-                end_time = CommonService.calcMonthLater(unused_uid_bucket['expire'] * unused_uid_bucket['num'])
+                end_time = CommonService.calcMonthLater(unused_uid_bucket['expire'])
                 UID_Bucket.objects.filter(uid=uid).update(channel=unused_uid_bucket['channel'], endTime=end_time,
                                                           bucket_id=unused_uid_bucket['bucket_id']
                                                           , updateTime=now_time, use_status=1,
                                                           has_unused=has_unused)
+                # 开通AI服务
+                if unused_uid_bucket['is_ai']:
+                    ai_service = AiService.objects.filter(uid=uid, channel=unused_uid_bucket['channel'])
+                    if ai_service.exists():  # 有正在使用的套餐,套餐结束时间保存为套餐有效期
+                        ai_service.update(updTime=now_time, use_status=1, orders_id=unused_uid_bucket['order_id'],
+                                          endTime=end_time)
+                    else:
+                        AiService.objects.create(uid=uid, channel=unused_uid_bucket['channel'], detect_status=1,
+                                                 addTime=now_time, updTime=now_time, endTime=end_time, use_status=1,
+                                                 orders_id=unused_uid_bucket['order_id'])
                 Unused_Uid_Meal.objects.filter(id=unused_id).delete()
                 StsCrdModel.objects.filter(uid=uid).delete()  # 删除sts记录
                 # VodHlsModel.objects.filter(uid=uid).delete()  # 删除播放列表,后期数据量多时应该考虑延后删除

Controller/CloudTransfer.py

@@ -13,7 +13,7 @@ from django.db.models import Q
 from django.views.generic.base import View
 
 from Model.models import Device_User, Device_Info, Order_Model, UID_Bucket, StsCrdModel, VodHlsModel, Unused_Uid_Meal, \
-    VodBucketModel, UnicomDeviceInfo, LogModel, UidPushModel
+    VodBucketModel, UnicomDeviceInfo, LogModel, UidPushModel, AiService, UidSetModel
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
 from Service.CommonService import CommonService
@@ -196,30 +196,48 @@ class cloudTestView(View):
             new_unused_uid_bucket = Unused_Uid_Meal.objects.filter(uid=new_uid)
             if new_using_uid_bucket.exists() or new_unused_uid_bucket.exists():
                 return response.json(10014)
-
-            # 如果转出设备有未使用套餐,更改第一个未使用套餐为正在使用
-            if old_using_uid_bucket[0]['has_unused'] == 1:
-                old_unused_uid_bucket = Unused_Uid_Meal.objects.filter(uid=old_uid).values('id', 'channel', 'bucket_id',
-                                                                                           'addTime', 'expire', 'num')
-                count = old_unused_uid_bucket.count()
-                unused = old_unused_uid_bucket[0]
-                has_unused = 1 if count > 1 else 0  # 如果存在不止一个未使用套餐,has_unused=1
-                endTime = CommonService.calcMonthLater(unused['expire'] * unused['num'])
-                data_dict = {
-                    'uid': old_uid,
-                    'channel': unused['channel'],
-                    'bucket_id': unused['bucket_id'],
-                    'addTime': unused['addTime'],
-                    'endTime': endTime,
-                    'updateTime': nowTime,
-                    'status': 1,
-                    'use_status': 1,
-                    'has_unused': has_unused
-                }
-                UID_Bucket.objects.create(**data_dict)  # 正在使用套餐表添加数据
-                Unused_Uid_Meal.objects.filter(uid=old_uid).first().delete()  # 删除未使用套餐表中的数据
-
+            old_ai_service = AiService.objects.filter(uid=old_uid, endTime__gte=nowTime, use_status=1).values('id',
+                                                                                                              'detect_interval',
+                                                                                                              'detect_status',
+                                                                                                              'detect_group')
+            new_ai_service = AiService.objects.filter(uid=new_uid, endTime__gte=nowTime, use_status=1)
+            if new_ai_service.exists():  # 转入设备有开通AI功能，不能转
+                return response.json(10014)
+            new_uid_set = UidSetModel.objects.filter(uid=new_uid).values('is_ai')
+            if old_ai_service.exists() and new_uid_set[0]['is_ai'] == 2:  # 转出设备有开通AI，但是转入设备不支持AI，不能转
+                return response.json(10016)
             with transaction.atomic():
+                # 如果转出设备有未使用套餐,更改第一个未使用套餐为正在使用
+                if old_using_uid_bucket[0]['has_unused'] == 1:
+                    old_unused_uid_bucket = Unused_Uid_Meal.objects.filter(uid=old_uid).values('id', 'channel',
+                                                                                               'bucket_id',
+                                                                                               'addTime', 'expire',
+                                                                                               'is_ai',
+                                                                                               'order_id')
+                    count = old_unused_uid_bucket.count()
+                    unused = old_unused_uid_bucket[0]
+                    has_unused = 1 if count > 1 else 0  # 如果存在不止一个未使用套餐,has_unused=1
+                    endTime = CommonService.calcMonthLater(unused['expire'])
+                    data_dict = {
+                        'uid': old_uid,
+                        'channel': unused['channel'],
+                        'bucket_id': unused['bucket_id'],
+                        'addTime': unused['addTime'],
+                        'endTime': endTime,
+                        'updateTime': nowTime,
+                        'status': 1,
+                        'use_status': 1,
+                        'has_unused': has_unused
+                    }
+                    UID_Bucket.objects.create(**data_dict)  # 正在使用套餐表添加数据
+                    Unused_Uid_Meal.objects.filter(uid=old_uid).first().delete()  # 删除未使用套餐表中的数据
+                    if unused['is_ai']:  # 开通AI服务
+                        AiService.objects.create(uid=old_uid, channel=unused['channel'],
+                                                 detect_status=old_ai_service[0]['detect_status'],
+                                                 addTime=nowTime, updTime=nowTime, endTime=endTime, use_status=1,
+                                                 orders_id=unused['order_id'],
+                                                 detect_group=old_ai_service[0]['detect_group'],
+                                                 detect_interval=old_ai_service[0]['detect_interval'])
                 # 更新转入设备的主用户信息
                 Device_Info.objects.filter(UID=new_uid).update(vodPrimaryUserID=vodPrimaryUserID,
                                                                vodPrimaryMaster=vodPrimaryMaster)
@@ -227,6 +245,16 @@ class cloudTestView(View):
                 old_using_uid_bucket_id = old_using_uid_bucket[0]['id']
                 UID_Bucket.objects.filter(id=old_using_uid_bucket_id).update(uid=new_uid, has_unused=0)
                 StsCrdModel.objects.filter(uid=old_uid).delete()  # 删除转出设备stscrd表关联数据
+                # 转移AI服务
+                if old_ai_service.exists() and new_uid_set[0]['is_ai'] != 2:
+                    AiService.objects.filter(id=old_ai_service[0]['id']).update(uid=new_uid, detect_status=0,
+                                                                                detect_group='', detect_interval=60)
+                    msg = {'commandType': 'AIDisable'}
+                    thing_name = CommonService.query_serial_with_uid(old_uid)  # 存在序列号则为使用序列号作为物品名
+                    topic_name = 'ansjer/generic/{}'.format(thing_name)
+                    req_success = CommonService.req_publish_mqtt_msg(thing_name, topic_name, msg)
+                    if not req_success:
+                        return response.json(10044)
 
                 # 记录套餐转移日志
                 ip = CommonService.get_ip_address(request)

Controller/CloudVod.py

@@ -13,9 +13,10 @@ from django.utils.decorators import method_decorator
 from django.views.decorators.csrf import csrf_exempt
 from django.views.generic.base import View
 
-from Ansjer.config import OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET, OSS_ROLE_ARN, SERVER_DOMAIN, PAYPAL_CRD
-from Model.models import Device_Info, Order_Model, Store_Meal, VodHlsModel, OssCrdModel, UID_Bucket, StsCrdModel, \
-    VodBucketModel
+from Ansjer.config import OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET, OSS_ROLE_ARN, SERVER_DOMAIN, PAYPAL_CRD, \
+    CONFIG_INFO, CONFIG_CN
+from Model.models import Device_Info, Order_Model, Store_Meal, OssCrdModel, UID_Bucket, StsCrdModel, \
+    VodBucketModel, UidSetModel, AiService
 from Object.AliPayObject import AliPayObject
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
@@ -564,7 +565,8 @@ class CloudVodView(View):
             thumb = bucket.sign_url('GET', ts, 3600,
                                     params={'x-oss-process': 'video/snapshot,t_1000,m_fast,w_300'})
             vod_play_list.append(
-                {'name': vod['start_time'], 'sign_url': vod_play_url, 'thumb': thumb, 'sec': vod['sec'], 'id': vod['id']})
+                {'name': vod['start_time'], 'sign_url': vod_play_url, 'thumb': thumb, 'sec': vod['sec'],
+                 'id': vod['id']})
         vod_play_list = sorted(vod_play_list, key=lambda item: -item['name'])
         return response.json(0, vod_play_list)
 

Controller/Cron/CronTaskController.py

@@ -432,8 +432,7 @@ class CronUpdateDataView(View):
         if expired_uid_bucket.exists():
             expired_uid_bucket.update(use_status=2)
         # 监控有未使用套餐则自动生效
-        expired_uid_buckets = \
-            UID_Bucket.objects.filter(endTime__lte=now_time, has_unused=1).values("id", "uid")[0:1000]
+        expired_uid_buckets = UID_Bucket.objects.filter(endTime__lte=now_time, has_unused=1).values("id", "uid")[0:1000]
         for expired_uid_bucket in expired_uid_buckets:
             unuseds = Unused_Uid_Meal.objects.filter(
                 uid=expired_uid_bucket['uid']).values(
@@ -442,29 +441,36 @@ class CronUpdateDataView(View):
                 "channel",
                 "addTime",
                 "expire",
-                "num",
-                "bucket_id").order_by('addTime')[0:1]
+                "is_ai",
+                "bucket_id",
+                "order_id").order_by('addTime')
             if not unuseds.exists():
                 continue
             unused = unuseds[0]
             try:
                 with transaction.atomic():
-                    count_unused = Unused_Uid_Meal.objects.filter(
-                        uid=expired_uid_bucket['uid']).count()
+                    count_unused = Unused_Uid_Meal.objects.filter(uid=expired_uid_bucket['uid']).count()
                     has_unused = 1 if count_unused > 1 else 0
-                    endTime = CommonService.calcMonthLater(
-                        unused['expire'] * unused['num'])
+                    end_time = CommonService.calcMonthLater(unused['expire'])
                     UID_Bucket.objects.filter(
                         uid=expired_uid_bucket['uid']).update(
                         channel=unused['channel'],
-                        endTime=endTime,
+                        endTime=end_time,
                         bucket_id=unused['bucket_id'],
                         updateTime=now_time,
                         use_status=1,
                         has_unused=has_unused)
+                    if unused['is_ai']:
+                        ai_service = AiService.objects.filter(uid=expired_uid_bucket['uid'], channel=unused['channel'])
+                        if ai_service.exists():
+                            ai_service.update(updTime=now_time, use_status=1, orders_id=unused['order_id'],
+                                              endTime=end_time)
+                        else:
+                            AiService.objects.create(uid=expired_uid_bucket['uid'], channel=unused['channel'],
+                                                     detect_status=1, addTime=now_time, orders_id=unused['order_id'],
+                                                     updTime=now_time, endTime=end_time, use_status=1)
                     Unused_Uid_Meal.objects.filter(id=unused['id']).delete()
-                    StsCrdModel.objects.filter(
-                        uid=expired_uid_bucket['uid']).delete()  # 删除sts记录
+                    StsCrdModel.objects.filter(uid=expired_uid_bucket['uid']).delete()  # 删除sts记录
             except Exception as e:
                 print(repr(e))
                 continue

Controller/EquipmentManager.py

@@ -1105,7 +1105,7 @@ def uid_status(request):
     qs = UidSetModel.objects.filter(uid=uid).values('uid', 'detect_status', 'detect_interval', 'version', 'ucode',
                                                     'p2p_region', 'tz', 'video_code', 'channel', 'cloud_vod', 'id',
                                                     'detect_group', 'is_alexa', 'region_alexa', 'is_ptz',
-                                                    'msg_notify')
+                                                    'msg_notify', 'new_detect_interval')
 
     # 调试
     debugOnes = int(time.time())
@@ -1126,6 +1126,7 @@ def uid_status(request):
         data = {
             'push_status': detect_status,  # 推送状态
             'push_interval': qs[0]['detect_interval'],  # 推送间隔
+            'new_push_interval': qs[0]['new_detect_interval'],  # 新推送间隔
             'ucode': qs[0]['ucode'],
             'version': qs[0]['version'],
             'p2p_region': qs[0]['p2p_region'],

Controller/MealManage.py

@@ -97,6 +97,8 @@ class MealManage(View):
         expire = request_dict.get('expire', None)
         symbol = request_dict.get('symbol', None)
         is_show = request_dict.get('is_show', None)
+        is_ai = request_dict.get('is_ai', None)
+        pixel_level = request_dict.get('pixel_level', None)
 
         # if not title or not id or not price or not day or not content:
         if not id or not price or not day:
@@ -110,7 +112,8 @@ class MealManage(View):
                 return response.json(10, '已存在')
             store_meal = Store_Meal(id=id, price=price, day=day, bucket_id=bucketID, commodity_code=commodity_code,
                                     currency=currency, virtual_price=virtual_price, is_discounts=is_discounts,
-                                    discount_price=discount_price, expire=expire, symbol=symbol, is_show=is_show)
+                                    discount_price=discount_price, expire=expire, symbol=symbol, is_show=is_show,
+                                    is_ai=is_ai, pixel_level=pixel_level)
             store_meal.save()
             paytype = paytype.split(',')
             if len(paytype) > 0:
@@ -142,7 +145,8 @@ class MealManage(View):
         qs = qs.annotate(title=F('lang__title'), content=F('lang__content'))
         qs = qs.values("id", "title", "price", "day", "add_time", "update_time", "currency", "expire", "symbol"
                        , "commodity_type", "commodity_code", "virtual_price", "is_discounts", "discount_price"
-                       , "bucket_id", "bucket__bucket", "bucket__area", "bucket__storeDay", "bucket__mold", "is_show")
+                       , "bucket_id", "bucket__bucket", "bucket__area", "bucket__storeDay", "bucket__mold", "is_show",
+                       "is_ai", "pixel_level")
         res = {}
         items_list = []
         if qs.exists():
@@ -178,6 +182,8 @@ class MealManage(View):
         symbol = request_dict.get('symbol', None)
         type = request_dict.get('type', None)
         is_show = request_dict.get('is_show', None)
+        is_ai = request_dict.get('is_ai', None)
+        pixel_level = request_dict.get('pixel_level', None)
         # if not id or not title or not price or not content or not day or not type:
         if not id or not price or not day or not type:
             # return response.json(444, 'id, title, price, content, day,type')
@@ -200,6 +206,8 @@ class MealManage(View):
             store_meal.expire = expire
             store_meal.symbol = symbol
             store_meal.is_show = is_show
+            store_meal.is_ai = is_ai
+            store_meal.pixel_level = pixel_level
             store_meal.day = day
             if bucketID:
                 store_meal.bucket_id = bucketID

Controller/PaymentCycle.py

@@ -207,8 +207,7 @@ class PaypalCycleNotify(View):
             username = order_list[0]['userID__username']
             channel = order_list[0]['channel']
             rank = order_list[0]['rank']
-            smqs = Store_Meal.objects.filter(id=rank). \
-                values("day", "bucket_id", "bucket__storeDay", "expire")
+            smqs = Store_Meal.objects.filter(id=rank).values("day", "bucket_id", "bucket__storeDay", "expire", "is_ai")
             bucketId = smqs[0]['bucket_id']
             if not smqs.exists():
                 logger.info('----订阅套餐失效----')
@@ -220,7 +219,7 @@ class PaypalCycleNotify(View):
             ubqs = UID_Bucket.objects.filter(uid=UID).values("id", "bucket_id", "bucket__storeDay", "bucket__region",
                                                              "endTime", "use_status")
             expire = smqs[0]['expire']
-
+            is_ai = smqs[0]['is_ai']
             if order_list[0]['isSelectDiscounts'] == 1:
                 expire = smqs[0]['expire'] * 2
             # 是否有促销
@@ -229,28 +228,22 @@ class PaypalCycleNotify(View):
             if promotion.exists():
                 promotion_rule_id = promotion[0]['id']
                 expire = expire * 2
+            endTime = CommonService.calcMonthLater(expire)
+            use_flag = True
             with transaction.atomic():
                 if ubqs.exists():
                     ubq = ubqs[0]
-                    if ubq['use_status'] == 1 and ubq['bucket_id'] == bucketId:  # 套餐使用中并且相同套餐叠加过期时间
-                        endTime = CommonService.calcMonthLater(expire, ubq['endTime'])
-                        UID_Bucket.objects.filter(id=ubq['id']).update \
-                            (uid=UID, channel=channel, bucket_id=bucketId,
-                             endTime=endTime, updateTime=nowTime)
-                    else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
-                        has_unused = Unused_Uid_Meal.objects.filter(uid=UID, bucket_id=bucketId).values("id")
-                        nums = 2 if order_list[0]['isSelectDiscounts'] == 1 else 1
-                        if promotion.exists():
-                            nums = nums + 1
-                        if has_unused.exists():
-                            Unused_Uid_Meal.objects.filter(id=has_unused[0]['id']).update(num=F('num') + nums)
-                        else:
-                            Unused_Uid_Meal.objects.create(uid=UID, channel=channel, addTime=nowTime, num=nums,
-                                                           expire=smqs[0]['expire'], bucket_id=bucketId)
-                        UID_Bucket.objects.filter(id=ubq['id']).update(has_unused=1)
                     uid_bucket_id = ubq['id']
+                    if ubq['use_status'] == 1 and ubq['endTime'] > nowTime:  # 套餐使用中并且未过期，加入未使用的关联套餐表
+                        Unused_Uid_Meal.objects.create(uid=UID, channel=channel, addTime=nowTime, is_ai=is_ai,
+                                                       order_id=orderID, expire=expire, bucket_id=bucketId)
+                        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(uid=UID, channel=channel, bucket_id=bucketId,
+                                                                           endTime=endTime, updateTime=nowTime)
+
                 else:
-                    endTime = CommonService.calcMonthLater(expire)
                     ub_cqs = UID_Bucket.objects.create \
                         (uid=UID, channel=channel, bucket_id=bucketId, endTime=endTime, addTime=nowTime,
                          updateTime=nowTime, use_status=1)
@@ -262,6 +255,14 @@ class PaypalCycleNotify(View):
                         'vodPrimaryMaster': username
                     }
                     dvq.update(**dvq_set_update_dict)
+                # 开通AI服务
+                if is_ai and use_flag:
+                    ai_service = AiService.objects.filter(uid=UID, channel=channel)
+                    if ai_service.exists():  # 有正在使用的套餐,套餐结束时间保存为套餐有效期
+                        ai_service.update(updTime=nowTime, use_status=1, orders_id=orderID, endTime=endTime)
+                    else:
+                        AiService.objects.create(uid=UID, channel=channel, detect_status=1, addTime=nowTime,
+                                                 updTime=nowTime, endTime=endTime, use_status=1, orders_id=orderID)
 
                 # uid_main_exist = UIDMainUser.objects.filter(UID=UID)
                 # if not uid_main_exist.exists():
@@ -437,41 +438,38 @@ class PaypalCycleNotify(View):
             username = order_qs[0]['userID__username']
             channel = order_qs[0]['channel']
             rank = order_qs[0]['rank']
-            store_meal_qs = Store_Meal.objects.filter(id=rank).values("day", "bucket_id", "bucket__storeDay", "expire")
+            store_meal_qs = Store_Meal.objects.filter(id=rank).values("day", "bucket_id", "bucket__storeDay", "expire",
+                                                                      "is_ai")
             if not store_meal_qs.exists():
                 PAY_LOGGER.info('{} PayPal周期扣款失败---套餐数据不存在'.format(UID))
                 return HttpResponse('fail', status=500)
 
             bucketId = store_meal_qs[0]['bucket_id']
             expire = store_meal_qs[0]['expire']
+            is_ai = store_meal_qs[0]['is_ai']
+            endTime = CommonService.calcMonthLater(expire)
+            use_flag = True
+            orderID = CommonService.createOrderID()
             ubqs = UID_Bucket.objects.filter(uid=UID).values("id", "bucket_id", "bucket__storeDay", "bucket__region",
                                                              "endTime", "use_status")
 
             with transaction.atomic():
                 if ubqs.exists():
                     ubq = ubqs[0]
-                    if ubq['use_status'] == 1 and ubq['bucket_id'] == bucketId:  # 套餐使用中并且相同套餐叠加过期时间
-                        endTime = CommonService.calcMonthLater(expire, ubq['endTime'])
-                        UID_Bucket.objects.filter(id=ubq['id']).update \
-                            (uid=UID, channel=channel, bucket_id=bucketId,
-                             endTime=endTime, updateTime=nowTime)
-                    else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
-                        has_unused = Unused_Uid_Meal.objects.filter(uid=UID, bucket_id=bucketId).values("id")
-                        nums = 1
-                        if has_unused.exists():
-                            Unused_Uid_Meal.objects.filter(id=has_unused[0]['id']).update(num=F('num') + nums)
-                        else:
-                            Unused_Uid_Meal.objects.create(uid=UID, channel=channel, addTime=nowTime, num=nums,
-                                                           expire=expire, bucket_id=bucketId)
-                        UID_Bucket.objects.filter(id=ubq['id']).update(has_unused=1)
                     uid_bucket_id = ubq['id']
+                    if ubq['use_status'] == 1 and ubq['endTime'] > nowTime:  # 套餐使用中并且未过期
+                        Unused_Uid_Meal.objects.create(uid=UID, channel=channel, addTime=nowTime, is_ai=is_ai,
+                                                       order_id=orderID, expire=expire, bucket_id=bucketId)
+                        UID_Bucket.objects.filter(id=ubq['id']).update(has_unused=1)
+                        use_flag = False
+                    else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
+                        UID_Bucket.objects.filter(id=uid_bucket_id).update(uid=UID, channel=channel, bucket_id=bucketId,
+                                                                           endTime=endTime, updateTime=nowTime)
+
                 else:
-                    endTime = CommonService.calcMonthLater(expire)
-                    ub_cqs = UID_Bucket.objects.create \
-                        (uid=UID, channel=channel, bucket_id=bucketId, endTime=endTime, addTime=nowTime,
-                         updateTime=nowTime, use_status=1)
+                    ub_cqs = UID_Bucket.objects.create(uid=UID, channel=channel, bucket_id=bucketId, endTime=endTime,
+                                                       addTime=nowTime, updateTime=nowTime, use_status=1)
                     uid_bucket_id = ub_cqs.id
-
                 dvq = Device_Info.objects.filter(UID=UID, vodPrimaryUserID='', vodPrimaryMaster='')
                 if dvq.exists():
                     dvq_set_update_dict = {
@@ -480,7 +478,6 @@ class PaypalCycleNotify(View):
                     }
                     dvq.update(**dvq_set_update_dict)
 
-                orderID = CommonService.createOrderID()
                 store_meal_qs = Store_Meal.objects.filter(id=rank, lang__lang='cn', is_show=0).values('lang__title',
                                                                                                       'lang__content')
                 if store_meal_qs.exists():
@@ -488,13 +485,25 @@ class PaypalCycleNotify(View):
                 else:
                     store_meal_name = '未知套餐'
                 Order_Model.objects.create(orderID=orderID, UID=UID, channel=channel, userID_id=userid,
-                                           desc=desc, payType=pay_type, payTime=nowTime, price=amount.get('total'),
-                                           currency=order_qs[0]['currency'], addTime=nowTime, updTime=nowTime,
-                                           pay_url='', isSelectDiscounts=0, commodity_code=commodity_code,
+                                           desc=desc, payType=pay_type, payTime=nowTime,
+                                           price=amount.get('total'),
+                                           currency=order_qs[0]['currency'], addTime=nowTime,
+                                           updTime=nowTime,
+                                           pay_url='', isSelectDiscounts=0,
+                                           commodity_code=commodity_code,
                                            commodity_type=commodity_type, rank_id=rank, paymentID='',
                                            coupon_id='', uid_bucket_id=uid_bucket_id, status=1,
                                            agreement_id=agreement_id, store_meal_name=store_meal_name,
                                            plan_id=plan_id, ai_rank_id=1, trade_no=paypal_transaction_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=nowTime, use_status=1, orders_id=orderID, endTime=endTime)
+                    else:
+                        AiService.objects.create(uid=uid, channel=channel, detect_status=1, addTime=nowTime,
+                                                 updTime=nowTime, endTime=endTime, use_status=1, orders_id=orderID)
+
                 # 如果存在序列号,消息提示用序列号
                 device_name = CommonService.query_serial_with_uid(uid=UID)
                 datetime = time.strftime("%Y-%m-%d", time.localtime())

Model/apps.py

@@ -1,4 +1,5 @@
 from django.apps import AppConfig
 
+
 class UsermanagerConfig(AppConfig):
     name = 'Model'

Model/models.py

@@ -1515,7 +1515,7 @@ class Order_Model(models.Model):
     rank = models.ForeignKey(Store_Meal, to_field='id', default='', on_delete=models.CASCADE, verbose_name='关联云存套餐表')
     ai_rank = models.ForeignKey(AiStoreMeal, to_field='id', default='', on_delete=models.CASCADE,
                                 verbose_name='关联ai套餐表')
-    order_type = models.SmallIntegerField(default=0, verbose_name='订单类型：0：云存,1:ai,2:联通4G')
+    order_type = models.SmallIntegerField(default=0, verbose_name='订单类型：0：云存,1:ai,2:联通4G,3:五兴,4:云盘')
     unify_combo_id = models.CharField(blank=True, default='', max_length=32, verbose_name=u'统一套餐id')
     nickname = models.CharField(default='', max_length=64, verbose_name='设备昵称')
     uid_bucket_id = models.IntegerField(default=0, verbose_name='关联uid_bucket的字段')
@@ -1873,8 +1873,10 @@ class Unused_Uid_Meal(models.Model):
     bucket = models.ForeignKey(VodBucketModel, blank=True, to_field='id', on_delete=models.CASCADE, verbose_name='存储空间')
     addTime = models.IntegerField(verbose_name='添加时间', default=0)
     expire = models.IntegerField(verbose_name='存储桶存储时长[月份]', default=0)
-    num = models.IntegerField(verbose_name='个数', default=0)
+    is_ai = models.SmallIntegerField(verbose_name='是否开通AI服务', default=0)  # 0:不开通；1：开通
+    order_id = models.CharField(max_length=20, verbose_name='关联订单号', default='', db_index=True)
 
+    # num = models.IntegerField(verbose_name='个数', default=0)
     # effect_time = models.BigIntegerField(verbose_name='生效时间', db_index=True, default=0)
     # uid_bucket = models.ForeignKey(UID_Bucket, blank=True, to_field='id', on_delete=models.CASCADE, default=0,
     #                            verbose_name='uid_bucket关联')

Object/ResponseObject.py

@@ -97,6 +97,7 @@ class ResponseObject(object):
             10013: 'Original equipment package has expired and cannot be transferred',
             10014: 'Accept transfer of equipment packages that have not expired and cannot be transferred',
             10015: 'Shared devices cannot be transferred',
+            10016: 'The transfer device does not support the AI function and cannot be transferred',
             10030: 'No purchase of cloud storage',
             10031: 'The cloud storage has expired',
             10032: 'The switched cloud storage package ID cannot be the same as the one in use',
@@ -232,6 +233,7 @@ class ResponseObject(object):
             10013: '原设备套餐已过期，无法转移',
             10014: '接受转移设备套餐未过期，无法转移',
             10015: '分享的设备无法转移',
+            10016: '转入设备不支持AI功能，无法转移',
             10030: '未购买云存',
             10031: '云存已过期',
             10032: '切换的云存套餐ID不能与正在使用中的相同',

Service/UserDeviceService.py

@@ -81,7 +81,7 @@ class UserDeviceService:
         """
         return UidSetModel.objects.filter(uid__in=uid_list) \
             .values('id', 'uid', 'version', 'nickname', 'ucode',
-                    'detect_status', 'detect_group',
+                    'detect_status', 'detect_group', 'new_detect_interval',
                     'detect_interval', 'isSupportFourPoint',
                     'region_alexa', 'is_alexa', 'deviceModel',
                     'TimeZone', 'TimeStatus', 'SpaceUsable',
@@ -106,6 +106,7 @@ class UserDeviceService:
                 'nickname': us['nickname'],
                 'ucode': us['ucode'],
                 'detect_interval': us['detect_interval'],
+                'new_detect_interval': us['new_detect_interval'],
                 'detect_group': us['detect_group'],
                 'detect_status': us['detect_status'],
                 'region_alexa': us['region_alexa'],
@@ -215,6 +216,7 @@ class UserDeviceService:
         p_vo['uid_version'] = uidversion
         p_vo['ucode'] = '72V201233AA' if uv_dict[p_uid]['mobile4G'] == 1 else uv_dict[p_uid]['ucode']
         p_vo['detect_interval'] = uv_dict[p_uid]['detect_interval']
+        p_vo['new_push_interval'] = uv_dict[p_uid]['new_detect_interval']
         p_vo['detect_status'] = uv_dict[p_uid]['detect_status']
         p_vo['detect_group'] = uv_dict[p_uid]['detect_group']
         p_vo['region_alexa'] = uv_dict[p_uid]['region_alexa']