上线联通100M测试流量

AdminController/UnicomManageController.py

@@ -101,7 +101,7 @@ class UnicomManageControllerView(View):
                 return self.package_cdk_export_excel(response)
             elif operation == 'uploadSerialNumberFile':  # 上传序列号文件绑定4G套餐
                 return self.upload_file(tko.user, request, request_dict, response)
-            elif operation == 'iccidBatchReset':  # 上传序列号文件绑定4G套餐
+            elif operation == 'iccidBatchReset':  # 批量重置流量
                 return self.iccid_batch_reset(tko.user, request, request_dict, response)
             elif operation == 'orderFlowPackage':  # 订购流量套餐包
                 return self.order_flow_package(request_dict, response, userID)
@@ -115,7 +115,7 @@ class UnicomManageControllerView(View):
                 return response.json(404)
 
     @classmethod
-    def order_flow_package(cls, request_dict, response, user):
+    def order_flow_package(cls, request_dict, response, user_id):
         """
         订购流量套餐包
         """
@@ -124,35 +124,11 @@ class UnicomManageControllerView(View):
             package_id = request_dict.get('packageId', None)
             if not all([serial_number, package_id]):
                 return response.json(444)
-            u_device_info_qs = UnicomDeviceInfo.objects.filter(serial_no=serial_number, card_type=0) \
-                .exclude(Q(user_id__isnull=True) | Q(user_id=''))
-            if not u_device_info_qs.exists():
-                return response.json(173)
-            package_id = int(package_id)
-            combo_qs = UnicomCombo.objects.filter(id=package_id) \
-                .values('id', 'combo_name', 'price', 'virtual_price', 'remark').order_by('sort')
-            if not combo_qs.exists():
-                return response.json(173)
-
-            now_time = int(time.time())
-            combo_info_vo = combo_qs[0]
-            u_device_info = u_device_info_qs.first()
-            rank_id, ai_rank_id = UnicomComboView.get_cloud_or_ai_combo()  # 生成订单必须添加该字段
-            uid = CommonService.query_uid_with_serial(serial_number)
-
-            order_id = CommonService.createOrderID()
-            order_dict = {'orderID': order_id, 'UID': uid, 'rank_id': rank_id, 'ai_rank_id': ai_rank_id,
-                          'userID_id': u_device_info.user_id, 'desc': combo_info_vo['combo_name'], 'payType': 10,
-                          'payTime': now_time, 'price': combo_info_vo['price'], 'addTime': now_time,
-                          'updTime': now_time, 'status': 1,
-                          'unify_combo_id': str(combo_info_vo['id']), 'order_type': 2,
-                          'store_meal_name': combo_info_vo['combo_name']
-                          }
-            Order_Model.objects.create(**order_dict)
-            LOGGER.info(f'{serial_number}订购流量套餐包,createdBy：{user}')
-            UnicomComboView.create_combo_order_info(order_id, 0, u_device_info.iccid, package_id)
-            if u_device_info.status != 2:
-                UnicomDeviceInfo.objects.filter(iccid=u_device_info.iccid).update(status=2, updated_time=now_time)
+            serial_number = serial_number[0:9]
+            result = UnicomComboView().generate_flow_package(serial_number, int(package_id), user_id)
+            LOGGER.info(f'{serial_number}订购流量套餐包,createdBy:{user_id},result:{result}')
+            if not result:
+                response.json(503)
             return response.json(0)
         except Exception as e:
             LOGGER.info('UnicomManageControllerView.order_flow_package,errLine:{}, errMsg:{}'
@@ -161,6 +137,14 @@ class UnicomManageControllerView(View):
 
     @classmethod
     def reset_card_package(cls, request, request_dict, response, user):
+        """
+        iccid单卡重置流量
+        @param request: 请求体
+        @param request_dict: 请求参数
+        @param response: 响应体
+        @param user: 用户名称
+        @return: 重置结果
+        """
         try:
             serial_number = request_dict.get('serialNumber', None)
             if not serial_number:
@@ -180,6 +164,7 @@ class UnicomManageControllerView(View):
                     res = wx_tech.delete_card_package(**data)
                     if res['code'] == '0':
                         UnicomComboExperienceHistory.objects.filter(iccid=iccid).delete()
+                        LOGGER.info(f"{serial_number}电信重置流量成功:{json.loads(response.text)}")
                         return response.json(0)
                     return response.json(176)
                 flow_push_qs = UnicomFlowPush.objects.filter(serial_no=serial_number)
@@ -189,16 +174,17 @@ class UnicomManageControllerView(View):
                 if sys_msg_qs.exists():  # 删除有关系统消息数据
                     sys_msg_qs.delete()
                 # 将4G用户信息状态改为已完成测试状态
-                device_info_qs.update(status=1, updated_time=now_time, user_id='')
+                device_info_qs.update(status=2, updated_time=now_time, user_id='')
                 combo_order_qs = UnicomComboOrderInfo.objects.filter(iccid=iccid)
                 if combo_order_qs.exists():
                     combo_order_qs.delete()
                 combo_experience_history_qs = UnicomComboExperienceHistory.objects.filter(iccid=iccid)
                 if combo_experience_history_qs.exists():
                     combo_experience_history_qs.delete()
-                UnicomObjeect().change_device_to_disable(iccid)  # 重置流量停用设备
+                # UnicomObjeect().change_device_to_disable(iccid)  # 重置流量停用设备
+                result = UnicomComboView().activate_test_flow_package(serial_number)
                 ip = CommonService.get_ip_address(request)
-                describe = '重置4G流量序列号{}，iccid:{}'.format(serial_number, iccid)
+                describe = '重置4G流量序列号{},iccid:{},{}'.format(serial_number, iccid, result)
                 key = f'ASJ:UNICOM:CARD:ACTIVATE:{serial_number}'
                 redis = RedisObject()
                 redis.del_data(key)

Controller/EquipmentManager.py

@@ -824,6 +824,10 @@ def deleteInterface(request):
                 # 删除推送消息
                 del_eq_info_thread = threading.Thread(target=ModelService.del_user_list_eq_info,
                                                       args=(user_id_list, userID, uid))
+                # 清除ICCID用户信息
+                iccid_info_qs = UnicomDeviceInfo.objects.filter(serial_no=serial_number, user_id=userID)
+                if iccid_info_qs:
+                    iccid_info_qs.update(status=2, updated_time=int(time.time()), user_id='')
             else:
                 Device_Info.objects.filter(UID=uid, userID_id=userID).delete()
                 UidPushModel.objects.filter(uid_set__uid=uid, userID_id=userID).delete()

Controller/EquipmentManagerV3.py

@@ -395,17 +395,20 @@ class EquipmentManagerV3(View):
             unicom_device_info_qs = UnicomDeviceInfo.objects.filter(serial_no=serial_number, card_type=0)
             if not unicom_device_info_qs.exists():
                 return False
-            if unicom_device_info_qs.first().status == 1:  # 已测试
-                # 领取4G体验套餐
-                res = UnicomComboView.user_activate_flow(unicom_device_info_qs[0].iccid)
-                logging.info('{}联通领取体验流量:{}'.format(unicom_device_info_qs[0].iccid, res))
-                WXTechControllerView.activate_flow_package(serial_number, 'system', user_id)
-            if not unicom_device_info_qs[0].user_id:
-                # 生成4G免费订单
-                UnicomComboView.experience_order_4G(unicom_device_info_qs[0].iccid,
-                                                    serial_number, user_id, False)
-                UnicomDeviceInfo.objects.filter(iccid=unicom_device_info_qs[0].iccid) \
-                    .update(user_id=user_id, updated_time=int(time.time()))
+            unicom_device_info_qs.update(user_id=user_id, updated_time=int(time.time()))
+            LOGGER.info('{}更新4G用户信息成功:{}'.format(serial_number, user_id))
+
+            # if unicom_device_info_qs.first().status == 1:  # 已测试
+            #     # 领取4G体验套餐
+            #     res = UnicomComboView.user_activate_flow(unicom_device_info_qs[0].iccid)
+            #     logging.info('{}联通领取体验流量:{}'.format(unicom_device_info_qs[0].iccid, res))
+            #     WXTechControllerView.activate_flow_package(serial_number, 'system', user_id)
+            # if not unicom_device_info_qs[0].user_id:
+            #     # 生成4G免费订单
+            #     UnicomComboView.experience_order_4G(unicom_device_info_qs[0].iccid,
+            #                                         serial_number, user_id, False)
+            #     UnicomDeviceInfo.objects.filter(iccid=unicom_device_info_qs[0].iccid) \
+            #         .update(user_id=user_id, updated_time=int(time.time()))
             return True
         except Exception as e:
             logging.info('创建体验4G订单异常,errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
@@ -1133,6 +1136,11 @@ class EquipmentManagerV3(View):
             # 异步删除推送消息
             for val in range(1, 8):
                 EquipmentInfoService.get_equipment_info_model('', val).filter(device_uid=uid).delete()
+            serial_number = CommonService.get_serial_number_by_uid(uid)
+            # 删除iccid用户信息
+            iccid_info_qs = UnicomDeviceInfo.objects.filter(serial_no=serial_number)
+            if iccid_info_qs:
+                iccid_info_qs.update(status=2, updated_time=int(time.time()), user_id='')
         except Exception as e:
             LOGGER.info('EquipmentManagerV3.async_del_message,{},error_line:{}, error_msg:{}'
                         .format(uid, e.__traceback__.tb_lineno, repr(e)))

Controller/SerialNumberController.py

@@ -15,11 +15,10 @@ from Controller.UnicomCombo.UnicomComboController import UnicomComboView
 from Model.models import SerialNumberModel, CompanySerialModel, UIDCompanySerialModel, UIDModel, Device_Info, \
     iotdeviceInfoModel, LogModel, UidSetModel, UID_Bucket, \
     Unused_Uid_Meal, Order_Model, StsCrdModel, VodHlsModel, ExperienceContextModel, UidUserModel, ExperienceAiModel, \
-    AiService, DeviceDomainRegionModel, RegionModel, UidPushModel, UnicomDeviceInfo
+    AiService, DeviceDomainRegionModel, RegionModel, UidPushModel
 from Object.AWS.S3Email import S3Email
 from Object.RedisObject import RedisObject
 from Object.TokenObject import TokenObject
-from Object.UnicomObject import UnicomObjeect
 from Object.uidManageResponseObject import uidManageResponseObject
 from Service.AlgorithmService import AlgorithmBaseOn35
 from Service.CommonService import CommonService
@@ -606,7 +605,7 @@ class SerialNumberView(View):
 
         try:
             if company_serial.status == 0 or company_serial.status == 1:  # 未使用
-                self.is_4g_device(serial_number, request_dict, request)
+                UnicomComboView().is_4g_device(serial_number, request_dict, request)
                 return response.json(173)
             elif company_serial.status == 2:  # 返回uid
                 res = self.get_uid_info_by_serial(company_serial.id)
@@ -901,32 +900,3 @@ class SerialNumberView(View):
         except Exception as e:
             LOGGER.info('{}同步iot异常,errLine:{}, errMsg:{}'.format(serial_number, e.__traceback__.tb_lineno, repr(e)))
             return False
-
-    @staticmethod
-    def is_4g_device(serial_number, request_dict, request):
-        """
-        判断是否4G设备
-        """
-        try:
-            serial_no = serial_number[0:9]
-            key = f'ASJ:UNICOM:CARD:ACTIVATE:{serial_no}'
-            redis = RedisObject()
-            if redis.get_data(key):
-                return True
-            # 根据序列号查询联通iccid
-            unicom_qs = UnicomDeviceInfo.objects.filter(serial_no=serial_no, status=1, card_type=0) \
-                .values('iccid', 'status')
-            if not unicom_qs.exists():
-                return False
-            unicom_qs = unicom_qs.first()
-            unicom_api = UnicomObjeect()
-            unicom_api.change_device_to_activate(unicom_qs['iccid'])
-            redis.CONN.setnx(key, str(unicom_qs['iccid']))
-            redis.CONN.expire(key, 7200)  # 已调用过激活两个小时内不可调用
-            ip = CommonService.get_ip_address(request)
-            describe = '{}获取uid请求激活4G卡,{}'.format(serial_no, unicom_qs['iccid'])
-            UnicomComboView().create_operation_log('serialNumber/get-uid', ip, request_dict, describe)
-            return True
-        except Exception as e:
-            LOGGER.info('{}判断是否4G设备异常,errLine:{}, errMsg:{}'.format(serial_number, e.__traceback__.tb_lineno, repr(e)))
-            return False

Controller/UnicomCombo/UnicomComboController.py

@@ -20,8 +20,8 @@ from django.views.generic.base import View
 
 from Ansjer.config import LOGGER
 from Model.models import UnicomDeviceInfo, UnicomCombo, Pay_Type, Order_Model, Store_Meal, AiStoreMeal, \
-    UnicomComboOrderInfo, UnicomComboExperienceHistory, UnicomDeviceStatusChangePush, SysMsgModel, UnicomFlowPush, \
-    LogModel, DeviceLiveRestrict, SerialNumberPackage
+    UnicomComboOrderInfo, UnicomComboExperienceHistory, UnicomDeviceStatusChangePush, SysMsgModel, LogModel, \
+    DeviceLiveRestrict
 from Object.EIoTClubObject import EIoTClubObject
 from Object.Enums.WXOperatorEnum import WXOperatorEnum
 from Object.RedisObject import RedisObject
@@ -285,56 +285,12 @@ class UnicomComboView(View):
             return response.json(444)
         logger.info('PC工具进入重置SIM卡{}'.format(serial_no))
         try:
-            if not CommonService.check_time_stamp_token(sign, time_stamp):
-                return response.json(13)
-            now_time = int(time.time())
-            redis = RedisObject()
-            with transaction.atomic():
-                device_info_qs = UnicomDeviceInfo.objects.filter(serial_no=serial_no)
-                if not device_info_qs.exists():  # 首先查询SIM卡绑定信息是否存在
-                    return response.json(173)
-                iccid = device_info_qs.first().iccid
-                if device_info_qs.first().card_type == 1:
-                    cls.reset_telecom_user(serial_no)
-                    device_info_qs.update(updated_time=now_time, user_id='')
-                    return response.json(0)
-                # 根据序列号重置出厂流量套餐
-                serial_package_qs = SerialNumberPackage.objects.filter(~Q(status=1), serial_number=serial_no)
-                if serial_package_qs.exists():
-                    serial_package_qs.update(status=1, updated_time=now_time, updated_by='operator')
-
-                flow_push_qs = UnicomFlowPush.objects.filter(serial_no=serial_no)
-                if flow_push_qs.exists():  # 删除流量预警推送
-                    flow_push_qs.delete()
-                sys_msg_qs = SysMsgModel.objects.filter(uid=serial_no)
-                if sys_msg_qs.exists():  # 删除有关系统消息数据
-                    sys_msg_qs.delete()
-
-                device_info_qs.update(status=1, updated_time=now_time, user_id='')
-                combo_order_qs = UnicomComboOrderInfo.objects.filter(iccid=iccid)
-                order_list = []
-                if combo_order_qs.exists():
-                    for item in combo_order_qs:
-                        if item.order_id:
-                            order_list.append(item.order_id)
-                    combo_order_qs.delete()
-                combo_experience_history_qs = UnicomComboExperienceHistory.objects.filter(iccid=iccid)
-                if combo_experience_history_qs.exists():
-                    combo_experience_history_qs.delete()
-
-                UnicomObjeect().change_device_to_disable(iccid)
-                logger.info('4GResetFlow相关订单号：{}'.format(order_list))
-                describe = '重置4G流量序列号{}，iccid:{}'.format(serial_no, iccid)
-                key = f'ASJ:UNICOM:CARD:ACTIVATE:{serial_no}'
-                redis.del_data(key)
-                ip = CommonService.get_ip_address(request)
-                cls.create_operation_log('unicom/api/device-status', ip, request_dict, describe)
-                return response.json(0)
+            return response.json(10072)
         except Exception as e:
             print(e.args)
             ex = traceback.format_exc()
             print(ex)
-            logger.info('PC工具重置异常ICCID{}，msg={}'.format(iccid, ex))
+            logger.info('PC工具重置异常ICCID{}，msg={}'.format(serial_no, ex))
             return response.json(177, ex)
 
     @staticmethod
@@ -413,44 +369,52 @@ class UnicomComboView(View):
         n_time = int(time.time())
         try:
             logger.info('--->参数验证通过，sign验证通过')
-            with transaction.atomic():
-                ip = CommonService.get_ip_address(request)
-                # 待完善代码 根据uid与用户id验证系统设备mdcmd
-                unicom_device_qs = UnicomDeviceInfo.objects.filter(iccid=iccid)
-                if unicom_device_qs.exists():
-                    if unicom_device_qs.first().serial_no != serial_no:
-                        unicom_device_qs.update(main_card=sim, updated_time=n_time, serial_no=serial_no)
-                        cls.create_operation_log('unicom/api/device-bind',
-                                                 ip, request_dict, '4G序列号{}新绑定{}'.format(serial_no, iccid))
-                    elif unicom_device_qs.first().main_card != sim:
-                        unicom_device_qs.update(main_card=sim, updated_time=n_time)
-                    return response.json(0)
-                if sim == 0:
-                    return response.json(0, '外置卡不保存相关信息{}'.format(serial_no))
-                params = {'iccid': iccid, 'serial_no': serial_no, 'updated_time': n_time,
-                          'created_time': n_time, 'main_card': sim}
-                if cls.is_unicom_sim(iccid):  # 联通卡
-                    UnicomDeviceInfo.objects.create(**params)
+            ip = CommonService.get_ip_address(request)
+            # 待完善代码 根据uid与用户id验证系统设备mdcmd
+            unicom_device_qs = UnicomDeviceInfo.objects.filter(iccid=iccid)
+            if unicom_device_qs.exists():
+                if unicom_device_qs.first().serial_no != serial_no:
+                    unicom_device_qs.update(main_card=sim, updated_time=n_time, serial_no=serial_no)
                     cls.create_operation_log('unicom/api/device-bind',
-                                             ip, request_dict, '4G序列号{}绑定{}'.format(serial_no, iccid))
-                    return response.json(0)
-                elif cls.is_dingxin_iot(iccid):  # 鼎芯物联卡
-                    params['card_type'] = 5  # 国际
-                    params['status'] = 2
-                    UnicomDeviceInfo.objects.create(**params)
-                    return response.json(0)
-                elif cls.check_iccid(iccid):  # 五兴物联卡
-                    params['card_type'] = 1
+                                             ip, request_dict, '4G序列号{}新绑定{}'.format(serial_no, iccid))
+                elif unicom_device_qs.first().main_card != sim:
+                    unicom_device_qs.update(main_card=sim, updated_time=n_time)
+                return response.json(0)
+            params = {'iccid': iccid, 'serial_no': serial_no, 'updated_time': n_time,
+                      'created_time': n_time, 'main_card': sim}
+            if sim == 0:
+                if cls.is_dingxin_iot(iccid):  # 鼎芯物联卡
+                    params['card_type'] = 5
                     params['status'] = 2
                     UnicomDeviceInfo.objects.create(**params)
-                    return response.json(0)
-                else:
-                    logger.info('--->设备请求绑定{}验证失败'.format(iccid))
-                    return response.json(173)
+                    cls.create_operation_log('unicom/api/device-bind',
+                                             ip, request_dict, '4G序列号{}新绑定鼎芯{}'.format(serial_no, iccid))
+                return response.json(0, '外置卡不保存相关信息{}'.format(serial_no))
+
+            if cls.is_unicom_sim(iccid):  # 联通卡
+                UnicomDeviceInfo.objects.create(**params)
+                result = cls.activate_test_flow_package(serial_no)
+                cls.create_operation_log('unicom/api/device-bind',
+                                         ip, request_dict,
+                                         '4G序列号{}绑定{},testFlowPackage{}'.format(serial_no, iccid, result))
+                return response.json(0)
+            elif cls.is_dingxin_iot(iccid):  # 鼎芯物联卡
+                params['card_type'] = 5  # 国际
+                params['status'] = 2
+                UnicomDeviceInfo.objects.create(**params)
+                return response.json(0)
+            elif cls.check_iccid(iccid):  # 五兴物联卡
+                params['card_type'] = 1
+                params['status'] = 2
+                UnicomDeviceInfo.objects.create(**params)
+                return response.json(0)
+            else:
+                logger.info('--->设备请求绑定{}验证失败'.format(iccid))
+                return response.json(173)
         except Exception as e:
             print(e)
             ex = traceback.format_exc()
-            logger.info('--->设备调用4G注册接口异常:{}'.format(ex))
+            logger.info('UnicomComboView.iccid_bind_serial_no error{}'.format(ex))
             return response.json(177, repr(e))
 
     @classmethod
@@ -1036,3 +1000,104 @@ class UnicomComboView(View):
         except Exception as e:
             print('日志异常,errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
             return response.json(0)
+
+    @classmethod
+    def activate_test_flow_package(cls, serial_number):
+        """
+        激活测试流量套餐（100M）
+        @return: 成功 | 失败
+        """
+        flow_combo_qs = UnicomCombo.objects.filter(combo_type=4, is_del=False)
+        if not flow_combo_qs:
+            return False
+        package_id = flow_combo_qs.first().id
+        return cls.generate_flow_package(serial_number, package_id, '151564262337939513800138001')
+
+    @classmethod
+    def generate_flow_package(cls, serial_number, package_id, user_id):
+        """
+        生成联通流量套餐包
+        @param serial_number: 序列号
+        @param package_id: 套餐id
+        @param user_id: 用户id
+        @return: True | False
+        """
+        try:
+            u_device_info_qs = UnicomDeviceInfo.objects.filter(serial_no=serial_number, card_type=0)
+            if not u_device_info_qs.exists():
+                LOGGER.info(f'{serial_number}生成联通流量套餐iccid未绑定')
+                return False
+            combo_qs = UnicomCombo.objects.filter(id=package_id) \
+                .values('id', 'combo_name', 'price', 'virtual_price', 'remark').order_by('sort')
+            if not combo_qs.exists():
+                LOGGER.info(f'{serial_number}生成联通流量套餐不存在')
+                return False
+            now_time = int(time.time())
+            combo_info_vo = combo_qs[0]
+            u_device_info = u_device_info_qs.first()
+            rank_id, ai_rank_id = UnicomComboView.get_cloud_or_ai_combo()  # 生成订单必须添加该字段
+            uid = CommonService.get_uid_by_serial_number(serial_number)
+            if u_device_info.user_id:
+                user_id = u_device_info.user_id
+            order_id = CommonService.createOrderID()
+            order_dict = {'orderID': order_id, 'UID': uid, 'rank_id': rank_id, 'ai_rank_id': ai_rank_id,
+                          'userID_id': user_id, 'desc': combo_info_vo['combo_name'], 'payType': 10,
+                          'payTime': now_time, 'price': combo_info_vo['price'], 'addTime': now_time,
+                          'updTime': now_time, 'status': 1,
+                          'unify_combo_id': str(combo_info_vo['id']), 'order_type': 2,
+                          'store_meal_name': combo_info_vo['combo_name']
+                          }
+            Order_Model.objects.create(**order_dict)
+            UnicomComboView.create_combo_order_info(order_id, 0, u_device_info.iccid, package_id)
+            if u_device_info.status != 2:
+                UnicomDeviceInfo.objects.filter(iccid=u_device_info.iccid).update(status=2, updated_time=now_time)
+            LOGGER.info(f'{serial_number}生成流量套餐包成功,createdBy：{user_id}')
+            return True
+        except Exception as e:
+            LOGGER.info('UnicomManageControllerView.order_flow_package,{}errLine:{}, errMsg:{}'
+                        .format(serial_number, e.__traceback__.tb_lineno, repr(e)))
+            return False
+
+    @staticmethod
+    def is_4g_device(serial_number, request_dict, request):
+        """
+        序列号未绑定UID时调用
+        判断是否4G设备（如卡停用，判断是否符合激活测试流量）
+        为了解决序列号解绑UID后，测试流量用完客户出现无法添加
+        增加赠送5M测试流量
+        """
+        try:
+            serial_no = serial_number[0:9]
+            key = f'ASJ:UNICOM:CARD:ACTIVATE:{serial_no}'
+            redis = RedisObject()
+            LOGGER.info(f'UnicomComboView.is_4g_device:{serial_no}')
+            if redis.get_data(key):
+                return True
+            # 根据序列号查询联通iccid
+            unicom_qs = UnicomDeviceInfo.objects.filter(serial_no=serial_no, card_type=0) \
+                .values('iccid', 'status')
+            if not unicom_qs.exists():
+                return False
+            # 针对库存设备，此步骤激活测试流量
+            unicom_qs = unicom_qs[0]
+
+            order_package = UnicomComboOrderInfo.objects.filter(iccid=unicom_qs['iccid'], status=1)
+            if not order_package:  # 当前iccid不存在正在使用的套餐
+                # 查询出厂其它测试流量（特殊套餐5M为了解决客户停卡添加设备）
+                flow_combo_qs = UnicomCombo.objects.filter(combo_type=5, is_del=False)
+                if not flow_combo_qs:
+                    return False
+
+                package_id = flow_combo_qs.first().id
+                UnicomComboView().generate_flow_package(serial_no, package_id, '151564262337939513800138001')
+                redis.CONN.setnx(key, str(unicom_qs['iccid']))
+                redis.CONN.expire(key, 3600)  # 当天赠送过测试流量的设备缓存24小时
+                ip = CommonService.get_ip_address(request)
+                describe = '{}获取uid请求激活4G卡,{}'.format(serial_no, unicom_qs['iccid'])
+                UnicomComboView().create_operation_log('serialNumber/get-uid', ip, request_dict, describe)
+                return True
+            LOGGER.info(f'{serial_no}有正在使用的套餐')
+            return True
+        except Exception as e:
+            LOGGER.info('{}判断是否4G设备异常,errLine:{}, errMsg:{}'.format(serial_number, e.__traceback__.tb_lineno, repr(e)))
+            return False

Controller/UnicomCombo/UnicomComboTaskController.py

@@ -267,51 +267,70 @@ class UnicomComboTaskView(View):
         @param response:
         @return:
         """
-        logger.info('--->进入监控流量到期停卡或激活叠加包')
+        logger.info('check_flow_expire进入监控流量到期停卡或激活叠加包')
         now_time = int(time.time())
         combo_order_qs = UnicomComboOrderInfo.objects.filter(~Q(status=2), expire_time__lte=now_time,
                                                              is_del=False).values()
+        if not combo_order_qs.exists():
+            return response.json(0)
+        asy = threading.Thread(target=UnicomComboTaskView.async_deactivate_expire_package,
+                               args=(combo_order_qs, now_time))
+        asy.start()
+        return response.json(0)
+
+    @staticmethod
+    def async_deactivate_expire_package(combo_order_qs, now_time):
+        """
+        异步停用过期套餐
+        @param combo_order_qs: 过期套餐querySet
+        @param now_time 当前实际
+        """
         today = datetime.datetime.today()
         year = today.year
         month = today.month
-        if not combo_order_qs.exists():
-            return response.json(0)
+
         iccid_list = []
-        with transaction.atomic():
-            for item in combo_order_qs:
-                try:
-                    icc_id = item['iccid']
-                    um_device_qs = UnicomDeviceInfo.objects.filter(iccid=icc_id)
-                    if not um_device_qs.exists():
-                        continue
-                    UnicomComboOrderInfo.objects.filter(id=item['id']).update(status=2, updated_time=now_time)
-                    iccid_list.append(icc_id)
-                    logger.info('--->当前流量套餐已过期，iccid:{}'.format(icc_id))
-                except Exception as e:
-                    logger.info('出错了~监控流量到期异常,errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
+        for item in combo_order_qs:
+            try:
+                icc_id = item['iccid']
+                um_device_qs = UnicomDeviceInfo.objects.filter(iccid=icc_id)
+                if not um_device_qs.exists():
                     continue
+                UnicomComboOrderInfo.objects.filter(id=item['id']).update(status=2, updated_time=now_time)
+                iccid_list.append(icc_id)
+                logger.info('修改套餐已失效成功,iccid:{}'.format(icc_id))
+            except Exception as e:
+                logger.info('async_deactivate_expire_package套餐过期修改失效异常,{}'
+                            'errLine:{}, errMsg:{}'.format(item['iccid'], e.__traceback__.tb_lineno, repr(e)))
+                continue
         # set无序不重复元素集
         iccid_list = list(set(iccid_list))
         unicom_api = UnicomObjeect()
         for item in iccid_list:
-            activate_combo_qs = UnicomComboOrderInfo.objects.filter(iccid=item, status=1, expire_time__gt=now_time,
-                                                                    is_del=False).values()
-            if activate_combo_qs.exists():
+            try:
+                activate_combo_qs = UnicomComboOrderInfo.objects.filter(iccid=item, status=1, expire_time__gt=now_time,
+                                                                        is_del=False).values()
+                if activate_combo_qs.exists():
+                    continue
+                usage_flow = unicom_api.get_flow_usage_total(item)
+                # 查询是否有未使用套餐，有则进行激活 否 则调用API停卡
+                result = UnicomComboTaskView().query_unused_combo_and_activate(item, year, month, usage_flow)
+                if not result:  # 没有可用套餐进行停卡
+                    # 停用设备
+                    unicom_api.change_device_to_disable(item)
+                    logger.info('调用停卡API successful,iccid:{}'.format(item))
+                    combo_order_info_qs = UnicomComboOrderInfo.objects.filter(iccid=item, status=2) \
+                        .values('id').order_by('-updated_time')
+                    combo_order = combo_order_info_qs.first()
+                    asy = threading.Thread(target=UnicomComboTaskView.async_combo_sys_msg_push,
+                                           args=(item, combo_order['id'], 4))
+                    asy.start()
+                else:
+                    unicom_api.change_device_to_activate(item)
+            except Exception as e:
+                logger.info('async_deactivate_expire_package套餐过期停卡异常,{}'
+                            'errLine:{}, errMsg:{}'.format(item, e.__traceback__.tb_lineno, repr(e)))
                 continue
-            usage_flow = unicom_api.get_flow_usage_total(item)
-            result = cls.query_unused_combo_and_activate(item, year, month, usage_flow)
-            if not result:
-                # 停用设备
-                unicom_api.change_device_to_disable(item)
-                combo_order_info_qs = UnicomComboOrderInfo.objects.filter(iccid=item, status=2) \
-                    .values('id').order_by('-updated_time')
-                combo_order = combo_order_info_qs.first()
-                asy = threading.Thread(target=UnicomComboTaskView.async_combo_sys_msg_push,
-                                       args=(icc_id, combo_order['id'], 4))
-                asy.start()
-            else:
-                unicom_api.change_device_to_activate(item)
-        return response.json(0)
 
     @staticmethod
     def async_combo_sys_msg_push(iccid, combo_order_id, push_type):

Controller/UnicomCombo/WXTechController.py

@@ -64,7 +64,7 @@ class WXTechControllerView(View):
         elif operation == 'getExperiencePackage':
             return self.get_experience_package(request_dict, response)
         elif operation == 'createOrder':
-            return self.create_order_package(user_id, request_dict, response)
+            return self.create_order_package(user_id, request_dict, response, request)
         elif operation == 'exchangePackage':
             return self.wx_exchange_package(request_dict, response, request, user_id)
         elif operation == 'getPackageBySerialNumber':
@@ -155,7 +155,7 @@ class WXTechControllerView(View):
             return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
 
     @classmethod
-    def create_order_package(cls, user_id, request_dict, response):
+    def create_order_package(cls, user_id, request_dict, response, request):
         """
         五兴电信领取1G15天流量体验包
         """
@@ -167,7 +167,7 @@ class WXTechControllerView(View):
                 return response.json(444)
             serial_no = serial_no[0:9]
             unicom_device_qs = UnicomDeviceInfo.objects.filter(serial_no=serial_no) \
-                .values('serial_no', 'user_id', 'iccid')
+                .values('serial_no', 'user_id', 'iccid', 'card_type')
             if not unicom_device_qs.exists():
                 return response.json(173)
             unicom_device_qs = unicom_device_qs.first()
@@ -176,21 +176,39 @@ class WXTechControllerView(View):
             experience_history_qs = UnicomComboExperienceHistory.objects.filter(iccid=iccid)
             if experience_history_qs.exists():
                 return response.json(10062)
-            data = {'iccid': iccid, 'operator': WXOperatorEnum(int(operator)).value,
-                    'startType': str(WXStartTypeEnum.EFFECTIVE_IMMEDIATELY.value), 'packageCode': COMBO_ID}
-            wx_tech = WXTechObject()
-            # 请求五兴API创建套餐接口
-            res = wx_tech.create_order_package(**data)
-            LOGGER.info('*****五兴创建体验套餐信息:{}'.format(res))
-            if res['code'] == '0':
-                trade_no = res['data']['orderNumber']
-                experience_history_vo = {'iccid': iccid, 'experience_type': 0, 'do_time': int(time.time())}
-                UnicomComboExperienceHistory.objects.create(**experience_history_vo)
-                order_res = cls.created_order(serial_no, user_id, trade_no, pay_type=10)
-                UnicomDeviceInfo.objects.filter(serial_no=serial_no) \
-                    .update(user_id=user_id, updated_time=int(time.time()))
-                LOGGER.info('*****系统创建体验订单:{}'.format(order_res))
+            ip = CommonService.get_ip_address(request)
+            experience_history_vo = {'iccid': iccid, 'experience_type': 0, 'do_time': int(time.time())}
+            if unicom_device_qs['card_type'] == 0:  # 珠海联通
+
+                flow_combo_qs = UnicomCombo.objects.filter(combo_type=1, is_del=False, status=0).order_by('sort')
+                app_user_id = unicom_device_qs['user_id'] if unicom_device_qs['user_id'] else user_id
+                free_result = False
+                if flow_combo_qs.exists():
+                    # 生成免费体验套餐
+                    free_result = UnicomComboView() \
+                        .generate_flow_package(serial_no, flow_combo_qs.first().id, app_user_id)
+                    UnicomComboExperienceHistory.objects.create(**experience_history_vo)
+                if not unicom_device_qs['user_id']:
+                    UnicomDeviceInfo.objects.filter(iccid=iccid) \
+                        .update(user_id=app_user_id, updated_time=int(time.time()))
+                factory_result = cls.activate_flow_package(serial_no, ip, app_user_id)  # 检测并激活出厂无限流量
+                cls.save_log(ip, 0, '{}激活免费套餐{},出厂无限流量{}'.format(serial_no, free_result, factory_result))
                 return response.json(0)
+            elif unicom_device_qs['card_type'] == 1:  # 五兴电信
+                data = {'iccid': iccid, 'operator': WXOperatorEnum(int(operator)).value,
+                        'startType': str(WXStartTypeEnum.EFFECTIVE_IMMEDIATELY.value), 'packageCode': COMBO_ID}
+                wx_tech = WXTechObject()
+                # 请求五兴API创建套餐接口
+                res = wx_tech.create_order_package(**data)
+                LOGGER.info('*****五兴创建体验套餐信息:{}'.format(res))
+                if res['code'] == '0':
+                    trade_no = res['data']['orderNumber']
+                    UnicomComboExperienceHistory.objects.create(**experience_history_vo)
+                    order_res = cls.created_order(serial_no, user_id, trade_no, pay_type=10)
+                    UnicomDeviceInfo.objects.filter(serial_no=serial_no) \
+                        .update(user_id=user_id, updated_time=int(time.time()))
+                    LOGGER.info('*****系统创建体验订单:{}'.format(order_res))
+                    return response.json(0)
             return response.json(10063)
         except Exception as e:
             LOGGER.info('*****WXTechController.create_order_package:errLine:{}, errMsg:{}'

Object/ResponseObject.py

@@ -143,7 +143,8 @@ class ResponseObject(object):
             10069: 'If the traffic is abnormal, check the data plan or contact customer service',
             10070: 'This device sharing limit has been reached',
             503: 'The operation failed, please try again later',
-            10071: 'The successful collection can be viewed in Settings - 4G-My package'
+            10071: 'The successful collection can be viewed in Settings - 4G-My package',
+            10072: 'This function has been disabled. Please contact the administrator'
         }
         data_cn = {
             0: '成功',
@@ -273,7 +274,8 @@ class ResponseObject(object):
             10069: '流量异常，请查看流量套餐情况或联系客服',
             10070: '此设备分享已达上限',
             503: '操作失败，请稍后重试',
-            10071: '\t领取成功\n可在设置-4G-我的套餐中查看'
+            10071: '\t领取成功\n可在设置-4G-我的套餐中查看',
+            10072: '该功能已停用,请联系管理员'
         }
 
         msg = data_cn if self.lang == 'cn' or self.lang == 'zh-Hans' or self.lang == 'zh-Hant' else data_en

Service/CommonService.py

@@ -12,6 +12,7 @@ import requests
 import simplejson as json
 from dateutil.relativedelta import relativedelta
 from django.core import serializers
+from django.db.models import F
 from django.utils import timezone
 from django.utils.crypto import constant_time_compare
 from pyipip import IPIPDatabase
@@ -19,7 +20,7 @@ from pyipip import IPIPDatabase
 from Ansjer.config import BASE_DIR, SERVER_DOMAIN_SSL, CONFIG_INFO, CONFIG_TEST, CONFIG_CN, SERVER_DOMAIN_TEST, \
     SERVER_DOMAIN_CN, SERVER_DOMAIN_US, CONFIG_US, CONFIG_EUR, SERVER_DOMAIN_LIST, SERVER_DOMAIN_EUR
 from Controller.CheckUserData import RandomStr
-from Model.models import iotdeviceInfoModel, Device_Info, UIDModel, AppDeviceType
+from Model.models import iotdeviceInfoModel, Device_Info, UIDModel, AppDeviceType, UIDCompanySerialModel
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
 
@@ -783,4 +784,32 @@ GCqvlyw5dfxNA+EtxNE2wCW/LW7ENJlACgcfgPlBZtpLheWoZB/maw4=
                 version_list.append(version)
             else:
                 continue
-        return version_list
+        return version_list
+
+    @staticmethod
+    def get_uid_by_serial_number(serial_number):
+        """
+        根据序列号获取绑定uid
+        @param serial_number: 9位序列号
+        @return: uid信息
+        """
+        c_serial_qs = UIDCompanySerialModel.objects.filter(company_serial__serial_number=serial_number[0:6])
+        if not c_serial_qs.exists():
+            return serial_number
+        c_serial_info = c_serial_qs.values('uid__uid')
+        return c_serial_info[0]['uid__uid']
+
+    @staticmethod
+    def get_serial_number_by_uid(uid):
+        """
+        根据序列号获取绑定uid
+        @param uid: uid
+        @return: uid信息
+        """
+        c_serial_qs = UIDCompanySerialModel.objects.filter(uid__uid=uid)
+        if not c_serial_qs.exists():
+            return uid
+        c_serial_qs = c_serial_qs.annotate(mark=F('company_serial__company__mark'),
+                                           serial_number=F('company_serial__serial_number'))
+        c_serial_info = c_serial_qs.values('mark', 'serial_number')
+        return c_serial_info[0]['serial_number'] + c_serial_info[0]['mark']