ASJServer/Controller/EquipmentManager.py

import logging
import re
import threading
import time
import traceback

import oss2
import requests
import simplejson as json
from django.db import transaction
from django.db.models import Q
from django.utils import timezone

from Ansjer.config import BASE_DIR, ALGORITHM_COMBO_TYPES
from Controller.DetectController import DetectControllerView
from Controller.DeviceShare import DeviceShareView
from Model.models import Device_User, Device_Info, UID_Bucket, UID_Preview, UidSetModel, UidPushModel, \
    UIDCompanySerialModel, iotdeviceInfoModel, UidChannelSetModel, LogModel, UnicomDeviceInfo, SysMsgModel, CountryModel
from Object.RedisObject import RedisObject
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject
from Service.CommonService import CommonService
from Service.ModelService import ModelService
from django.conf import settings
OSS_STS_ACCESS_KEY = settings.OSS_STS_ACCESS_KEY
OSS_STS_ACCESS_SECRET = settings.OSS_STS_ACCESS_SECRET


#     查询用户设备
def queryUserEquipmentInterface(request):
    request.encoding = 'utf-8'
    response = ResponseObject()
    if request.method == 'POST':
        request_dict = request.POST
    elif request.method == 'GET':
        request_dict = request.GET
    else:
        return response.json(444)
    token = request_dict.get('token', None)
    tko = TokenObject(token)
    response.lang = tko.lang
    if tko.code != 0:
        return response.json(tko.code)
    userID = tko.userID
    if not userID:
        return response.json(309)
    dvqs = Device_Info.objects.filter(userID_id=userID)
    dvdict = CommonService.qs_to_dict(dvqs)
    uid_list = Device_Info.objects.filter(userID_id=userID, isShare=False). \
        values_list('UID', flat=True)
    ubqs = UID_Bucket.objects.filter(uid__in=uid_list). \
        values('bucket__content', 'status', 'channel', 'endTime', 'uid')
    res = []
    nowTime = int(time.time())
    for p in dvdict['datas']:
        p['fields']['vod'] = []
        for dm in ubqs:
            if p['fields']['UID'] == dm['uid']:
                if dm['endTime'] > nowTime:
                    p['fields']['vod'].append(dm)
                    # dm['valid'] = 1
                # else:
                #     dm['valid'] = 0
        # p['fields']['primaryUserID'] = ''
        res.append(p)
    return response.json(0, {'datas': res})


def addNewUserEquipmentInterface(request):
    request.encoding = 'utf-8'
    response = ResponseObject()
    if request.method == 'POST':
        request_dict = request.POST
    elif request.method == 'GET':
        request_dict = request.GET
    else:
        return response.json(444)
    token = request_dict.get('token', None)
    deviceContent = request_dict.get('content', None)
    if not deviceContent:
        return response.json(444, 'content')
    tko = TokenObject(token)
    response.lang = tko.lang
    if tko.code != 0:
        return response.json(tko.code)
    userID = tko.userID

    try:
        deviceData = json.loads(deviceContent)
        UID = deviceData.get('UID', None)
        if not UID:
            return response.json(444, 'content')
        dValid = Device_Info.objects.filter(userID_id=userID, UID=UID)
        if dValid:
            return response.json(174)
        else:
            UID = deviceData.get('UID', '')
            re_uid = re.compile(r'^[A-Za-z0-9]{20}$')
            if re_uid.match(UID):
                userDevice = Device_Info(id=CommonService.getUserID(getUser=False), userID_id=userID,
                                         **deviceData)
                userDevice.save()
                if UID == '98UXAA8BRPA35VAL111A':
                    asy = threading.Thread(target=ModelService.add_log,
                                           args=(CommonService.get_ip_address(request), userID, 'addV0'))
                    asy.start()

                # is_bind = Device_Info.objects.filter(UID=UID, isShare=False)
                # # 判断是否有已绑定用户
                # if not is_bind.exists():
                #     userDevice = Device_Info(id=CommonService.getUserID(getUser=False), userID_id=userID,
                #                              **deviceData)
                #     userDevice.save()
                # else:
                #     # 分享添加
                #     if 'isShare' in deviceData:
                #         deviceData['isShare'] = True
                #     else:
                #         deviceData['isShare'] = True
                #     bind_userID = is_bind[0].userID_id
                #     userDevice = Device_Info(id=CommonService.getUserID(getUser=False),
                #                              userID_id=userID,
                #                              primaryUserID=bind_userID,
                #                              primaryMaster=ModelService.get_user_name(bind_userID),
                #                              **deviceData)
                #     userDevice.save()
            else:
                return response.json(444, 'UID')

    except Exception as e:
        errorInfo = traceback.format_exc()
        print('添加设备错误: %s ' % errorInfo)
        return response.json(178, repr(e))
    else:
        sqlDict = CommonService.qs_to_dict([userDevice])
        return response.json(0, sqlDict)


def delUserEquipmentInterface(request):
    '''
    删除用户设备
    :param request:
    :return:
    '''
    response = ResponseObject()
    request.encoding = 'utf-8'
    if request.method == 'POST':
        request_dict = request.POST
    elif request.method == 'GET':
        request_dict = request.GET
    else:
        return response.json(444)
    token = request_dict.get('token', None)
    id = request_dict.get('id', None)
    if not id:
        return response.json(444, 'id')
    tko = TokenObject(token)
    response.lang = tko.lang
    if tko.code != 0:
        return response.json(tko.code)
    userID = tko.userID
    # 主用户删除设备全部删除
    try:
        dv_qs = Device_Info.objects.filter(userID_id=userID, id=id)
        if dv_qs.exists():
            uid = dv_qs[0].UID
            asy = threading.Thread(target=ModelService.add_log,
                                   args=(CommonService.get_ip_address(request), userID, 'deleteV1'))
            asy.start()

            print('删除')
            UID_Preview.objects.filter(uid=uid).delete()
            dv_qs.delete()
            Device_Info.objects.filter(UID=uid).update(vodPrimaryUserID='', vodPrimaryMaster='')
            asy = threading.Thread(target=ModelService.del_eq_info, args=(userID, uid))
            asy.start()

    except Exception as e:
        errorInfo = traceback.format_exc()
        print('删除数据库记录错误: %s' % errorInfo)
        return response.json(176, repr(e))
    else:
        return response.json(0)


def modifyUserEquipmentInterface(request):
    '''
    修改用户设备
    :param request:
    :return:
    '''
    response = ResponseObject()
    if request.method == 'POST':
        request.encoding = 'utf-8'
        request_dict = request.POST
    elif request.method == 'GET':
        request.encoding = 'utf-8'
        request_dict = request.GET
    else:
        return response.json(444)
    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 = json.loads(deviceContent)

        if deviceData.__contains__('userID_id'):
            asy = threading.Thread(target=ModelService.update_log,
                                   args=(CommonService.get_ip_address(request), userID, 'modifyV0', 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)
        dev_info_qs.update(**deviceData)
    except Exception as 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
            if uid == '98UXAA8BRPA35VAL111A':
                asy = threading.Thread(target=ModelService.update_log,
                                       args=(
                                           CommonService.get_ip_address(request), userID, 'modifyV0', deviceContent,
                                           id))
                asy.start()
            nickname = qs[0].NickName
            # 增加设备影子信息修改昵称 start
            us_qs = UidSetModel.objects.filter(uid=uid)
            if us_qs.exists():
                us_qs.update(nickname=nickname)
            else:
                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
                }
                UidSetModel.objects.create(**uid_set_create_dict)
            Device_Info.objects.filter(UID=uid).update(NickName=nickname)
            if deviceData.__contains__('NickName') and us_qs[0].is_alexa == 1:
                encrypt_pwd = ''
                if deviceData.__contains__('View_Password'):
                    encrypt_pwd = deviceData['View_Password']
                data_list = [{'userID': userID, 'UID': uid, 'uid_nick': nickname, 'password': encrypt_pwd}]
                # 请求Alexa服务器更新事件网关
                CommonService.update_alexa_events(data_list)
        return response.json(0, res)


def showAllUserEquipmentInterface(request, *callback_args, **callback_kwargs):
    request.encoding = 'utf-8'
    response = ResponseObject()
    if request.method == 'POST':
        fieldDict = request.POST
    elif request.method == 'GET':
        fieldDict = request.GET
    else:
        return response.json(444)
    token = request.POST.get('token', None)
    type = request.POST.get('type', None)
    tko = TokenObject(token)
    response.lang = tko.lang
    if tko.code != 0:
        return response.json(tko.code)
    userID = tko.userID
    if not userID:
        return response.json(309)
    own_perm = ModelService.check_perm(userID=userID, permID=30)
    if not own_perm:
        return response.json(404)
    if type == 'PC':
        page = int(fieldDict['page'])
        line = int(fieldDict['line'])
        qs = Device_Info.objects.all()
        count = qs.count()
        res = qs[(page - 1) * line:page * line]
        sqlDict = CommonService.qs_to_dict(query_set=res)
        sqlDict['count'] = count
        return response.json(0, sqlDict)
    else:
        qs = Device_Info.objects.all()
        res = CommonService.qs_to_dict(qs)
        return response.json(0, res)


def findEquipmentInfoInterface(request, *callback_args, **callback_kwargs):
    request.encoding = 'utf-8'
    response = ResponseObject()
    if request.method == 'GET':
        fieldDict = request.GET
    elif request.method == 'POST':
        fieldDict = request.POST
    else:
        return response.json(444)
    deviceContent = fieldDict.get('content', None)
    token = fieldDict.get('token', None)
    tko = TokenObject(token)
    response.lang = tko.lang
    if tko.code != 0:
        return response.json(tko.code)
    if deviceContent:
        try:
            searchCondition = json.loads(deviceContent)
        except Exception as e:
            print(repr(e))
            return response.json(10, repr(e))
        else:
            kwargs = CommonService.get_kwargs(data=searchCondition)
            qs = Device_Info.objects.filter(**kwargs)
            page = int(fieldDict['page'])
            line = int(fieldDict['line'])
            count = qs.count()
            res = qs[(page - 1) * line:page * line]
            send_dict = CommonService.qs_to_dict(query_set=res)
            for k, v in enumerate(send_dict["datas"]):
                for val in res:
                    if v['pk'] == val.id:
                        send_dict["datas"][k]['fields']['username'] = \
                            ModelService.get_user_mark(send_dict["datas"][k]['fields']['userID'])
                        send_dict["datas"][k]['fields']['primaryusername'] = \
                            ModelService.get_user_mark(send_dict["datas"][k]['fields']['primaryUserID'])
            send_dict['count'] = count
            return response.json(0, send_dict)
    else:
        qs = Device_Info.objects.all()
        page = int(fieldDict['page'])
        line = int(fieldDict['line'])
        count = qs.count()
        res = qs[(page - 1) * line:page * line]
        send_dict = CommonService.qs_to_dict(query_set=res)
        for k, v in enumerate(send_dict["datas"]):
            for val in res:
                if v['pk'] == val.id:
                    username = ModelService.get_user_name(send_dict["datas"][k]['fields']['userID'])
                    send_dict["datas"][k]['fields']['username'] = username
                    send_dict["datas"][k]['fields']['primaryusername'] = \
                        ModelService.get_user_mark(send_dict["datas"][k]['fields']['primaryUserID'])
        send_dict['count'] = count
        return response.json(0, send_dict)


# 添加设备字段
def addInterface(request):
    request.encoding = 'utf-8'
    response = ResponseObject()
    if request.method == 'POST':
        request_dict = request.POST
    elif request.method == 'GET':
        request_dict = request.GET
    else:
        return response.json(444)
    token = request_dict.get('token', None)
    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', '')
    Type = request_dict.get('Type', None)
    ChannelIndex = request_dict.get('ChannelIndex', None)
    version = request_dict.get('version', '')
    isCheckMainUser = request_dict.get('isCheckMainUser', None)
    isMainUserExists = False
    if all([UID, NickName, View_Account, Type, ChannelIndex]):
        tko = TokenObject(token)
        response.lang = tko.lang
        if tko.code == 0:
            userID = tko.userID
            re_uid = re.compile(r'^[A-Za-z0-9]{20}$')
            if re_uid.match(UID):
                is_exist = Device_Info.objects.filter(UID=UID, userID_id=userID)
                if is_exist:
                    # 判断设备是否已存在
                    if is_exist[0].isExist == 1:
                        return response.json(174)
                    else:
                        is_exist.delete()
                if UID == '98UXAA8BRPA35VAL111A':
                    asy = threading.Thread(target=ModelService.add_log,
                                           args=(CommonService.get_ip_address(request), userID, 'addV1'))
                    asy.start()
                    return response.json(10, 'illegal uid: {uid}'.format(uid=UID))
                pass

                pk = CommonService.getUserID(getUser=False)
                userName = Device_User.objects.get(userID=userID).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']
                    # Type = is_bind[0]['Type']
                    isShare = True

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

                # 判断是否有已绑定用户
                if isCheckMainUser == '1' and isusermain:
                    res = {
                        'id': pk,
                        '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
                    return response.json(0, res)

                try:
                    # 判断是否有用户绑定
                    nowTime = int(time.time())
                    us_qs = UidSetModel.objects.filter(uid=UID)
                    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
                    if not us_qs.exists():
                        uid_set_create_dict = {
                            'uid': UID,
                            'addTime': nowTime,
                            'updTime': nowTime,
                            'ip': CommonService.get_ip_address(request),
                            'channel': ChannelIndex,
                            'nickname': NickName,
                            'version': version,
                            'device_type': Type,
                            'tb_country': country
                        }
                        UidSetModel.objects.create(**uid_set_create_dict)
                    else:
                        us_qs.update(nickname=NickName)

                    userDevice = Device_Info(id=pk, 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()
                    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': View_Password})
                        else:
                            data_list = [
                                {'userID': userID, 'UID': UID, 'uid_nick': NickName, 'password': View_Password}]

                        # 请求Alexa服务器更新事件网关
                        CommonService.update_alexa_events(data_list)
                except Exception as e:
                    return response.json(10, repr(e))
                else:
                    dvqs = Device_Info.objects.filter(id=pk).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)

                    # 新增获取IOT证书内容
                    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 isMainUserExists:
                        res['isMainUserExists'] = 1
                    return response.json(0, res)


            else:
                return response.json(444, {'param': 'UID'})
        else:
            return response.json(tko.code)
    else:
        return response.json(444, {'param': 'UID,NickName,View_Account,View_Password,Type,ChannelIndex,version'})


# 添加设备字段
def judgeInterface(request):
    request.encoding = 'utf-8'
    response = ResponseObject()
    if request.method == 'POST':
        request_dict = request.POST
    elif request.method == 'GET':
        request_dict = request.GET
    else:
        return response.json(444)
    token = request_dict.get('token', None)
    uid = request_dict.get('uid', None)
    if all([uid, token]):
        tko = TokenObject(token)
        response.lang = tko.lang
        if tko.code == 0:
            re_uid = re.compile(r'^[A-Za-z0-9]{20}$')
            if re_uid.match(uid):
                is_bind = Device_Info.objects.filter(UID=uid, isShare=False)
                # 判断是否有已绑定用户
                if is_bind:
                    qs = is_bind.values('userID__NickName', 'NickName')
                    nickname = qs[0]['NickName']
                    us_qs = UidSetModel.objects.filter(uid=uid).values('nickname')
                    if us_qs.exists():
                        nickname = us_qs[0]['NickName']
                    res = {
                        'bind_user': qs[0]['userID__NickName'],
                        'bind_device_name': nickname,
                    }
                    return response.json(15, res=res)
                else:
                    return response.json(0, 'no bind user')
            else:
                return response.json(444, {'param': 'UID'})
        else:
            return response.json(tko.code)
    else:
        return response.json(444, {'param': 'UID,NickName,View_Account,View_Password,Type,ChannelIndex'})


# 管理员添加
def admin_addInterface(request):
    request.encoding = 'utf-8'
    response = ResponseObject()
    if request.method == 'POST':
        request_dict = request.POST
    elif request.method == 'GET':
        request_dict = request.GET
    else:
        return response.json(444)
    token = request_dict.get('token', None)
    deviceContent = request_dict.get('content', None)
    ipdizhi = request_dict.get('ipdizhi', None)
    username = request_dict.get('username', None)
    if not username:
        return response.json(444, 'username')
    if not deviceContent:
        return response.json(444, 'content')
    tko = TokenObject(token)
    response.lang = tko.lang
    if tko.code != 0:
        return response.json(tko.code)
    userID = tko.userID
    own_perm = ModelService.check_perm(userID, 40)
    # 权限判断
    if own_perm is not True:
        return response.json(404)
    # 查询id
    user = Device_User.objects.filter(Q(username=username) | Q(phone=username) | Q(userEmail=username))

    if user.exists():
        user_dict = CommonService.qs_to_dict(user)
        userID = user_dict.get('datas')[0].get('pk')
    else:
        return response.json(104)
    print(deviceContent)
    try:
        deviceData = json.loads(deviceContent)
        UID = deviceData.get('UID', None)
        if not UID:
            return response.json(444, 'content')
        dValid = Device_Info.objects.filter(userID_id=userID, UID=UID)
        if dValid:
            return response.json(174)
        else:
            UID = deviceData.get('UID', '')
            re_uid = re.compile(r'^[A-Za-z0-9]{20}$')
            if re_uid.match(UID):
                userDevice = Device_Info(id=CommonService.getUserID(getUser=False), userID_id=userID,
                                         **deviceData)
                userDevice.save()
                file_path = '/'.join((BASE_DIR, 'static/test.log'))

                file = open(file_path, 'a+')
                file.write(ipdizhi + "; username:" + username + "; time:" + time.strftime("%Y-%m-%d %H:%M:%S",
                                                                                          time.localtime()))
                file.write('\n')
                file.flush()
                file.close()

                # is_bind = Device_Info.objects.filter(UID=UID, isShare=False)
                # # 判断是否有已绑定用户
                # if not is_bind.exists():
                #     userDevice = Device_Info(id=CommonService.getUserID(getUser=False), userID_id=userID,
                #                              **deviceData)
                #     userDevice.save()
                # else:
                #     # 分享添加
                #     if 'isShare' in deviceData:
                #         deviceData['isShare'] = True
                #     else:
                #         deviceData['isShare'] = True
                #     bind_userID = is_bind[0].userID_id
                #     userDevice = Device_Info(id=CommonService.getUserID(getUser=False),
                #                              userID_id=userID,
                #                              primaryUserID=bind_userID,
                #                              primaryMaster=ModelService.get_user_name(bind_userID),
                #                              **deviceData)
                #     userDevice.save()
            else:
                return response.json(444, 'UID')

    except Exception as e:
        errorInfo = traceback.format_exc()
        print('添加设备错误: %s ' % errorInfo)
        return response.json(178, repr(e))
    else:
        sqlDict = CommonService.qs_to_dict([userDevice])
        return response.json(0, sqlDict)


# 超级管理员修改设备
def admin_modifyInterface(request):
    response = ResponseObject()
    if request.method == 'POST':
        request.encoding = 'utf-8'
        request_dict = request.POST
    elif request.method == 'GET':
        request.encoding = 'utf-8'
        request_dict = request.GET
    else:
        return response.json(444)
    token = request_dict.get('token', None)
    deviceContent = request_dict.get('content', None)
    username = request_dict.get('username', None)
    if not username:
        return response.json(444, 'username')
    id = request_dict.get('id', None)
    print(deviceContent)

    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)
    own_perm = ModelService.check_perm(userID, 50)

    # 权限判断
    if own_perm is not True:
        return response.json(404)

    deviceData = json.loads(deviceContent)
    dValid = Device_Info.objects.filter(userID_id=userID, UID=deviceData['UID'])
    if dValid.exists():
        dValid_dict = CommonService.qs_to_dict(dValid)
        print(dValid_dict.get('datas')[0].get('pk'))
        if dValid_dict.get('datas')[0].get('pk') == id:
            print('可以编辑')
        else:
            return response.json(174)
        # 查询id
        user = Device_User.objects.filter(Q(username=username) | Q(phone=username) | Q(userEmail=username))
        if user.exists():
            user_dict = CommonService.qs_to_dict(user)
            userID = user_dict.get('datas')[0].get('pk')
        try:

            # 更改的时间
            update_time = timezone.localtime(timezone.now())
            Device_Info.objects.filter(userID_id=userID, id=id).update(update_time=update_time, **deviceData)
        except Exception as e:
            return response.json(177, repr(e))
        else:
            qs = Device_Info.objects.filter(userID_id=userID, id=id)
            res = CommonService.qs_to_dict(qs)
            return response.json(0, res)
    else:
        # 查询id
        user = Device_User.objects.filter(Q(username=username) | Q(phone=username) | Q(userEmail=username))
        if user.exists():
            user_dict = CommonService.qs_to_dict(user)
            userID = user_dict.get('datas')[0].get('pk')
        try:

            # 更改的时间
            update_time = timezone.localtime(timezone.now())
            Device_Info.objects.filter(userID_id=userID, id=id).update(update_time=update_time, **deviceData)
        except Exception as e:
            return response.json(177, repr(e))
        else:
            qs = Device_Info.objects.filter(userID_id=userID, id=id)
            res = CommonService.qs_to_dict(qs)
            return response.json(0, res)


def deleteInterface(request):
    """
    删除设备
    @param request: 请求体
    @return: response
    """
    response = ResponseObject()
    request.encoding = 'utf-8'
    if request.method == 'POST':
        request_dict = request.POST
    elif request.method == 'GET':
        request_dict = request.GET
    else:
        return response.json(444)

    token = request_dict.get('token', None)
    id = request_dict.get('id', None)
    if not all([token, id]):
        return response.json(444)

    tko = TokenObject(token)
    response.lang = tko.lang
    if tko.code != 0:
        return response.json(tko.code)
    userID = tko.userID
    if not userID:
        return response.json(309)

    username = CommonService.get_username(userID)
    try:
        with transaction.atomic():
            dv_qs = Device_Info.objects.filter(userID_id=userID, id=id).values('UID', 'serial_number', 'isShare',
                                                                               'vodPrimaryUserID')
            if not dv_qs.exists():
                return response.json(14)
            uid = dv_qs[0]['UID']
            serial_number = dv_qs[0]['serial_number']
            is_share = dv_qs[0]['isShare']
            vod_primary_user_id = dv_qs[0]['vodPrimaryUserID']

            del_channel_permission_user_id = ''
            # 主用户删除
            if userID == vod_primary_user_id:
                user_id_list = list(Device_Info.objects.filter(UID=uid).values_list('userID_id', flat=True))
                Device_Info.objects.filter(UID=uid).delete()
                UidPushModel.objects.filter(uid_set__uid=uid).delete()
                # 关闭移动侦测
                UidSetModel.objects.filter(uid=uid).update(detect_status=0)
                # 删除推送消息
                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()
                # 删除推送消息
                del_eq_info_thread = threading.Thread(target=ModelService.del_eq_info, args=(userID, uid))
                if is_share:
                    del_channel_permission_user_id = userID
            del_eq_info_thread.start()
            DeviceShareView.del_device_channel_permission(userID, uid)

            if not serial_number:
                serial_number = CommonService.query_serial_with_uid(uid)
            del_unicom_info(userID, serial_number)

            # 记录操作日志
            now_time = 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': now_time,
                'content': json.dumps(content),
                'url': 'equipment/delete',
                'operation': '{}删除设备,uid:{}'.format(username, uid),
            }
            LogModel.objects.create(**log)

        return response.json(0)
    except Exception as e:
        now_time = int(time.time())
        ip = CommonService.get_ip_address(request)
        log = {
            'ip': ip,
            'user_id': 1,
            'status': 200,
            'time': now_time,
            'content': 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)),
            'url': 'equipment/delete',
            'operation': '{}删除设备失败,uid:{}'.format(username, uid),
        }
        LogModel.objects.create(**log)
        return response.json(176, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))


def del_unicom_info(user_id, serial_no):
    """
    解绑联通绑定用户信息
    @param user_id: 用户id
    @param serial_no: 序列号
    """
    u_dev_info_qs = UnicomDeviceInfo.objects.filter(serial_no=serial_no)
    if u_dev_info_qs.exists():
        now_time = int(time.time())
        u_dev_info_qs.update(user_id='', updated_time=now_time)
        sys_msg_qs = SysMsgModel.objects.filter(userID_id=user_id, uid=serial_no)
        if sys_msg_qs.exists():
            sys_msg_qs.delete()


# 批量删除设备
def batchDeleteInterface(request):
    '''
    批量删除用户设备
    :param request: token,ids
    :return:
    '''
    response = ResponseObject()
    request.encoding = 'utf-8'
    if request.method == 'POST':
        request_dict = request.POST
    elif request.method == 'GET':
        request_dict = request.GET
    else:
        return response.json(444)
    token = request_dict.get('token', None)
    ids = request_dict.get('ids', None)
    if not ids:
        return response.json(444, 'ids')
    tko = TokenObject(token)
    response.lang = tko.lang
    if tko.code != 0:
        return response.json(tko.code)
    userID = tko.userID
    if not userID:
        return response.json(309)
    username = CommonService.get_username(userID)
    try:
        deviceInfo_qs = Device_Info.objects.filter(userID_id=userID, id__in=ids.split(','))
        if not deviceInfo_qs.exists():
            return response.json(14)
        uid_list = []
        for deviceInfo in deviceInfo_qs:
            uid = deviceInfo.UID
            uid_list.append(uid)
            if userID == deviceInfo.vodPrimaryUserID:
                Device_Info.objects.filter(UID=uid).update(vodPrimaryUserID='', vodPrimaryMaster='')

            deviceInfo.delete()
            if not deviceInfo.isShare:
                # a.主用户删除设备
                # 删除设备影子信息uid_set   外键关联删除设备推送配置信息 uid_push
                up_qs = UidPushModel.objects.filter(uid_set__uid=uid)
                DetectControllerView().do_delete_redis(uid)
                if up_qs.count() > 1:
                    UidPushModel.objects.filter(uid_set__uid=uid, userID_id=userID).delete()
                    redisObj = RedisObject()
                    ykey = '{uid}_redis_qs'.format(uid=uid)
                    if ykey:
                        redisObj.del_data(key=ykey)
                else:
                    up_qs.delete()
                # b.删除次用户设备
                Device_Info.objects.filter(UID=uid, isShare=True, primaryUserID=userID).delete()
                # 异步删除推送消息
            asy = threading.Thread(target=ModelService.del_eq_info, args=(userID, uid))
            asy.start()

        # 记录操作日志
        now_time = 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': now_time,
            'content': json.dumps(content),
            'url': 'equipment/batchDelete',
            'operation': '{}批量删除设备,uid:{}'.format(username, uid_list),
        }
        LogModel.objects.create(**log)
    except Exception as e:
        now_time = int(time.time())
        ip = CommonService.get_ip_address(request)
        log = {
            'ip': ip,
            'user_id': 1,
            'status': 200,
            'time': now_time,
            'content': 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)),
            'url': 'equipment/batchDelete',
            'operation': '{}批量删除设备失败'.format(username),
        }
        LogModel.objects.create(**log)
        return response.json(176, repr(e))
    else:
        return response.json(0)


# 新查询设备字段
def queryInterface(request):
    request.encoding = 'utf-8'
    response = ResponseObject()
    if request.method == 'POST':
        request_dict = request.POST
    elif request.method == 'GET':
        request_dict = request.GET
    else:
        return response.json(444)
    token = request_dict.get('token', None)
    page = request_dict.get('page', None)
    line = request_dict.get('line', None)
    NickName = request_dict.get('NickName', None)
    uid = request_dict.get('uid', None)
    page = int(page)
    line = int(line)
    tko = TokenObject(token)
    response.lang = tko.lang
    if page <= 0:
        return response.json(0)
    if tko.code == 0:
        userID = tko.userID
        dvqs = Device_Info.objects.filter(userID_id=userID)
        # # 已重置的设备
        # dvqs = dvqs.filter(~Q(isExist=2))
        if NickName:
            dvqs = dvqs.filter(NickName__icontains=NickName)
        if uid:
            dvqs = dvqs.filter(UID=uid)
        # count = dvqs.count()
        dvql = dvqs[(page - 1) * line:page * line].values('id', 'userID', 'NickName', 'UID', 'View_Account',
                                                          'View_Password', 'ChannelIndex', 'Type', 'isShare',
                                                          'primaryUserID', 'primaryMaster', 'data_joined', 'version',
                                                          'vodPrimaryUserID', 'vodPrimaryMaster', 'userID__userEmail',
                                                          'isVod', 'isExist', 'NotificationMode', 'isCameraOpenCloud',
                                                          'serial_number')
        dvls = CommonService.qs_to_list(dvql)
        uid_list = []
        serial_number_list = []
        for dvl in dvls:
            if dvl['primaryUserID'] and dvl['id'] == dvl['primaryUserID']:
                dvl['isPrimaryUser'] = 1
            else:
                dvl['isPrimaryUser'] = 0
            uid_list.append(dvl['UID'])
            serial_number_list.append(dvl['serial_number'][0:6])

        # 新增获取IOT证书内容
        iotqs = iotdeviceInfoModel.objects.filter(serial_number__in=serial_number_list)

        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(OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET)
        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('uid', 'version', 'nickname', 'detect_interval', 'is_ptz')
        uv_dict = {}
        for us in us_qs:
            uv_dict[us['uid']] = {'version': us['version'],
                                  'nickname': us['nickname'],
                                  'is_ptz': us['is_ptz'],
                                  'detect_interval': us['detect_interval']}

        for p in dvls:
            # 新增IOT
            p['iot'] = []
            for iot in iotqs:
                if p['serial_number'][0:6] == iot.serial_number:
                    p['iot'].append(
                        {
                            'endpoint': iot.endpoint,
                            'token_iot_number': iot.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['detect_interval'] = uv_dict[p_uid]['detect_interval']
                # 设备昵称 调用影子信息昵称，先阶段不可
                if uv_dict[p_uid]['nickname']:
                    p['NickName'] = uv_dict[p_uid]['nickname']
            else:
                # 设备版本号
                p['uid_version'] = ''
            data.append(p)
        return response.json(0, data)
    else:
        return response.json(tko.code)


def uid_status(request):
    request.encoding = 'utf-8'
    response = ResponseObject()
    if request.method == 'POST':
        request_dict = request.POST
    elif request.method == 'GET':
        request_dict = request.GET
    else:
        return response.json(444)
    token = request_dict.get('token', None)
    uid = request_dict.get('uid', None)
    channel = int(request_dict.get('channel', 0))
    is_nvr = int(request_dict.get('isNVR', 0))
    tko = TokenObject(token)
    response.lang = tko.lang
    if tko.code != 0:
        return response.json(tko.code)
    userID = tko.userID

    # 调试
    logger = logging.getLogger('django')
    debugOne = int(time.time())

    # 判断用户是否绑定设备
    qs = UidSetModel.objects.filter(uid=uid).values('uid', 'detect_status', 'detect_interval', 'version', 'ucode',
                                                    'p2p_region', 'tz', 'video_code', 'channel', 'cloud_vod', 'id',
                                                    'detect_group', 'is_alexa', 'region_alexa', 'is_ptz',
                                                    'msg_notify', 'new_detect_interval')

    # 调试
    debugOnes = int(time.time())
    logger.error('————————debugOne_sec：{}'.format(debugOnes - debugOne))

    # 判断uid配置表信息是否存在
    if qs.exists():
        # 获取uid推送是否添加过
        us_id = qs[0]['id']

        # 调试
        debugTwo = int(time.time())

        if UidPushModel.objects.filter(uid_set_id=us_id, userID_id=userID).exists():
            detect_status = qs[0]['detect_status']
        else:
            detect_status = 0
        data = {
            'push_status': detect_status,  # 推送状态
            'push_interval': qs[0]['detect_interval'],  # 推送间隔
            'new_push_interval': qs[0]['new_detect_interval'],  # 新推送间隔
            'ucode': qs[0]['ucode'],
            'version': qs[0]['version'],
            'p2p_region': qs[0]['p2p_region'],
            'tz': qs[0]['tz'],
            'video_code': qs[0]['video_code'],
            'channel': qs[0]['channel'],
            'cloud_vod': qs[0]['cloud_vod'],
            'detect_group': qs[0]['detect_group'],  # 推送组
            'is_alexa': qs[0]['is_alexa'],  # 推送组
            'region_alexa': qs[0]['region_alexa'],  # 推送组
            'is_ptz': qs[0]['is_ptz'],
            'msgData': qs[0]['msg_notify']
        }

        try:
            # 检查 channel 有效性和 msg_notify 是否存在
            if channel > 0 and is_nvr == 1 and qs[0].get('msg_notify'):
                # 获取 msg_notify 数据
                msg_notify = qs[0]['msg_notify']
                nvr_entries = msg_notify.get('nvr', [])
                channel_key = f'channel{channel}'

                # 查找匹配的 channel_entry
                matching_entry = next((entry for entry in nvr_entries if channel_key in entry), None)

                if matching_entry:
                    # 更新 nvr 值
                    data['msgData']['nvr'] = matching_entry[channel_key]
                else:
                    # 没有找到匹配的 channel，使用默认值替换 nvr
                    available_types = [t for t in ALGORITHM_COMBO_TYPES if t != 51]
                    data['msgData']['nvr'] = available_types
            else:
                msg_notify = qs[0].get('msg_notify')
                if msg_notify and 'nvr' in msg_notify:
                    data['msgData']['nvr'] = []
        except Exception as e:
            logger.error(f'查询消息提醒异常uid:{uid},error:{repr(e)}')


        # 调试
        debugTwos = int(time.time())
        logger.error('————————debugTwo_sec：{}'.format(debugTwos - debugTwo))

        # 调试
        debugThere = int(time.time())

        # 查询云存储相关信息
        ubqs = UID_Bucket.objects.filter(uid=uid). \
            values('bucket__content', 'status', 'channel', 'endTime', 'uid')

        # 调试
        debugTheres = int(time.time())
        logger.error('————————debugTheres_sec：{}'.format(debugTheres - debugThere))

        nowTime = int(time.time())
        if ubqs.exists():
            if ubqs[0]['endTime'] > nowTime:
                data['vod'] = list(ubqs)
        return response.json(0, data)
    else:
        return response.json(0)


def uid_status_test(request):
    request.encoding = 'utf-8'
    response = ResponseObject()
    if request.method == 'POST':
        request_dict = request.POST
    elif request.method == 'GET':
        request_dict = request.GET
    else:
        return response.json(444)
    token = request_dict.get('token', None)
    uid = request_dict.get('uid', None)
    tko = TokenObject(token)
    response.lang = tko.lang
    if tko.code != 0:
        return response.json(tko.code)
    userID = tko.userID
    # 判断用户是否绑定设备
    print(100000000000)
    qs = UidSetModel.objects.filter(uid=uid).values('uid', 'detect_status', 'detect_interval', 'version', 'ucode',
                                                    'p2p_region', 'tz', 'video_code', 'channel', 'cloud_vod', 'id',
                                                    'detect_group', 'is_alexa', 'region_alexa')
    # 判断uid配置表信息是否存在
    if qs.exists():
        # 获取uid推送是否添加过
        print(1111111111111)
        us_id = qs[0]['id']
        if UidPushModel.objects.filter(uid_set_id=us_id, userID_id=userID).exists():
            detect_status = qs[0]['detect_status']
        else:
            detect_status = 0
        data = {
            'push_status': detect_status,  # 推送状态
            'push_interval': qs[0]['detect_interval'],  # 推送间隔
            'ucode': qs[0]['ucode'],
            'version': qs[0]['version'],
            'p2p_region': qs[0]['p2p_region'],
            'tz': qs[0]['tz'],
            'video_code': qs[0]['video_code'],
            'channel': qs[0]['channel'],
            'cloud_vod': qs[0]['cloud_vod'],
            'detect_group': qs[0]['detect_group'],  # 推送组
            'is_alexa': qs[0]['is_alexa'],  # 推送组
            'region_alexa': qs[0]['region_alexa'],  # 推送组
        }
        print(22222222222)
        # 查询云存储相关信息
        ubqs = UID_Bucket.objects.filter(uid=uid). \
            values('bucket__content', 'status', 'channel', 'endTime', 'uid')
        nowTime = int(time.time())
        if ubqs.exists():
            if ubqs[0]['endTime'] > nowTime:
                data['vod'] = list(ubqs)
        print(3333333333333)
        return response.json(0, data)
    else:
        return response.json(0)


def update_uid_set(request):
    request.encoding = 'utf-8'
    response = ResponseObject()
    if request.method == 'POST':
        request_dict = request.POST
    elif request.method == 'GET':
        request_dict = request.GET
    else:
        return response.json(444)
    token = request_dict.get('token', None)
    uid = request_dict.get('uid', None)
    version = request_dict.get('version', '')
    ucode = request_dict.get('ucode', '')
    tko = TokenObject(token)
    response.lang = tko.lang
    if tko.code == 0:
        userID = tko.userID
        nowTime = int(time.time())
        dvqs = Device_Info.objects.filter(userID_id=userID)
        if dvqs.exists():
            us_qs = UidSetModel.objects.filter(uid=uid)
            if us_qs.exists():
                uid_set_update_dict = {
                    'updTime': nowTime,
                    'version': version,
                    'ucode': ucode,
                }
                us_qs.update(**uid_set_update_dict)
            else:
                uid_set_create_dict = {
                    'uid': uid,
                    'addTime': nowTime,
                    'updTime': nowTime,
                    'version': version,
                    'ucode': ucode,
                    'device_type': dvqs[0].Type
                }
                UidSetModel.objects.create(**uid_set_create_dict)
            return response.json(0)
        else:
            return response.json(14)
    else:
        return response.json(tko.code)