修复云存套装转移接口问题、新增ip返回状态接口adStatus限定珠海市

AdminController/ServeManagementController.py

@@ -23,7 +23,7 @@ from Controller.UnicomCombo.UnicomComboTaskController import UnicomComboTaskView
 from Model.models import VodBucketModel, CDKcontextModel, Store_Meal, Order_Model, \
     UID_Bucket, ExperienceContextModel, Lang, CloudLogModel, UidSetModel, Unused_Uid_Meal, \
     Device_Info, DeviceTypeModel, UnicomComboOrderInfo, AiService, CountryModel, \
-    AbnormalOrder, DailyReconciliation, StsCrdModel, LogModel
+    Device_User, AbnormalOrder, DailyReconciliation, StsCrdModel, LogModel
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
 from Object.UnicomObject import UnicomObjeect
@@ -1428,186 +1428,234 @@ class serveManagement(View):
             return response.json(0, '重置云存体验失败')
 
     def meal_transfer(self, request, request_dict, response):
-        orderID = request_dict.get("orderID")
-        old_uid = request_dict.get("old_uid")
-        new_uid = request_dict.get("new_uid")
-        nowTime = int(time.time())
-
-        # 查订单表查看订单类型
-        order_type = Order_Model.objects.values_list('order_type', flat=True).get(orderID=orderID)
-        if order_type not in [0, 1]:
-            return response.json(10017)
-
-        # 查老设备 orderID
-        old_using_uid_bucket = UID_Bucket.objects.filter(orderId=orderID, endTime__gte=nowTime)
-        old_unusing_uid_bucket = Unused_Uid_Meal.objects.filter(order_id=orderID)
-
-        if not old_using_uid_bucket.exists() and not old_unusing_uid_bucket.exists():
-            return response.json(10017)
-
-        # 订单套餐未使用
-        if old_unusing_uid_bucket.exists():
-            with transaction.atomic():
-                # 旧设备不包含 ai
-                if old_unusing_uid_bucket.filter(is_ai=1).exists():
-                    new_uid_set = UidSetModel.objects.filter(uid=new_uid).values('is_ai')
-                    if new_uid_set[0]['is_ai'] == 2:
-                        return response.json(10016)
-                old_unusing_uid_bucket.update(uid=new_uid, addTime=nowTime)
-                new_unused_uid_bucket = Unused_Uid_Meal.objects.filter(uid=new_uid, addTime=nowTime).values(
-                    'id', 'channel', 'bucket_id', 'addTime', 'expire', 'is_ai', 'order_id'
-                )
-
-                # 转移后如果没有未使用套餐则把 has_unused 改为 0
-                unused_uid_meal_qs = Unused_Uid_Meal.objects.filter(uid=old_uid)
-                if not unused_uid_meal_qs.exists():
-                    UID_Bucket.objects.filter(uid=old_uid).update(has_unused=0)
-
-                # 判断新设备是否有正在使用的套餐
-                new_uid_bucket_qs = UID_Bucket.objects.filter(uid=new_uid, endTime__gte=nowTime, use_status=1)
-                if new_uid_bucket_qs.exists():
-                    new_uid_bucket_qs.update(has_unused=1)
-                else:
-                    # 激活转移的套餐
-                    unused = new_unused_uid_bucket[0]
-                    endTime = CommonService.calcMonthLater(unused['expire'])
-                    # 判断是否有已过期套餐
-                    if UID_Bucket.objects.filter(uid=new_uid).exists():
-                        UID_Bucket.objects.filter(uid=new_uid).update(status=1, orderId=orderID, updateTime=nowTime,
-                                                                      use_status=1, has_unused=0, endTime=endTime,
-                                                                      bucket_id=unused['bucket_id'],
-                                                                      channel=unused['channel'],
-                                                                      addTime=unused['addTime'])
-                    data_dict = {
-                        'uid': new_uid,
-                        'channel': unused['channel'],
-                        'bucket_id': unused['bucket_id'],
-                        'addTime': unused['addTime'],
-                        'endTime': endTime,
-                        'updateTime': nowTime,
-                        'status': 1,
-                        'use_status': 1,
-                        'has_unused': 0,
-                        'orderId': unused['order_id']
-                    }
-                    UID_Bucket.objects.create(**data_dict)  # 正在使用套餐表添加数据
-                    if unused['is_ai']:  # 开通AI服务
-                        new_aiservice = AiService.objects.filter(uid=new_uid)
-                        if new_aiservice.filter(use_status=1 or 0).exists():
-                            return response.json(10014)
-                        if new_aiservice.exists():
-                            new_aiservice.update(channel=unused['channel'], detect_status=1, addTime=nowTime,
-                                                 updTime=nowTime, endTime=endTime, use_status=1,
-                                                 orders_id=unused['order_id'])
+        try:
+            orderID = request_dict.get("orderID", None)
+            old_uid = request_dict.get("old_uid", None)
+            new_uid = request_dict.get("new_uid", None)
+            nowTime = int(time.time())
+            if not all([orderID, old_uid, new_uid]):
+                return response.json(444)
+
+            # 查订单表查看订单类型
+            order_type = Order_Model.objects.values_list('order_type', flat=True).get(orderID=orderID)
+            if order_type not in [0, 1]:
+                return response.json(10017)
+
+            # 查老设备 orderID
+            old_using_uid_bucket = UID_Bucket.objects.filter(orderId=orderID)
+            old_unusing_uid_bucket = Unused_Uid_Meal.objects.filter(order_id=orderID)
+            if old_using_uid_bucket.exists():
+                if old_using_uid_bucket.first().endTime < nowTime:
+                    return response.json(10013)
+            else:
+                if not old_unusing_uid_bucket.exists():
+                    return response.json(10017)
+
+            # 订单套餐未使用
+            if old_unusing_uid_bucket.exists():
+                with transaction.atomic():
+                    # 旧设备不包含 ai
+                    if old_unusing_uid_bucket.filter(is_ai=1).exists():
+                        new_uid_set = UidSetModel.objects.filter(uid=new_uid).values('is_ai')
+                        if new_uid_set[0]['is_ai'] == 2:
+                            return response.json(10016)
+                    old_unusing_uid_bucket.update(uid=new_uid)
+                    new_unused_uid_bucket = Unused_Uid_Meal.objects.filter(order_id=orderID).values(
+                        'id', 'channel', 'bucket_id', 'addTime', 'expire', 'is_ai', 'order_id'
+                    )
+
+                    # 转移后如果没有未使用套餐则把 has_unused 改为 0
+                    unused_uid_meal_qs = Unused_Uid_Meal.objects.filter(uid=old_uid)
+                    if not unused_uid_meal_qs.exists():
+                        UID_Bucket.objects.filter(uid=old_uid).update(has_unused=0)
+
+                    # 判断新设备是否有正在使用的套餐
+                    new_uid_bucket_qs = UID_Bucket.objects.filter(uid=new_uid, endTime__gte=nowTime, use_status=1)
+                    if new_uid_bucket_qs.exists():
+                        new_uid_bucket_qs.update(has_unused=1)
+                    else:
+                        # 激活转移的套餐
+                        unused = new_unused_uid_bucket[0]
+                        endTime = CommonService.calcMonthLater(unused['expire'])
+                        # 判断是否有已过期套餐
+                        if UID_Bucket.objects.filter(uid=new_uid).exists():
+                            UID_Bucket.objects.filter(uid=new_uid).update(status=1, orderId=orderID, updateTime=nowTime,
+                                                                          use_status=1, has_unused=0, endTime=endTime,
+                                                                          bucket_id=unused['bucket_id'],
+                                                                          channel=unused['channel'])
+                            new_bucket_id = UID_Bucket.objects.filter(uid=new_uid).first().id
                         else:
-                            AiService.objects.create(uid=new_uid, channel=unused['channel'], detect_status=1,
-                                                     addTime=nowTime,
+                            data_dict = {
+                                'uid': new_uid,
+                                'channel': unused['channel'],
+                                'bucket_id': unused['bucket_id'],
+                                'addTime': unused['addTime'],
+                                'endTime': endTime,
+                                'updateTime': nowTime,
+                                'status': 1,
+                                'use_status': 1,
+                                'has_unused': 0,
+                                'orderId': orderID
+                            }
+                            new_bucket = UID_Bucket.objects.create(**data_dict)  # 正在使用套餐表添加数据
+                            new_bucket_id = new_bucket.id
+
+                        if unused['is_ai']:  # 开通AI服务
+                            new_aiservice = AiService.objects.filter(uid=new_uid)
+                            if new_aiservice.filter(use_status=1 or 0).exists():
+                                return response.json(10014)
+                            if new_aiservice.exists():
+                                new_aiservice.update(channel=unused['channel'], detect_status=1, addTime=nowTime,
                                                      updTime=nowTime, endTime=endTime, use_status=1,
                                                      orders_id=unused['order_id'])
+                            else:
+                                AiService.objects.create(uid=new_uid, channel=unused['channel'], detect_status=1,
+                                                         addTime=nowTime,
+                                                         updTime=nowTime, endTime=endTime, use_status=1,
+                                                         orders_id=unused['order_id'])
 
-                    Unused_Uid_Meal.objects.filter(order_id=orderID).first().delete()
+                        Unused_Uid_Meal.objects.filter(order_id=orderID).delete()
 
-                # 修改订单表
-                Order_Model.objects.filter(orderID=orderID).update(UID=new_uid, updTime=nowTime)
+                    # 修改订单表
+                    Order_Model.objects.filter(orderID=orderID).update(UID=new_uid, updTime=nowTime,
+                                                                       uid_bucket_id=int(new_bucket_id))
 
-        # 订单套餐已使用
-        else:
-            old_using_uid_bucket = old_using_uid_bucket.values('id', 'bucket_id', 'has_unused',
-                                                               'bucket__content').order_by('addTime')
-            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)
-
-            # 查询转入设备是否存在正在使用的套餐
-            new_using_uid_bucket = UID_Bucket.objects.filter(uid=new_uid, endTime__gte=nowTime).first()
-            is_delete = 0
-            if new_using_uid_bucket:
-                vod_bucket = VodBucketModel.objects.get(id=new_using_uid_bucket.bucket_id)
-                if vod_bucket.is_free:
-                    # 是免费套餐则删除
-                    is_delete = 1
-                else:
-                    # 非免费套餐不可转移
-                    return response.json(10014)
-            with transaction.atomic():
-                if is_delete == 1:
-                    if AiService.objects.filter(orders_id=orderID).exists():
-                        ai_service = AiService.objects.filter(uid=old_uid).first()
-                        if ai_service:
-                            ai_service.delete()
-                    new_using_uid_bucket.delete()
-                # 如果转出设备有未使用套餐,更改第一个未使用套餐为正在使用
-                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,
-                        'orderId': unused['order_id']
-                    }
-                    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'])
-
-                # 更新正在使用套餐的uid,重置拥有未使用套餐
-                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)
-                # 修改订单表
-                Order_Model.objects.filter(orderID=orderID).update(UID=new_uid, updTime=nowTime)
-
-        ip = CommonService.get_ip_address(request)
-        content = json.loads(json.dumps(request_dict))
-        log = {
-            'ip': ip,
-            'user_id': 1,
-            'status': 200,
-            'time': int(time.time()),
-            'url': 'cloudTransfer/mealTransfer',
-            'content': json.dumps(content),
-            'operation': f'订单号:{orderID}套餐从设备{old_uid}转移到设备{new_uid}'
-        }
-        LogModel.objects.create(**log)
-        return response.json(0)
+            # 订单套餐已使用
+            else:
+                old_using_uid_bucket = old_using_uid_bucket.values('id', 'bucket_id', 'has_unused',
+                                                                   'bucket__content').order_by('addTime')
+                old_ai_service = AiService.objects.filter(uid=old_uid, endTime__gte=nowTime, use_status=1).values('id',
+                                                                                                                  'detect_interval',
+                                                                                                                  'detect_status',
+                                                                                                                  'detect_group')
+
+                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)
+
+                # 查询转入设备是否存在正在使用的套餐
+                new_using_uid_bucket = UID_Bucket.objects.filter(uid=new_uid, endTime__gte=nowTime).first()
+                is_delete = 0
+                if new_using_uid_bucket:
+                    vod_bucket = VodBucketModel.objects.get(id=new_using_uid_bucket.bucket_id)
+                    if vod_bucket.is_free:
+                        # 是免费套餐则删除
+                        is_delete = 1
+                    else:
+                        # 非免费套餐不可转移
+                        return response.json(10014)
+                with transaction.atomic():
+                    if is_delete == 1:
+                        if AiService.objects.filter(orders_id=orderID).exists():
+                            ai_service = AiService.objects.filter(uid=old_uid).first()
+                            if ai_service:
+                                ai_service.delete()
+                        new_using_uid_bucket.delete()
+
+                    # 更新正在使用套餐的uid,重置拥有未使用套餐
+                    old_using_uid_bucket_id = old_using_uid_bucket[0]['id']
+                    ord_uid_bucket = UID_Bucket.objects.filter(id=old_using_uid_bucket_id).first()
+                    # 旧套餐云存转移到新设备
+                    if ord_uid_bucket:
+                        if not UID_Bucket.objects.filter(uid=new_uid).exists():
+                            new_bucket = UID_Bucket.objects.create(
+                                uid=new_uid,
+                                channel=ord_uid_bucket.channel,
+                                bucket_id=ord_uid_bucket.bucket_id,
+                                addTime=nowTime,
+                                endTime=ord_uid_bucket.endTime,
+                                updateTime=nowTime,
+                                status=1,
+                                use_status=1,
+                                has_unused=0,
+                                orderId=orderID
+                            )
+                            new_bucket_id = new_bucket.id
+                        else:
+                            UID_Bucket.objects.filter(uid=new_uid).update(
+                                bucket_id=ord_uid_bucket.bucket_id,
+                                addTime=nowTime,
+                                endTime=ord_uid_bucket.endTime,
+                                updateTime=nowTime,
+                                status=1,
+                                use_status=1,
+                                has_unused=0,
+                                orderId=orderID
+                            )
+                            new_bucket_id = UID_Bucket.objects.filter(uid=new_uid).first().id
+                        # 修改旧设备正在使用中套餐
+                        ord_order = Order_Model.objects.filter(UID=old_uid).exclude(
+                            orderID=orderID).order_by("-addTime").first()
+                        # ord_device_has_unused 如果放在 旧套餐保存旧orderID之后 会发生改变所以提前保持变量
+                        ord_device_has_unused = old_using_uid_bucket[0]['has_unused']
+                        # 旧套餐保存旧orderID
+                        if ord_order:
+                            ord_uid_bucket.orderId = ord_order.orderID
+                            ord_uid_bucket.save()
+                        elif not ord_order and ord_uid_bucket["has_unused"] == 0:
+                            ord_uid_bucket.delete()
+                    else:
+                        return response.json(10017)
+                    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)
+                    # 如果转出设备有未使用套餐,更改第一个未使用套餐为正在使用
+                    if ord_device_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'])
+                        UID_Bucket.objects.filter(id=old_using_uid_bucket_id).update(bucket_id=unused['bucket_id'],
+                                                                                     addTime=unused['addTime'],
+                                                                                     endTime=endTime,
+                                                                                     updateTime=nowTime, status=1,
+                                                                                     use_status=1,
+                                                                                     has_unused=has_unused,
+                                                                                     orderId=unused['order_id'])
+                        Unused_Uid_Meal.objects.filter(order_id=unused['order_id']).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'])
+
+                    # 修改订单表
+                    Order_Model.objects.filter(orderID=orderID).update(UID=new_uid, updTime=nowTime,
+                                                                       uid_bucket_id=int(new_bucket_id))
+
+            ip = CommonService.get_ip_address(request)
+            content = json.loads(json.dumps(request_dict))
+            log = {
+                'ip': ip,
+                'user_id': 1,
+                'status': 200,
+                'time': int(time.time()),
+                'url': 'serveManagement/mealTransfer',
+                'content': json.dumps(content),
+                'operation': f'订单号:{orderID}套餐从设备{old_uid}转移到设备{new_uid}'
+            }
+            LogModel.objects.create(**log)
+            return response.json(0)
+
+        except Exception as e:
+            print(e)
+            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
 
     @classmethod
     def getCloudUserList(cls, request_dict, response):