ASJServer/Controller/EquipmentManagerV3.py

import base64
import json
import logging
import re
import threading
import time

import oss2
import requests
from django.db import transaction
from django.db.models import Q, Max
from django.views.generic.base import View

from Ansjer.config import CONFIG_INFO, CONFIG_US
from Controller.CheckUserData import RandomStr
from Controller.DeviceConfirmRegion import Device_Region
from Controller.SensorGateway.EquipmentFamilyController import EquipmentFamilyView
from Controller.UnicomCombo.UnicomComboController import UnicomComboView
from Controller.UnicomCombo.WXTechController import WXTechControllerView
from Controller.UserDevice.DeviceVersionInfoController import DeviceVersionInfoView
from Model.models import Device_Info, UID_Bucket, UID_Preview, UidSetModel, UidChannelSetModel, \
    Device_User, iotdeviceInfoModel, UIDCompanySerialModel, UnicomDeviceInfo, CountryModel, \
    DeviceCloudPhotoInfo, UidPushModel, ExperienceContextModel, LogModel, UserAudioVideoPush, UIDModel
from Object.RedisObject import RedisObject
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject
from Service.CommonService import CommonService
from Service.EquipmentInfoService import EquipmentInfoService
from Service.ModelService import ModelService
from Service.UserDeviceService import UserDeviceService
from django.conf import settings
ALICLOUD_AK = settings.ALICLOUD_AK
ALICLOUD_SK = settings.ALICLOUD_SK
LOGGER = logging.getLogger('info')


class EquipmentManagerV3(View):

    def get(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        operation = kwargs.get('operation')
        return self.validation(request.GET, request, operation)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'

        operation = kwargs.get('operation')
        return self.validation(request.POST, request, operation)

    def validation(self, request_dict, request, operation):
        response = ResponseObject()

        if operation == 'notLoginMainUserDevice':
            return self.not_login_do_mainUserDevice(request_dict, response)
        elif operation == 'notLoginMainDelDevice':
            return self.test_tool_del_device(request_dict, response)
        elif operation == 'changeDevicePassword':
            return self.change_device_password(request_dict, response)
        elif operation == 'modifyChannelName':
            return self.do_modify_channel_name(request_dict, response)
        elif operation == 'updateLinkedChannel':
            return self.update_linked_channel(request_dict, response)

        token = request_dict.get('token', None)
        tko = TokenObject(token)
        if tko.code != 0:
            return response.json(tko.code)
        response.lang = tko.lang
        userID = tko.userID
        # 手机端添加设备，查询，修改
        if operation == 'add':
            return self.do_add(userID, request_dict, response, request)
        if operation == 'batchAdd':
            return self.do_batch_add(userID, request_dict, response, request)
        elif operation == 'query':
            return self.do_query(userID, request_dict, response)
        elif operation == 'modify':
            return self.do_modify(userID, request_dict, response, request)
        elif operation == 'fuzzyQuery':
            return self.do_fuzzy_query(userID, request_dict, response)
        elif operation == 'mainUserDevice':
            return self.do_mainUserDevice(request_dict, response, userID)
        elif operation == 'getDeviceFeatures':
            return self.do_get_device_features(request_dict, response)
        elif operation == 'deviceRouse':
            return self.device_rouse(request_dict, response)
        elif operation == 'saveButtonUser':
            return self.save_button_user(request_dict, response)
        elif operation == 'getButtonUser':
            return self.get_button_user(request_dict, response)
        elif operation == 'verifyCode':
            return self.verify_code(request_dict, response)
        elif operation == 'viewDevicePassword':
            return self.view_device_password(request_dict, response)
        elif operation == 'editSortOrder':
            return self.edit_sort_order(userID, request_dict, response)
        elif operation == 'getDeviceListByUserId':  # 根据用户id获取设备UID、设备名称列表
            return self.get_device_list_by_user_id(userID, response)
        elif operation == 'getDeviceDetailByUid': # 根据用户id获取设备详情
            return self.get_device_detail_by_uid(userID, request_dict, response)
        else:
            return response.json(414)

    @classmethod
    def device_rouse(cls, request_dict, response):
        """
        设备唤醒
        """
        serial_number = request_dict.get('serialNumber', None)
        if not serial_number:
            return response.json(444)
        try:
            # 主题名称
            topic_name = f'/wakeup/{serial_number}_0'
            # 发布消息内容
            msg = {'payload': 'A'}
            result = CommonService.req_publish_mqtt_msg(serial_number, topic_name, msg)
            if not result:
                return response.json(10044)
            return response.json(0)
        except Exception as e:
            LOGGER.info('****设备唤醒发布消息异常:{},{}'.format(serial_number, repr(e)))
            return response.json(500, repr(e))

    def do_add(self, userID, request_dict, response, request):
        UID = request_dict.get('UID', None)
        NickName = request_dict.get('NickName', None)
        View_Account = request_dict.get('View_Account', None)
        View_Password = request_dict.get('View_Password', '')
        encrypt_pass = View_Password
        Type = request_dict.get('Type', None)
        ChannelIndex = request_dict.get('ChannelIndex', None)
        version = request_dict.get('version', '')
        isCheckMainUser = request_dict.get('isCheckMainUser', None)

        family_id = request_dict.get('familyId', None)
        room_id = request_dict.get('roomId', None)

        m_code = request_dict.get('m_code', None)
        appBundleId = request_dict.get('appBundleId', None)
        app_type = request_dict.get('app_type', None)
        push_type = request_dict.get('push_type', None)
        token_val = request_dict.get('token_val', None)
        jg_token_val = request_dict.get('jg_token_val', '')
        lang = request_dict.get('lang', 'en')
        tz = request_dict.get('tz', '0')

        if not NickName:
            NickName = UID[:6]

        if not all([UID, NickName, View_Account, Type, ChannelIndex]):  # Type和ChannelIndex可能为0
            return response.json(444, {'param': 'UID, NickName, View_Account, Type, ChannelIndex'})

        if tz == '':
            tz = 0
        else:
            tz = tz.replace("GMT", "")
        Type = int(Type)
        ChannelIndex = int(ChannelIndex)

        re_uid = re.compile(r'^[A-Za-z0-9]{14,20}$')
        if not re_uid.match(UID):
            return response.json(444, {'param': 'UID'})

        device_info_qs = Device_Info.objects.filter(UID=UID, userID_id=userID)
        if device_info_qs:
            # 判断设备是否已存在
            if device_info_qs[0].isExist == 1:
                return response.json(174)
            else:
                device_info_qs.delete()

        dvr_type_list = [1, 2, 3, 4, 300, 10001]
        View_Password = '' if Type in dvr_type_list else 'admin'

        id = CommonService.getUserID(getUser=False)
        device_user_qs = Device_User.objects.filter(userID=userID).values('username')
        if not device_user_qs.exists():
            return response.json(173)

        uid_status = UIDModel.objects.filter(uid=UID).values('status').first()
        if uid_status and uid_status['status'] == 0:
            return response.json(10076)

        userName = device_user_qs[0]['username']
        main_exist = Device_Info.objects.filter(UID=UID)
        main_exist = main_exist.filter(~Q(vodPrimaryUserID='')).values('vodPrimaryUserID', 'vodPrimaryMaster')

        vodPrimaryUserID = userID
        vodPrimaryMaster = userName
        primaryUserID = ''
        primaryMaster = ''
        isShare = False

        is_bind = Device_Info.objects.filter(UID=UID, isShare=False).values('userID__userID', 'primaryUserID',
                                                                            'primaryMaster')

        if main_exist.exists():
            vodPrimaryUserID = main_exist[0]['vodPrimaryUserID']
            vodPrimaryMaster = main_exist[0]['vodPrimaryMaster']

        if is_bind.exists():
            primaryUserID = is_bind[0]['primaryUserID']
            primaryMaster = is_bind[0]['primaryMaster']
            isShare = True

        isusermain = False
        if (vodPrimaryUserID != userID and vodPrimaryUserID != '') or (primaryUserID != userID and primaryUserID != ''):
            isusermain = True

        # 判断是否有已绑定用户
        if isCheckMainUser == '1' and isusermain:
            res = {
                'id': id,
                'userID': userID,
                'NickName': NickName,
                'UID': UID,
                'View_Account': View_Account,
                'View_Password': View_Password,
                'ChannelIndex': ChannelIndex,
                'Type': Type,
                'isShare': isShare,
                'primaryUserID': primaryUserID,
                'primaryMaster': primaryMaster,
                'vodPrimaryUserID': vodPrimaryUserID,
                'vodPrimaryMaster': vodPrimaryMaster,
                'data_joined': '',
                'version': version,
                'isVod': 0,
                'isExist': 1,
                'userID__userEmail': ''
            }
            res['vod'] = [
                {
                    "status": 1,
                    "channel": ChannelIndex,
                    "endTime": '',
                    "bucket__content": '',
                    "uid": UID
                }
            ]
            res['isMainUserExists'] = 1
            LOGGER.info('add设备已绑定其他用户uid:{} type:{} 主:{} Now:{} nickName:{}'
                        .format(UID, Type, vodPrimaryUserID, userID, NickName))
            return response.json(0, res)

        # 日志数据
        username = CommonService.get_username(userID)
        nowTime = int(time.time())
        ip = CommonService.get_ip_address(request)
        content = json.loads(json.dumps(request_dict))
        log = {
            'ip': ip,
            'user_id': 1,
            'status': 200,
            'time': nowTime,
            'content': json.dumps(content),
            'url': 'v3/equipment/add',
            'operation': '{}添加{}成功'.format(username, UID)
        }

        try:
            with transaction.atomic():
                # 判断是否有用户绑定
                us_qs = UidSetModel.objects.filter(uid=UID)
                if us_qs.exists():
                    us_qs.update(nickname=NickName, device_type=Type)
                    UidSet_id = us_qs.first().id
                else:
                    ipInfo = CommonService.getIpIpInfo(ip, 'CN')
                    country_qs = CountryModel.objects.filter(country_code=ipInfo['country_code']).values('id')
                    country = country_qs.exists() if country_qs[0]['id'] else 0
                    region_id = Device_Region().get_device_region(ip)
                    region_alexa = 'CN' if region_id == 1 else 'ALL'
                    uid_set_create_dict = {
                        'uid': UID,
                        'addTime': nowTime,
                        'updTime': nowTime,
                        'ip': ip,
                        'channel': ChannelIndex,
                        'nickname': NickName,
                        'version': version,
                        'region_alexa': region_alexa,
                        'device_type': Type,
                        'tb_country': country
                    }
                    UidSet = UidSetModel.objects.create(**uid_set_create_dict)
                    UidSet_id = UidSet.id

                if all([token_val, m_code, appBundleId, app_type]):
                    uid_push_qs = UidPushModel.objects.filter(userID_id=userID, m_code=m_code, uid_set__uid=UID)
                    if uid_push_qs.exists():
                        uid_push_update_dict = {
                            'appBundleId': appBundleId,
                            'app_type': app_type,
                            'push_type': push_type,
                            'token_val': token_val,
                            'jg_token_val': jg_token_val,
                            'updTime': nowTime,
                            'lang': lang,
                            'tz': tz
                        }
                        uid_push_qs.update(**uid_push_update_dict)
                    else:
                        uid_push_create_dict = {
                            'uid_set_id': UidSet_id,
                            'userID_id': userID,
                            'appBundleId': appBundleId,
                            'app_type': app_type,
                            'push_type': push_type,
                            'token_val': token_val,
                            'jg_token_val': jg_token_val,
                            'm_code': m_code,
                            'addTime': nowTime,
                            'updTime': nowTime,
                            'lang': lang,
                            'tz': tz
                        }
                        # 绑定设备推送
                        UidPushModel.objects.create(**uid_push_create_dict)
                # 查询uid_channel表有无该uid的数据
                uid_channel_set = UidChannelSetModel.objects.filter(uid_id=UidSet_id)
                if not uid_channel_set.exists():
                    # 多通道设备设置通道名
                    if Type in dvr_type_list:
                        UidChannelSet_bulk = []
                        for i in range(1, ChannelIndex + 1):
                            channel_name = 'Channel ' + str(i)  # Channel 1,Channel 2...
                            UidChannelSet = UidChannelSetModel(uid_id=UidSet_id, channel=i, channel_name=channel_name)
                            UidChannelSet_bulk.append(UidChannelSet)
                        UidChannelSetModel.objects.bulk_create(UidChannelSet_bulk)

                # 获取当前用户下最大 sort_order
                max_sort_order = Device_Info.objects.filter(userID_id=userID).aggregate(
                    Max('sort_order'))['sort_order__max'] or 0
                userDevice = Device_Info(id=id, userID_id=userID, UID=UID, NickName=NickName, View_Account=View_Account,
                                         View_Password=View_Password, Type=Type, ChannelIndex=ChannelIndex,
                                         version=version,
                                         vodPrimaryUserID=vodPrimaryUserID, vodPrimaryMaster=vodPrimaryMaster,
                                         sort_order=max_sort_order + 1)
                userDevice.save()
                # 保存用户推送按钮信息
                button_qs = UserAudioVideoPush.objects.filter(uid=UID)
                if button_qs.exists():
                    button_qs.update(buttonUser1=userID, buttonUser2=userID)
                else:
                    UserAudioVideoPush.objects.create(uid=UID, buttonUser1=userID, buttonUser2=userID,
                                                      created_time=nowTime, updated_time=nowTime)
                # 添加到家庭房间
                if family_id:
                    EquipmentFamilyView.family_room_device_save(family_id, room_id, userDevice.id, Type)

                uid_serial_qs = UIDCompanySerialModel.objects.filter(uid__uid=UID)
                if uid_serial_qs.exists():
                    uid_serial = uid_serial_qs[0]
                    serial_number = uid_serial.company_serial.serial_number + uid_serial.company_serial.company.mark
                    Device_Info.objects.filter(UID=UID).update(vodPrimaryUserID=vodPrimaryUserID,
                                                               vodPrimaryMaster=vodPrimaryMaster,
                                                               serial_number=serial_number)
                    self.unicom_user_info_save(userID, serial_number)
                else:
                    Device_Info.objects.filter(UID=UID).update(vodPrimaryUserID=vodPrimaryUserID,
                                                               vodPrimaryMaster=vodPrimaryMaster)

                if not us_qs.exists():
                    us_qs = UidSetModel.objects.filter(uid=UID)

                if us_qs.exists() and us_qs[0].is_alexa == 1:
                    if us_qs[0].channel > 1:
                        data_list = []
                        uid_channel_set_qs = UidChannelSetModel.objects.filter(uid_id=us_qs[0].id). \
                            values('channel', 'channel_name')
                        if uid_channel_set_qs.exists():
                            # 多通道设备名为 UidChannelSetModel 的 channel_name
                            for uid_channel_set in uid_channel_set_qs:
                                data_list.append(
                                    {'userID': userID, 'UID': UID, 'uid_nick': uid_channel_set['channel_name'],
                                     'channel': uid_channel_set['channel'], 'password': encrypt_pass})
                    else:
                        data_list = [{'userID': userID, 'UID': UID, 'uid_nick': NickName, 'password': encrypt_pass}]

                    # 请求Alexa服务器更新事件网关
                    CommonService.update_alexa_events(data_list)

                # 记录添加日志
                LogModel.objects.create(**log)
        except Exception as e:
            # 记录添加失败日志
            error_msg = 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e))
            operation = '{}添加{}失败:{}'.format(username, UID, error_msg)
            log['operation'] = operation
            LogModel.objects.create(**log)
            return response.json(10, error_msg)
        else:
            dvqs = Device_Info.objects.filter(id=id).values('id', 'userID', 'NickName', 'UID',
                                                            'View_Account',
                                                            'View_Password', 'ChannelIndex', 'Type',
                                                            'isShare',
                                                            'primaryUserID', 'primaryMaster',
                                                            'vodPrimaryUserID', 'vodPrimaryMaster',
                                                            'userID__userEmail',
                                                            'data_joined', 'version',
                                                            'isVod', 'isExist', 'isCameraOpenCloud', 'serial_number')
            dvql = CommonService.qs_to_list(dvqs)
            ubqs = UID_Bucket.objects.filter(uid=UID). \
                values('bucket__content', 'status', 'channel', 'endTime', 'uid')
            res = dvql[0]
            res['vod'] = list(ubqs)

            iotqs = iotdeviceInfoModel.objects.filter(serial_number=dvql[0]['serial_number'])
            if iotqs.exists():
                res['iot'] = {
                    'endpoint': iotqs[0].endpoint,
                    'token_iot_number': iotqs[0].endpoint
                }

            # 存在序列号返回完整序列号
            if res['serial_number']:
                res['serial_number'] = CommonService.get_full_serial_number(UID, res['serial_number'], Type)

            return response.json(0, res)

    @classmethod
    def unicom_user_info_save(cls, user_id, serial_number):
        """
        保存联通与用户信息绑定
        @param user_id: 用户id
        @param serial_number: 序列号
        @return: True | False
        """
        try:
            # 根据序列号查询联通iccid
            unicom_device_info_qs = UnicomDeviceInfo.objects.filter(serial_no=serial_number, card_type=0)
            if not unicom_device_info_qs.exists():
                return False
            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)))
            return False

    def do_batch_add(self, userID, request_dict, response, request):
        # 批量添加设备
        uidContent = request_dict.get('uidContent', None)
        family_id = request_dict.get('familyId', None)
        room_id = request_dict.get('roomId', None)

        if not uidContent:
            return response.json(444, {'param': 'uidContent'})

        try:
            deviceNumber = 0  # 添加成功数量
            add_success_flag = False  # 添加成功标识
            exception_flag = False  # 异常标识
            exists_flag = False  # 已存在标识
            uid_content_list = eval(uidContent)
            print('uidContent: ', uid_content_list)
            re_uid = re.compile(r'^[A-Za-z0-9]{14,20}$')
            for uid_content in uid_content_list:
                exception_flag = False  # 重置异常标识
                exists_flag = False  # 已存在标识
                UID = uid_content['uid']
                NickName = uid_content['nickName']
                Type = uid_content['type']
                ChannelIndex = uid_content['channelIndex']
                version = uid_content['version']
                isCheckMainUser = uid_content['isCheckMainUser']
                View_Account = uid_content['viewAccount']
                encryptPassword = uid_content['encryptPassword']
                View_Password = self.decode_pwd(encryptPassword)
                if not all([UID, NickName, View_Account]):  # Type和ChannelIndex可能为0
                    return response.json(444, {'param': 'UID, NickName, View_Account'})

                if not re_uid.match(UID):  # 检查uid长度
                    return response.json(444, {'error uid length': UID})

                device_info_qs = Device_Info.objects.filter(UID=UID, userID_id=userID)
                if device_info_qs:
                    # 判断设备是否已存在
                    if device_info_qs[0].isExist == 1:
                        exists_res = {UID: 'device already exists!'}
                        exists_flag = True
                        continue
                    else:
                        device_info_qs.delete()

                id = CommonService.getUserID(getUser=False)
                device_user_qs = Device_User.objects.filter(userID=userID).values('username')
                if not device_user_qs.exists():
                    return response.json(173)
                userName = device_user_qs[0]['username']
                main_exist = Device_Info.objects.filter(UID=UID)
                main_exist = main_exist.filter(~Q(vodPrimaryUserID='')).values('vodPrimaryUserID', 'vodPrimaryMaster')

                vodPrimaryUserID = userID
                vodPrimaryMaster = userName
                primaryUserID = ''
                primaryMaster = ''
                isShare = False

                is_bind = Device_Info.objects.filter(UID=UID, isShare=False).values('userID__userID', 'primaryUserID',
                                                                                    'primaryMaster', 'Type')

                if main_exist.exists():
                    vodPrimaryUserID = main_exist[0]['vodPrimaryUserID']
                    vodPrimaryMaster = main_exist[0]['vodPrimaryMaster']

                if is_bind.exists():
                    primaryUserID = is_bind[0]['primaryUserID']
                    primaryMaster = is_bind[0]['primaryMaster']
                    isShare = True

                isusermain = False
                if (vodPrimaryUserID != userID and vodPrimaryUserID != '') or (
                        primaryUserID != userID and primaryUserID != ''):
                    isusermain = True

                # 判断是否有已绑定用户
                if isCheckMainUser == 1 and isusermain:
                    res = {
                        'id': id,
                        'userID': userID,
                        'NickName': NickName,
                        'UID': UID,
                        'View_Account': View_Account,
                        'View_Password': View_Password,
                        'ChannelIndex': ChannelIndex,
                        'Type': Type,
                        'isShare': isShare,
                        'primaryUserID': primaryUserID,
                        'primaryMaster': primaryMaster,
                        'vodPrimaryUserID': vodPrimaryUserID,
                        'vodPrimaryMaster': vodPrimaryMaster,
                        'data_joined': '',
                        'version': version,
                        'isVod': 0,
                        'isExist': 1,
                        'userID__userEmail': ''
                    }
                    res['vod'] = [
                        {
                            "status": 1,
                            "channel": ChannelIndex,
                            "endTime": '',
                            "bucket__content": '',
                            "uid": UID
                        }
                    ]
                    res['isMainUserExists'] = 1
                    continue

                # 判断是否有用户绑定
                nowTime = int(time.time())
                us_qs = UidSetModel.objects.filter(uid=UID)
                if us_qs.exists():
                    us_qs.update(nickname=NickName)
                    UidSet_id = us_qs.first().id
                else:
                    ip = CommonService.get_ip_address(request)
                    ipInfo = CommonService.getIpIpInfo(ip, 'CN')
                    country_qs = CountryModel.objects.filter(country_code=ipInfo['country_code']).values('id')
                    country = country_qs.exists() if country_qs[0]['id'] else 0
                    region_id = Device_Region().get_device_region(ip)
                    region_alexa = 'CN' if region_id == 1 else 'ALL'
                    uid_set_create_dict = {
                        'uid': UID,
                        'addTime': nowTime,
                        'updTime': nowTime,
                        'ip': CommonService.get_ip_address(request_dict),
                        'channel': ChannelIndex,
                        'nickname': NickName,
                        'version': version,
                        'region_alexa': region_alexa,
                        'device_type': is_bind[0]['Type'] if is_bind.exists() else int(Type),
                        'tb_country': country
                    }
                    UidSet = UidSetModel.objects.create(**uid_set_create_dict)
                    UidSet_id = UidSet.id

                # 查询uid_channel表有无该uid的数据
                uid_channel_set = UidChannelSetModel.objects.filter(uid_id=UidSet_id)
                if not uid_channel_set.exists():
                    # 多通道设备设置通道名
                    multi_channel_list = [1, 2, 3, 4, 10001]
                    if Type in multi_channel_list:
                        UidChannelSet_bulk = []
                        for i in range(1, ChannelIndex + 1):
                            channel_name = 'channel' + str(i)  # channel1,channel2...
                            UidChannelSet = UidChannelSetModel(uid_id=UidSet_id, channel=i, channel_name=channel_name)
                            UidChannelSet_bulk.append(UidChannelSet)
                        UidChannelSetModel.objects.bulk_create(UidChannelSet_bulk)

                userDevice = Device_Info(id=id, userID_id=userID, UID=UID, NickName=NickName, View_Account=View_Account,
                                         View_Password=View_Password, Type=Type, ChannelIndex=ChannelIndex,
                                         version=version,
                                         vodPrimaryUserID=vodPrimaryUserID, vodPrimaryMaster=vodPrimaryMaster)
                userDevice.save()
                # 添加到家庭房间
                if family_id:
                    EquipmentFamilyView.family_room_device_save(family_id, room_id, userDevice.id, Type)
                uid_serial_qs = UIDCompanySerialModel.objects.filter(uid__uid=UID)
                if uid_serial_qs.exists():
                    uid_serial = uid_serial_qs[0]
                    Device_Info.objects.filter(UID=UID).update(vodPrimaryUserID=vodPrimaryUserID,
                                                               vodPrimaryMaster=vodPrimaryMaster,
                                                               serial_number=uid_serial.company_serial.serial_number + uid_serial.company_serial.company.mark)
                else:
                    Device_Info.objects.filter(UID=UID).update(vodPrimaryUserID=vodPrimaryUserID,
                                                               vodPrimaryMaster=vodPrimaryMaster)

                if not us_qs.exists():
                    us_qs = UidSetModel.objects.filter(uid=UID)

                if us_qs.exists() and us_qs[0].is_alexa == 1:
                    if us_qs[0].channel > 1:
                        data_list = []
                        uid_channel_set_qs = UidChannelSetModel.objects.filter(uid_id=us_qs[0].id). \
                            values('channel', 'channel_name')
                        if uid_channel_set_qs.exists():
                            # 多通道设备名为 UidChannelSetModel 的 channel_name
                            for uid_channel_set in uid_channel_set_qs:
                                data_list.append(
                                    {'userID': userID, 'UID': UID, 'uid_nick': uid_channel_set['channel_name'],
                                     'channel': uid_channel_set['channel'], 'password': encryptPassword})
                    else:
                        data_list = [{'userID': userID, 'UID': UID, 'uid_nick': NickName, 'password': encryptPassword}]

                    # 请求Alexa服务器更新事件网关
                    CommonService.update_alexa_events(data_list)

                dvqs = Device_Info.objects.filter(id=id).values('id', 'userID', 'NickName', 'UID',
                                                                'View_Account',
                                                                'View_Password', 'ChannelIndex', 'Type',
                                                                'isShare',
                                                                'primaryUserID', 'primaryMaster',
                                                                'vodPrimaryUserID', 'vodPrimaryMaster',
                                                                'userID__userEmail',
                                                                'data_joined', 'version',
                                                                'isVod', 'isExist', 'isCameraOpenCloud',
                                                                'serial_number')
                dvql = CommonService.qs_to_list(dvqs)
                ubqs = UID_Bucket.objects.filter(uid=UID). \
                    values('bucket__content', 'status', 'channel', 'endTime', 'uid')
                success_res = dvql[0]
                success_res['vod'] = list(ubqs)
                iotqs = iotdeviceInfoModel.objects.filter(serial_number=dvql[0]['serial_number'])
                if iotqs.exists():
                    success_res['iot'] = {'endpoint': iotqs[0].endpoint, 'token_iot_number': iotqs[0].endpoint}
                deviceNumber += 1
                success_res['deviceNumber'] = deviceNumber
                add_success_flag = True
        except Exception as e:
            LOGGER.info('异常详情,errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
            print(e)
            error_res = repr(e)
            exception_flag = True
            pass
        finally:
            if add_success_flag:  # 有一台添加成功则返回成功
                return response.json(0, success_res)
            if exists_flag:  # 全部设备已存在
                return response.json(174, exists_res)
            if exception_flag:
                return response.json(500, error_res)
            return response.json(0, res)

    def do_modify(self, userID, request_dict, response, request):
        token = request_dict.get('token', None)
        deviceContent = request_dict.get('content', None)
        id = request_dict.get('id', None)
        if not deviceContent or not id:
            return response.json(444, 'content,id')
        tko = TokenObject(token)
        response.lang = tko.lang
        if tko.code != 0:
            return response.json(tko.code)
        userID = tko.userID
        if userID is None:
            return response.json(309)

        try:
            deviceData = eval(deviceContent)
            if deviceData.__contains__('userID_id'):
                asy = threading.Thread(target=ModelService.update_log,
                                       args=(CommonService.get_ip_address(request), userID, 'modifyV3', deviceData, id))
                asy.start()
                return response.json(10, '110')

            if deviceData.__contains__('UID'):
                del deviceData['UID']

            dev_info_qs = Device_Info.objects.filter(userID_id=userID, id=id).values('UID')
            if not dev_info_qs.exists():
                return response.json(173)

            view_password = ''
            if deviceData.__contains__('View_Password'):
                encrypt_pwd = deviceData['View_Password']
                view_password = self.decode_pwd(deviceData['View_Password'])
                deviceData['View_Password'] = view_password
                # 记录修改密码日志
                uid = dev_info_qs[0]['UID']
                ip = CommonService.get_ip_address(request)
                content = json.loads(json.dumps(request_dict))
                log = {
                    'user_id': 2,
                    'status': 200,
                    'time': int(time.time()),
                    'url': 'v3/equipment/modify',
                    'content': json.dumps(content),
                    'ip': ip,
                    'operation': '{}修改设备密码:{}'.format(uid, view_password),
                }
                LogModel.objects.create(**log)
            # 更新数据
            dev_info_qs.update(**deviceData)
        except Exception as e:
            print(e)
            return response.json(177, repr(e))
        else:
            qs = Device_Info.objects.filter(userID_id=userID, id=id)
            res = CommonService.qs_to_dict(qs)
            if qs.exists():
                uid = qs[0].UID
                nickname = qs[0].NickName
                # 增加设备影子信息修改昵称 start
                us_qs = UidSetModel.objects.filter(uid=uid)
                if us_qs.exists():
                    if deviceData.__contains__('NickName'):
                        us_qs.update(nickname=nickname)
                else:
                    ip = CommonService.get_ip_address(request)
                    ipInfo = CommonService.getIpIpInfo(ip, 'CN')
                    country_qs = CountryModel.objects.filter(country_code=ipInfo['country_code']).values('id')
                    country = country_qs.exists() if country_qs[0]['id'] else 0
                    ChannelIndex = qs[0].ChannelIndex
                    nowTime = int(time.time())
                    uid_set_create_dict = {
                        'uid': uid,
                        'addTime': nowTime,
                        'updTime': nowTime,
                        'ip': CommonService.get_ip_address(request),
                        'channel': ChannelIndex,
                        'nickname': nickname,
                        'device_type': qs[0].Type,
                        'tb_country': country,
                    }
                    UidSetModel.objects.create(**uid_set_create_dict)
                di_qs = Device_Info.objects.filter(UID=uid)
                di_qs.update(NickName=nickname)

                if deviceData is not None and deviceData.__contains__('NickName') and us_qs[0].is_alexa == 1:
                    # 异步请求Alexa服务器更新事件网关
                    password = encrypt_pwd if deviceData.__contains__('View_Password') else ''
                    data_list = [{'userID': userID, 'UID': uid, 'uid_nick': nickname, 'password': password}]
                    # 请求Alexa服务器更新事件网关
                    CommonService.update_alexa_events(data_list)

            return response.json(0, res)

    @staticmethod
    def do_modify_channel_name(request_dict, response):
        """
        修改通道名
        @param request_dict:
        @param response:
        @return:
        """
        uid = request_dict.get('uid', None)
        channel = request_dict.get('channel', None)
        channel_name = request_dict.get('channel_name', None)
        if not all([uid, channel, channel_name]):
            return response.json(444)
        try:
            # 更新通道名
            channel = int(channel) + 1
            uid_channel_set_qs = UidChannelSetModel.objects.filter(uid__uid=uid, channel=channel)
            if not uid_channel_set_qs.exists():
                return response.json(173)
            uid_channel_set_qs.update(channel_name=channel_name)
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def update_linked_channel(request_dict, response):
        """
        更新连接通道
        @param request_dict:
        @param response:
        @return:
        """
        uid = request_dict.get('uid', None)
        linked_channel = request_dict.get('linked_channel', None)
        if not all([uid, linked_channel]):
            return response.json(444)
        try:
            UidSetModel.objects.filter(uid=uid).update(linked_channel=linked_channel)
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    def do_query(self, userID, request_dict, response):
        """
        首页查询设备列表
        @param userID: 用户id
        @param request_dict: 请求参数
        @param response: 响应结果
        """
        token = request_dict.get('token', None)
        page = request_dict.get('page', None)
        line = request_dict.get('line', None)
        NickName = request_dict.get('NickName', None)
        if not token or not page or not line:
            return response.json(444)
        page = int(page)
        line = int(line)
        uid = request_dict.get('uid', None)
        tko = TokenObject(token)
        response.lang = tko.lang
        if page <= 0:
            return response.json(0)
        if tko.code != 0:
            return response.json(tko.code)
        userID = tko.userID
        UserDeviceService.init_device_sort_order(userID)
        group_id = int(request_dict.get('groupId', 0))
        # 查询设备列表以及设备uid集合
        dv_list, uid_list = UserDeviceService.query_device_list(userID, uid, NickName, page, line, group_id)
        ub_qs = UserDeviceService.query_device_uid_bucket(uid_list)  # 根据uid集合查询云存套餐
        up_qs = UserDeviceService.query_device_preview(uid_list)  # 根据uid集合查询设备预览图
        auth = oss2.Auth(ALICLOUD_AK, ALICLOUD_SK)
        bucket = oss2.Bucket(auth, 'oss-cn-hongkong.aliyuncs.com', 'statres')
        nowTime = int(time.time())
        data = []
        uv_dict = UserDeviceService.query_device_channel(uid_list)  # 查询设备uid通道配置属性
        # 遍历设备列表，查询设备关联数据详情
        for p in dv_list:
            p['UID'] = p['UID'].replace('\n', '').replace('\r', '')
            p_uid = p['UID'].upper()
            UserDeviceService.get_sim_by_serial_number(p)  # 获取SIM卡属性
            p['cloudPhoto'] = self.get_cloud_photo_status(p['UID'])
            # 获取云存使用状态
            p['vod_use_status'] = self.get_vod_use_status(p_uid, nowTime)
            # 获取iot_deviceInfo表的endpoint和token_iot_number
            p['iot'] = []
            if p['serial_number']:  # 存在序列号根据序列号查询
                iotdeviceInfo_qs = iotdeviceInfoModel.objects.filter(serial_number=p['serial_number'][0:6])
            else:  # 根据uid查询
                iotdeviceInfo_qs = iotdeviceInfoModel.objects.filter(uid=p_uid)
            if iotdeviceInfo_qs.exists():
                iotdeviceInfo = iotdeviceInfo_qs.values('endpoint', 'token_iot_number')
                p['iot'].append({
                    'endpoint': iotdeviceInfo[0]['endpoint'],
                    'token_iot_number': iotdeviceInfo[0]['token_iot_number']
                })

            p['vod'] = []
            for dm in ub_qs:
                if p_uid == dm['uid']:
                    if dm['endTime'] > nowTime:
                        p['vod'].append(dm)
            p['preview'] = []
            for up in up_qs:
                if p_uid == up['uid']:
                    obj = 'uid_preview/{uid}/channel_{channel}.png'.format(uid=up['uid'], channel=up['channel'])
                    img_sign = bucket.sign_url('GET', obj, 300)
                    p['preview'].append(img_sign)
            UserDeviceService.get_uid_info(p, p_uid)  # 获取uid初始化信息

            if p_uid in uv_dict:
                # 获取设备信息DTO
                UserDeviceService.get_device_info_dto(p, p_uid, uv_dict, userID)
            else:
                # 设备版本号
                p['uid_version'] = ''
                p['ucode'] = ''
            p['View_Password'] = self.encrypt_pwd(p['View_Password'])

            # 判断设备是否支持4G和查询移动侦测状态
            uid_set_qs = UidSetModel.objects.filter(uid=p['UID']).values('detect_status', 'ucode', 'version')
            if uid_set_qs.exists():
                uid_set_qs = uid_set_qs.first()
                p['has_4g_cloud'] = self.get_device_is_4G(uid_set_qs['ucode'], uid_set_qs['version'])
                if p['has_4g_cloud'] == 1:
                    p['isCameraOpenCloud'] = 1
                p['NotificationMode'] = uid_set_qs['detect_status']
            data.append(p)
        result = data
        return response.json(0, result)

    @staticmethod
    def get_device_is_4G(ucode, ver):
        try:
            if not all([ucode, ver]):
                return 0
            ver = ver.replace('V', '')
            d_ver = DeviceVersionInfoView.cache_device_version_info(ucode, ver)
            if d_ver:
                return 1 if d_ver['has_4g_cloud'] == 1 else 0
            return 0
        except Exception as e:
            LOGGER.error(f'{ucode}首页返回配置信息异常{repr(e)}')
            return 0

    @staticmethod
    def get_vod_use_status(uid, now_time):
        """
        根据UID获取云存使用状态
        @param uid: 设备uid
        @param now_time: 现在时间戳
        @return: 0：未体验；1：使用中；2：已过期
        """
        experience_context_qs = ExperienceContextModel.objects.filter(uid=uid, experience_type=0)
        if not experience_context_qs.exists():
            return 0
        uid_bucket_qs = UID_Bucket.objects.filter(uid=uid, endTime__gt=now_time, use_status=1)
        if uid_bucket_qs.exists():
            return 1
        else:
            return 2

    @staticmethod
    def get_cloud_photo_status(uid):
        """
        根据UID获取云相册开关状态
        @param uid: 设备uid
        @return: 0 or 1
        """
        cloud_photo_qs = DeviceCloudPhotoInfo.objects.filter(uid=uid).values('status')
        if not cloud_photo_qs.exists():
            return 0
        return cloud_photo_qs[0]['status']

    def do_fuzzy_query(self, userID, request_dict, response):
        fuzzy = request_dict.get('fuzzy', None)
        page = request_dict.get('page', None)
        line = request_dict.get('line', None)

        if not all([page, line]):
            return response.json(444)

        page = int(page)
        line = int(line)
        try:
            device_qs = Device_Info.objects.filter(userID=userID)
            device_qs = device_qs.filter(~Q(isExist=2))
            if not device_qs.exists():
                return response.json(0, [])
            if fuzzy:
                device_qs = device_qs.filter(Q(UID__icontains=fuzzy) | Q(NickName__icontains=fuzzy))
            device_qs = device_qs.values('id', 'userID', 'NickName', 'UID', 'View_Account',
                                         'View_Password', 'ChannelIndex', 'Type', 'isShare',
                                         'primaryUserID', 'primaryMaster', 'data_joined', 'vodPrimaryUserID',
                                         'vodPrimaryMaster', 'userID__userEmail',
                                         'version', 'isVod', 'isExist', 'NotificationMode', 'isCameraOpenCloud',
                                         'serial_number')

            dvls = CommonService.qs_to_list(device_qs)
            uid_list = []
            for dvl in dvls:
                uid_list.append(dvl['UID'])

            ubqs = UID_Bucket.objects.filter(uid__in=uid_list). \
                values('bucket__content', 'status', 'channel', 'endTime', 'uid')
            upqs = UID_Preview.objects.filter(uid__in=uid_list).order_by('channel').values('id', 'uid', 'channel')
            auth = oss2.Auth(ALICLOUD_AK, ALICLOUD_SK)
            bucket = oss2.Bucket(auth, 'oss-cn-hongkong.aliyuncs.com', 'statres')
            nowTime = int(time.time())
            data = []
            # 设备拓展信息表
            us_qs = UidSetModel.objects.filter(uid__in=uid_list).values('id', 'uid', 'version', 'nickname', 'ucode',
                                                                        'detect_status', 'detect_group',
                                                                        'detect_interval',
                                                                        'region_alexa', 'is_alexa', 'deviceModel',
                                                                        'TimeZone', 'TimeStatus', 'SpaceUsable',
                                                                        'SpaceSum', 'MirrorType', 'RecordType',
                                                                        'OutdoorModel', 'WIFIName', 'isDetector',
                                                                        'DetectorRank')
            uv_dict = {}
            for us in us_qs:
                uv_dict[us['uid']] = {
                    'version': us['version'],
                    'nickname': us['nickname'],
                    'ucode': us['ucode'],
                    'detect_interval': us['detect_interval'],
                    'detect_group': us['detect_group'],
                    'detect_status': us['detect_status'],
                    'region_alexa': us['region_alexa'],
                    'is_alexa': us['is_alexa'],
                    'deviceModel': us['deviceModel'],
                    'TimeZone': us['TimeZone'],
                    'TimeStatus': us['TimeStatus'],
                    'SpaceUsable': us['SpaceUsable'],
                    'SpaceSum': us['SpaceSum'],
                    'MirrorType': us['MirrorType'],
                    'RecordType': us['RecordType'],
                    'OutdoorModel': us['OutdoorModel'],
                    'WIFIName': us['WIFIName'],
                    'isDetector': us['isDetector'],
                    'DetectorRank': us['DetectorRank']
                }
                # 从uid_channel里面取出通道配置信息
                ucs_qs = UidChannelSetModel.objects.filter(uid__id=us['id']).values()
                channels = []
                for ucs in ucs_qs:
                    channel = {
                        'channel': ucs['channel'],
                        'channel_name': ucs['channel_name'],
                        'pir_audio': ucs['pir_audio'],
                        'mic_audio': ucs['mic_audio'],
                        'battery_status': ucs['battery_status'],
                        'battery_level': ucs['battery_level'],
                        'sleep_status': ucs['sleep_status'],
                        'sleep_time': ucs['sleep_time'],
                        'light_night_model': ucs['light_night_model'],
                        'light_alarm_type': ucs['light_alarm_type'],
                        'light_alarm_level': ucs['light_alarm_level'],
                        'light_alarm_man_en': ucs['light_alarm_man_en'],
                        'light_alarm_vol': ucs['light_alarm_vol'],
                        'light_long_light': ucs['light_long_light']
                    }
                    channels.append(channel)
                uv_dict[us['uid']]['channels'] = channels

            for p in dvls:
                # 获取iot_deviceInfo表的endpoint和token_iot_number
                p['iot'] = []
                if p['serial_number']:  # 存在序列号根据序列号查询
                    # 摄像头设备返回完整序列号
                    if p['UID'] != p['serial_number']:
                        p['serial_number'] = CommonService.get_full_serial_number(p['UID'], p['serial_number'],
                                                                                  p['Type'])
                    iotdeviceInfo_qs = iotdeviceInfoModel.objects.filter(serial_number=p['serial_number'][0:6])
                else:  # 根据uid查询
                    iotdeviceInfo_qs = iotdeviceInfoModel.objects.filter(uid=p['UID'])
                if iotdeviceInfo_qs.exists():
                    iotdeviceInfo = iotdeviceInfo_qs.values('endpoint', 'token_iot_number')
                    p['iot'].append({
                        'endpoint': iotdeviceInfo[0]['endpoint'],
                        'token_iot_number': iotdeviceInfo[0]['token_iot_number']
                    })

                p['vod'] = []
                for dm in ubqs:
                    if p['UID'] == dm['uid']:
                        if dm['endTime'] > nowTime:
                            p['vod'].append(dm)
                p['preview'] = []
                for up in upqs:
                    if p['UID'] == up['uid']:
                        obj = 'uid_preview/{uid}/channel_{channel}.png'.format(uid=up['uid'], channel=up['channel'])
                        img_sign = bucket.sign_url('GET', obj, 300)
                        p['preview'].append(img_sign)
                p_uid = p['UID']
                if p_uid in uv_dict:
                    # 设备版本号
                    p['uid_version'] = uv_dict[p_uid]['version']
                    p['ucode'] = uv_dict[p_uid]['ucode']
                    p['detect_interval'] = uv_dict[p_uid]['detect_interval']
                    p['detect_status'] = uv_dict[p_uid]['detect_status']
                    p['detect_group'] = uv_dict[p_uid]['detect_group']
                    p['region_alexa'] = uv_dict[p_uid]['region_alexa']
                    p['is_alexa'] = uv_dict[p_uid]['is_alexa']
                    p['deviceModel'] = uv_dict[p_uid]['deviceModel']
                    p['TimeZone'] = uv_dict[p_uid]['TimeZone']
                    p['TimeStatus'] = uv_dict[p_uid]['TimeStatus']
                    p['SpaceUsable'] = uv_dict[p_uid]['SpaceUsable']
                    p['SpaceSum'] = uv_dict[p_uid]['SpaceSum']
                    p['MirrorType'] = uv_dict[p_uid]['MirrorType']
                    p['RecordType'] = uv_dict[p_uid]['RecordType']
                    p['OutdoorModel'] = uv_dict[p_uid]['OutdoorModel']
                    p['WIFIName'] = uv_dict[p_uid]['WIFIName']
                    p['isDetector'] = uv_dict[p_uid]['isDetector']
                    p['DetectorRank'] = uv_dict[p_uid]['DetectorRank']
                    p['channels'] = uv_dict[p_uid]['channels']
                    # 设备昵称 调用影子信息昵称，先阶段不可
                    if uv_dict[p_uid]['nickname']:
                        p['NickName'] = uv_dict[p_uid]['nickname']
                else:
                    # 设备版本号
                    p['uid_version'] = ''
                    p['ucode'] = ''
                data.append(p)
            items = []
            for index, item in enumerate(data):
                if (page - 1) * line <= index:
                    if index < page * line:
                        # 加密
                        item['View_Password'] = self.encrypt_pwd(item['View_Password'])
                        items.append(item)
            return response.json(0, items)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    # 加密
    def encrypt_pwd(self, userPwd):
        for i in range(1, 4):
            if i == 1:
                userPwd = RandomStr(3, False) + userPwd + RandomStr(3, False)
                userPwd = base64.b64encode(str(userPwd).encode("utf-8")).decode('utf8')
            if i == 2:
                userPwd = RandomStr(2, False) + str(userPwd) + RandomStr(2, False)
                userPwd = base64.b64encode(str(userPwd).encode("utf-8")).decode('utf8')
            if i == 3:
                userPwd = RandomStr(1, False) + str(userPwd) + RandomStr(1, False)
                userPwd = base64.b64encode(str(userPwd).encode("utf-8")).decode('utf8')
        return userPwd

    # 解密
    def decode_pwd(self, password):
        for i in range(1, 4):
            if i == 1:
                # 第一次先解密
                password = base64.b64decode(password)
                password = password.decode('utf-8')
                # 截去第一位，最后一位
                password = password[1:-1]
            if i == 2:
                # 第2次先解密
                password = base64.b64decode(password)
                password = password.decode('utf-8')
                # 去前2位，后2位
                password = password[2:-2]
            if i == 3:
                # 第3次先解密
                password = base64.b64decode(password)
                password = password.decode('utf-8')
                # 去前3位，后3位
                password = password[3:-3]
        return password

    @staticmethod
    def do_mainUserDevice(request_dict, response, user_id):
        """
        根据UID或序列号获取云存主用户信息
        """
        try:
            UID = request_dict.get('UID')
            serial_number = request_dict.get('serial_number')
            if UID:
                dvq = Device_Info.objects.filter(UID=UID)
            elif serial_number:
                serial_number = serial_number[:9]
                uid = CommonService.get_uid_by_serial_number(serial_number)
                if serial_number == uid:  # 没查到绑定对应的UID
                    dvq = Device_Info.objects.filter(serial_number=serial_number)
                else:  # 根据序列号查到了对应的UID
                    dvq = Device_Info.objects.filter(UID=uid)
            else:
                return response.json(444)
            dvq = dvq.filter(~Q(vodPrimaryUserID='')).values('vodPrimaryUserID')
            if not dvq.exists():
                return response.json(0, [])
            qs = Device_User.objects.filter(userID=dvq[0]['vodPrimaryUserID']) \
                .values('userID', 'NickName', 'username', 'userEmail', 'phone')
            if not qs.exists():
                return response.json(0, [])
            nickname = qs[0]['username']
            phone = qs[0]['phone']
            username = qs[0]['username']
            sys_user_id = qs[0]['userID']

            qs = CommonService.qs_to_list(qs)
            if nickname == '':
                qs[0]['NickName'] = username
            if phone == '':
                qs[0]['phone'] = nickname

            # 查询主用户并且返回主用户是否是当前账户标识
            qs[0]['isOwnUser'] = sys_user_id and user_id and sys_user_id == user_id
            return response.json(0, qs)
        except Exception as e:
            LOGGER.info('异常详情,userID:{}, errLine:{}, errMsg:{}'.format(user_id, e.__traceback__.tb_lineno, repr(e)))
            return response.json(500)

    def not_login_do_mainUserDevice(self, request_dict, response):
        UID = request_dict.get('UID')
        token = request_dict.get('token', None)
        time_stamp = request_dict.get('time_stamp', None)

        if not all([token, time_stamp]):
            return response.json(444)

        # 时间戳token校验
        if not CommonService.check_time_stamp_token(token, time_stamp):
            return response.json(13)

        dvq = Device_Info.objects.filter(UID=UID)
        dvq = dvq.filter(~Q(vodPrimaryUserID='')).values('vodPrimaryUserID')
        qs = {}
        if dvq.exists():
            qs = Device_User.objects.filter(userID=dvq[0]['vodPrimaryUserID']).values('userID', 'NickName', 'username',
                                                                                      'userEmail', 'phone')
            NickName = qs[0]['NickName']
            phone = qs[0]['phone']
            username = qs[0]['username']
            qs = CommonService.qs_to_list(qs)
            if NickName == '':
                qs[0]['NickName'] = username
            if phone == '':
                qs[0]['phone'] = NickName
        return response.json(0, qs)

    @staticmethod
    def test_tool_del_device(request_dict, response):
        """
        测试工具删除设备
        @param request_dict: 请求数据
        @request_dict uid: uid
        @request_dict time_stamp: 时间戳
        @request_dict time_stamp_token: 时间戳token
        @param response: 响应
        @return: response
        """
        uid = request_dict.get('uid')
        time_stamp = request_dict.get('time_stamp', None)
        time_stamp_token = request_dict.get('time_stamp_token', None)

        if not all([uid, time_stamp, time_stamp_token]):
            return response.json(444)

        try:
            # 时间戳token校验
            if not CommonService.check_time_stamp_token(time_stamp_token, time_stamp):
                return response.json(13)

            with transaction.atomic():
                Device_Info.objects.filter(UID=uid).delete()
                UidPushModel.objects.filter(uid_set__uid=uid).delete()
                LOGGER.info(f'PC删除设备&删除APP推送token{uid}成功')
                asy = threading.Thread(target=EquipmentManagerV3.async_del_message, args=(uid,))
                asy.start()
            return response.json(0, {'msg': 'Delete the device and delete the push token successfully'})
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    def change_device_password(self, request_dict, response):
        """
        修改设备密码
        @return:
        """
        uid = request_dict.get('uid', None)
        version = request_dict.get('version', None)
        encrypt_pwd = request_dict.get('encrypt_pwd', None)
        if not all([uid, version, encrypt_pwd]):
            return response.json(444)
        try:
            # 异步请求其他服
            if CONFIG_INFO == CONFIG_US:
                change_pwd_thread = threading.Thread(target=self.change_pwd, args=(request_dict.dict(),))
                change_pwd_thread.start()

            view_password = self.decode_pwd(encrypt_pwd)
            Device_Info.objects.filter(UID=uid).update(View_Password=view_password)
            UidSetModel.objects.filter(uid=uid).update(pwd=view_password)
            content = json.loads(json.dumps(request_dict))
            log = {
                'user_id': 2,
                'status': 200,
                'time': int(time.time()),
                'url': 'v3/equipment/changeDevicePassword',
                'content': json.dumps(content),
                'operation': '{}上报设备密码:{}'.format(uid, view_password),
            }
            LogModel.objects.create(**log)
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def change_pwd(data):
        """
        请求更新密码线程
        @param data: 请求数据
        """
        orders_domain_name_list = CommonService.get_orders_domain_name_list()
        for domain_name in orders_domain_name_list:
            url = '{}v3/equipment/changeDevicePassword'.format(domain_name)
            requests.post(url=url, data=data, timeout=30)


    def do_get_device_features(self, request_dict, response):
        uid = request_dict.get('uid', None)

        if uid:
            uid = CommonService.decode_data(uid)

            if uid:
                uid_qs = UidSetModel.objects.filter(uid=uid)
                if uid_qs.exists():
                    uid_qs = uid_qs.values('is_alexa', 'is_human', 'is_custom_voice', 'double_wifi', 'mobile_4g')
                    return response.json(0, uid_qs[0])
                else:
                    return response.json(173)
            else:
                return response.json(444)

        else:
            return response.json(444)

    @classmethod
    def async_del_message(cls, uid):
        try:
            # 删除推送消息
            EquipmentInfoService.delete_all_equipment_info(device_uid=uid)
            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)))

    @staticmethod
    def save_button_user(request_dict, response):
        """
        设置推送按钮用户
        """
        uid = request_dict.get('uid', None)
        button_user1 = request_dict.get('buttonUser1', None)
        button_user2 = request_dict.get('buttonUser2', None)
        if not uid:
            return response.json(444)
        try:
            now_time = int(time.time())
            if button_user1:
                button_qs = UserAudioVideoPush.objects.filter(uid=uid)
                if button_qs.exists():
                    button_qs.update(buttonUser1=button_user1, updated_time=now_time)
                else:
                    UserAudioVideoPush.objects.create(uid=uid, buttonUser1=button_user1, created_time=now_time,
                                                      updated_time=now_time)
            if button_user2:
                button_qs = UserAudioVideoPush.objects.filter(uid=uid)
                if button_qs.exists():
                    button_qs.update(buttonUser2=button_user2, updated_time=now_time)
                else:
                    UserAudioVideoPush.objects.create(uid=uid, buttonUser2=button_user2, created_time=now_time,
                                                      updated_time=now_time)
            return response.json(0)
        except Exception as e:
            return response.json(500, repr(e))

    @staticmethod
    def get_button_user(request_dict, response):
        """
        获取推送按钮用户
        """
        uid = request_dict.get('uid', None)
        if not uid:
            return response.json(444)
        try:
            device_qs = Device_Info.objects.filter(UID=uid).values('userID', 'userID__NickName', 'noteName')
            button_qs = UserAudioVideoPush.objects.filter(uid=uid).values('buttonUser1', 'buttonUser2')
            res = []
            for item in device_qs:
                noteName = item['noteName'] if item['noteName'] else item['userID__NickName']
                temp_dict = {'userId': item['userID'], 'username': item['userID__NickName'],
                             'noteName': noteName}
                if not button_qs.exists():
                    res.append(temp_dict)
                    continue
                if item['userID'] == button_qs[0]['buttonUser1']:
                    temp_dict['audioVideoButton'] = '1'
                if item['userID'] == button_qs[0]['buttonUser2']:
                    temp_dict['audioVideoButton'] = '2'
                if item['userID'] == button_qs[0]['buttonUser1'] and item['userID'] == button_qs[0]['buttonUser2']:
                    temp_dict['audioVideoButton'] = '1,2'
                res.append(temp_dict)
            return response.json(0, res)
        except Exception as e:
            return response.json(500, repr(e))

    @staticmethod
    def verify_code(request_dict, response):
        """
        校验验证码(查看设备密码)
        @param request_dict:
        @param response:
        @return:
        """
        email = request_dict.get('email', None)
        phone = request_dict.get('phone', None)
        uid = request_dict.get('uid', None)
        authcode = request_dict.get('authcode', None)
        if not any([email, phone]):
            return response.json(444)
        if not all([uid, authcode]):
            return response.json(444)
        try:
            authcode = CommonService.decode_data(authcode.strip())
            if authcode is None:
                return response.json(444, 'authcode')
            user_info = email if email is not None else phone
            redis = RedisObject()
            redis_key = '{}_{}_GetDevicePassword'.format(user_info, uid)
            reset_code = redis.get_data(key=redis_key)
            if reset_code is False:
                return response.json(90)
            if authcode != reset_code:
                return response.json(121)
            if not redis.del_data(redis_key):
                return response.json(10, '删除缓存失败')
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def view_device_password(request_dict, response):
        """
        查看设备密码
        @param request_dict:
        @param response:
        @return:
        """
        uid = request_dict.get('uid', None)
        if not all([uid]):
            return response.json(444)
        try:
            uid_set_qs = UidSetModel.objects.filter(uid=uid).values('pwd')
            if uid_set_qs.exists():
                device_password = uid_set_qs[0]['pwd']
            else:
                device_info_qs = Device_Info.objects.filter(UID=uid).values('View_Password')
                if not device_info_qs.exists():
                    return response.json(173)
                device_password = device_info_qs[0]['View_Password']
            device_password = CommonService.encode_data(device_password)
            res = {
                'device_password': device_password
            }
            return response.json(0, res)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def edit_sort_order(user_id, request_dict, response):
        """
        修改设备排序
        ids: 选中的设备id列表（单选或多选）
        action: 操作类型（move/top/bottom）
        target_id: 拖动目标id（仅单选拖动时用）
        """
        ids = request_dict.get('ids', None)
        action = request_dict.get('action', None)
        target_id = request_dict.get('target_id', None)
        if not ids or not action:
            return response.json(444, 'ids or action missing')
        try:
            ids = ids.split(',')
            # 查询所有设备，按sort_order排序
            all_devices = list(Device_Info.objects.filter(userID_id=user_id).exclude(Type__in=[200, 201]).
                               order_by('-sort_order', '-data_joined'))
            id_to_device = {str(d.id): d for d in all_devices}
            # 单选拖动排序
            if action == 'move' and len(ids) == 1 and target_id:
                moving_id = ids[0]
                moving_device = id_to_device.get(str(moving_id))

                # 如果要移动到最前面，设置target_index为0
                if target_id == 'front':
                    target_index = 0
                else:
                    target_device = id_to_device.get(str(target_id))
                    target_index = all_devices.index(target_device)

                all_devices.remove(moving_device)
                all_devices.insert(target_index, moving_device)
            # 勾选框批量置顶/置底
            elif action in ('top', 'bottom'):
                selected_devices = [id_to_device[i] for i in ids if i in id_to_device]
                other_devices = [d for d in all_devices if str(d.id) not in ids]
                if action == 'top':
                    all_devices = selected_devices + other_devices
                else:
                    all_devices = other_devices + list(reversed(selected_devices))
            # 重新赋值sort_order
            for idx, device in enumerate(all_devices):
                device.sort_order = len(all_devices) - idx
                device.save(update_fields=['sort_order'])
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @classmethod
    def get_device_list_by_user_id(cls, user_id, response):
        """
        根据用户ID获取设备列表（设备名称、UID、序列号、类型）

        Args:
            user_id: 用户ID
            response: 响应对象

        Returns:
            Response: 包含设备列表的响应对象
        """
        # 输入参数验证
        if not user_id:
            LOGGER.warning("获取设备列表失败: 用户ID为空")
            return response.json(400, "用户ID不能为空")

        try:
            # 使用链式查询优化，减少数据库查询次数
            device_queryset = (
                Device_Info.objects
                .filter(
                    userID=user_id,
                )
                .exclude(Type__in=[200, 201])  # 排除网关和插座类型
                .only('NickName', 'UID', 'serial_number', 'Type')  # 仅查询需要的字段
                .order_by('-sort_order')  # 添加排序，提高用户体验
            )

            # 直接使用values()返回字典列表，避免创建模型实例
            device_data = list(
                device_queryset.values(
                    'NickName',
                    'UID',
                    'serial_number',
                    'Type'
                )
            )

            # 添加空数据检查
            if not device_data:
                return response.json(0, [])

            return response.json(0, device_data)

        except Exception as e:
            # 其他异常
            LOGGER.error(
                f"用户 {user_id} 获取设备列表时发生未知异常: {repr(e)}",
                exc_info=True  # 记录完整的堆栈信息
            )
            return response.json(500, "系统内部错误")

    def get_device_detail_by_uid(self, user_id, request_dict, response):
        """
        根据USER_ID、UID查询设备详情
        @param userID: 用户id
        @param request_dict: 请求参数
        @param response: 响应结果
        """
        try:
            uid = request_dict.get('uid', None)
            if not uid:
                return response.json(444)
            all_dv_list, _ = UserDeviceService.query_device_list(
                user_id,
                uid=uid,
                nickname=None,
                page=1,
                line=500,
                group_id=0
            )

            matched_dv = all_dv_list

            search_uids = [dev['UID'] for dev in matched_dv]

            ub_qs = UserDeviceService.query_device_uid_bucket(search_uids)  # 根据uid集合查询云存套餐
            up_qs = UserDeviceService.query_device_preview(search_uids)  # 根据uid集合查询设备预览图
            uv_dict = UserDeviceService.query_device_channel(search_uids)  # 查询设备uid通道配置属性
            auth = oss2.Auth(ALICLOUD_AK, ALICLOUD_SK)
            bucket = oss2.Bucket(auth, 'oss-cn-hongkong.aliyuncs.com', 'statres')
            nowTime = int(time.time())
            data = []

            # 遍历所有匹配的设备，查询设备关联数据详情
            for p in matched_dv:
                p['UID'] = p['UID'].replace('\n', '').replace('\r', '')
                p_uid = p['UID'].upper()
                UserDeviceService.get_sim_by_serial_number(p)  # 获取SIM卡属性
                p['cloudPhoto'] = self.get_cloud_photo_status(p['UID'])
                # 获取云存使用状态
                p['vod_use_status'] = self.get_vod_use_status(p_uid, nowTime)
                # 获取iot_deviceInfo表的endpoint和token_iot_number
                p['iot'] = []
                if p['serial_number']:  # 存在序列号根据序列号查询
                    iotdeviceInfo_qs = iotdeviceInfoModel.objects.filter(serial_number=p['serial_number'][0:6])
                else:  # 根据uid查询
                    iotdeviceInfo_qs = iotdeviceInfoModel.objects.filter(uid=p_uid)
                if iotdeviceInfo_qs.exists():
                    iotdeviceInfo = iotdeviceInfo_qs.values('endpoint', 'token_iot_number')
                    p['iot'].append({
                        'endpoint': iotdeviceInfo[0]['endpoint'],
                        'token_iot_number': iotdeviceInfo[0]['token_iot_number']
                    })

                p['vod'] = []
                for dm in ub_qs:
                    if p_uid == dm['uid']:
                        if dm['endTime'] > nowTime:
                            p['vod'].append(dm)
                p['preview'] = []
                for up in up_qs:
                    if p_uid == up['uid']:
                        obj = 'uid_preview/{uid}/channel_{channel}.png'.format(uid=up['uid'], channel=up['channel'])
                        img_sign = bucket.sign_url('GET', obj, 300)
                        p['preview'].append(img_sign)
                UserDeviceService.get_uid_info(p, p_uid)  # 获取uid初始化信息

                if p_uid in uv_dict:
                    # 获取设备信息DTO
                    UserDeviceService.get_device_info_dto(p, p_uid, uv_dict, user_id)
                else:
                    # 设备版本号
                    p['uid_version'] = ''
                    p['ucode'] = ''
                p['View_Password'] = self.encrypt_pwd(p['View_Password'])

                # 判断设备是否支持4G和查询移动侦测状态
                uid_set_qs = UidSetModel.objects.filter(uid=p['UID']).values('detect_status', 'ucode', 'version')
                if uid_set_qs.exists():
                    uid_set_qs = uid_set_qs.first()
                    p['has_4g_cloud'] = self.get_device_is_4G(uid_set_qs['ucode'], uid_set_qs['version'])
                    if p['has_4g_cloud'] == 1:
                        p['isCameraOpenCloud'] = 1
                    p['NotificationMode'] = uid_set_qs['detect_status']
                data.append(p)

            return response.json(0, data)
        except Exception as e:
            LOGGER.error(f"{user_id}查询设备详情时发生错误: {str(e)}")
            return response.json(500)