ASJServer/SensorGateway/EquipmentFamilyManager.py

# -*- encoding: utf-8 -*-
"""
@File    : EquipmentFamilyManager.py
@Time    : 2022/5/13 15:50
@Author  : stephen
@Email   : zhangdongming@asj6.wecom.work
@Software: PyCharm
"""

import base64
import time

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

from Ansjer.config import OSS_STS_ACCESS_SECRET, OSS_STS_ACCESS_KEY
from Controller.CheckUserData import RandomStr
from Controller.DeviceConfirmRegion import Device_Region
from Model.models import Device_Info, UID_Bucket, UID_Preview, UidSetModel, UidChannelSetModel, \
    iotdeviceInfoModel, UIDModel
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject
from Service.CommonService import CommonService


# 家庭设备管理
class EquipmentFamilyManager(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):

        token = TokenObject(request.META.get('HTTP_AUTHORIZATION'))
        lang = request_dict.get('lang', None)
        if lang:
            response = ResponseObject(lang)
        else:
            response = ResponseObject(token.lang) if token.lang else ResponseObject()

        if token.code != 0:
            return response.json(token.code)
        user_id = token.userID

        # 手机端添加设备，查询，修改
        if operation == 'add':
            return self.do_save(user_id, request_dict, response, request)
        if operation == 'page':
            return self.do_device_page(user_id, request_dict, response)
        if operation == 'query':
            return self.do_device_query(user_id, request_dict, response)
        else:
            return response.json(414)

    @classmethod
    def do_save(cls, user_id, request_dict, response, request):
        """
        添加设备
        @param request:
        @param user_id:
        @param request_dict:
        @param response:
        @return:
        """
        nick_name = request_dict.get('nickName', None)
        serial_number = request_dict.get('serialNumber', None)
        device_type = request_dict.get('deviceType', None)
        # type 可能为0
        if not all([nick_name, serial_number, device_type]):
            return response.json(444, {'param': 'nick_name, serial_number, device_type'})
        device_info_qs = Device_Info.objects.filter(serial_number=serial_number, userID_id=user_id)
        if device_info_qs:
            # 判断设备是否已存在
            if device_info_qs[0].isExist == 1:
                return response.json(174)
            else:
                device_info_qs.delete()
        try:
            with transaction.atomic():
                # 格式化后的日期时间
                now_time = CommonService.timestamp_to_str(int(time.time()))
                device_id = CommonService.getUserID(getUser=False)
                Device_Info.objects.create(id=device_id, userID_id=user_id, NickName=nick_name,
                                           Type=device_type,
                                           serial_number=serial_number, data_joined=now_time,
                                           update_time=now_time)

                # 判断是否有用户绑定
                us_qs = UidSetModel.objects.filter(uid=serial_number)
                if not us_qs:
                    n_time = int(time.time())
                    ip = CommonService.get_ip_address(request)
                    region_id = Device_Region().get_device_region(ip)
                    region_alexa = 'CN' if region_id == 1 else 'ALL'
                    uid_set_create_dict = {
                        'uid': serial_number,
                        'addTime': n_time,
                        'updTime': n_time,
                        'ip': CommonService.get_ip_address(request_dict),
                        'nickname': nick_name,
                        'region_alexa': region_alexa,
                    }
                    UidSetModel.objects.create(**uid_set_create_dict)
                return response.json(0)
        except Exception as e:
            print(e)
            return response.json(177, repr(e))

    @classmethod
    def do_device_page(cls, user_id, request_dict, response):
        """
        查询设备列表
        @param user_id:
        @param request_dict:
        @param response:
        @return:
        """
        page_no = request_dict.get('pageNo', None)
        page_size = request_dict.get('pageSize', None)
        if not all([page_no, page_size]):
            return response.json(444)

        page = int(page_no)
        line = int(page_size)
        device_info_qs = Device_Info.objects.filter(userID=user_id)
        device_info_qs = device_info_qs.filter(~Q(isExist=0))
        total = device_info_qs.count()
        device_info_qs = device_info_qs.values("id", "userID_id", "NickName", "Type", "serial_number",
                                               "data_joined",
                                               "update_time")[(page - 1) * line: page * line]
        data = []
        for item in device_info_qs:
            data.append({
                'id': item['id'],
                'userId': item['userID_id'],
                'nickName': item['NickName'],
                'type': item['Type'],
                'serialNumber': item['serial_number'],
                'dataJoined': item['data_joined'].strftime("%Y-%m-%d %H:%M:%S"),
                'updateTime': item['update_time'].strftime("%Y-%m-%d %H:%M:%S")
            })
        return response.json(0, {'list': data, 'total': total})

    @classmethod
    def do_device_query(cls, user_id, request_dict, response):
        """
        查询用户设备信息
        @param user_id: 用户id
        @param request_dict: 请求参数
        @param response: 响应对象
        @return: response
        """
        page = request_dict.get('page', None)
        line = request_dict.get('line', None)
        nick_name = request_dict.get('NickName', None)

        page = int(page)
        line = int(line)
        uid = request_dict.get('uid', None)
        device_start = time.time()
        device_info_list = cls.get_device_info_list(user_id, nick_name, uid,
                                                    page, line)
        device_end = time.time()
        print("设备信息代码执行时间")
        print(device_end - device_start)
        uid_list = []
        # 判断是否是主用户 isPrimaryUser=0：否，1：是
        for dvl in device_info_list:
            if dvl['primaryUserID'] and dvl['id'] == dvl['primaryUserID']:
                dvl['isPrimaryUser'] = 1
            else:
                dvl['isPrimaryUser'] = 0
            uid_list.append(dvl['UID'])
        print(uid_list)
        # 设备关联套餐，设备预览图
        bucket_start = time.time()
        uid_bucket_qs, uid_preview_qs = cls.get_bucket_and_preview_by_uid(uid_list)
        bucket_end = time.time()
        print("设备套餐代码执行时间")
        print(bucket_end - bucket_start)
        # 设备配置信息
        uid_set_start = time.time()
        uid_set_dict = cls.get_uid_set_dict(uid_list)
        uid_set_end = time.time()
        print("设备配置详情代码执行时间")
        print(uid_set_end - uid_set_start)
        # 设备详情信息
        details_start = time.time()
        result = cls.get_device_details(device_info_list, uid_bucket_qs, uid_preview_qs, uid_set_dict)
        details_end = time.time()
        print("设备uid详情代码执行时间")
        print(details_end - details_start)
        # print('NickName搜索缓存')
        # print('缓存分页')
        items = []
        pwd_start = time.time()
        for index, item in enumerate(result):
            # 加密
            if item['View_Password']:
                item['View_Password'] = cls.encrypt_pwd(item['View_Password'])
            items.append(item)
        pwd_end = time.time()
        print("加密代码执行时间")
        print(pwd_end - pwd_start)
        return response.json(0, items)

    @classmethod
    def get_device_info_list(cls, user_id, nick_name, uid, page, line):
        """
        根据用户id获取设备信息
        @param uid: uid
        @param nick_name: 设备名称
        @param line: 条数
        @param page: 页数
        @param user_id: 用户id
        @return: device_info_list 设备信息列表
        """
        # 获取用户设备信息
        device_info_qs = Device_Info.objects.filter(userID_id=user_id)
        # 过滤已重置的设备
        device_info_qs = device_info_qs.filter(~Q(isExist=2))
        if nick_name:
            device_info_qs = device_info_qs.filter(NickName__icontains=nick_name)
        if uid:
            device_info_qs.filter(UID=uid)
        device_info_values = device_info_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')
        device_info_values = device_info_values[(page - 1) * line:page * line]
        device_info_list = CommonService.qs_to_list(device_info_values)
        return device_info_list

    @classmethod
    def get_bucket_and_preview_by_uid(cls, uid_list):
        """
        根据uid列表查询套餐
        @param uid_list: uid列表
        @return: uid_bucket_qs
        """
        uid_bucket_qs = UID_Bucket.objects.filter(uid__in=uid_list).values('bucket__content', 'status', 'channel',
                                                                           'endTime', 'uid')
        uid_preview_qs = UID_Preview.objects.filter(uid__in=uid_list).order_by('channel').values('id', 'uid', 'channel')
        return uid_bucket_qs, uid_preview_qs

    @classmethod
    def get_uid_set_dict(cls, uid_list):
        """

        @param uid_list: uid列表
        @return: uid_set_dict uid配置信息
        """
        uid_set_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', 'is_human', 'is_custom_voice',
                    'is_ptz', 'double_wifi', 'is_ai')
        uid_set_dict = {}
        for us in uid_set_qs:
            uid_set_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'],
                'is_human': us['is_human'],
                'is_custom_voice': us['is_custom_voice'],
                'is_ptz': us['is_ptz'],
                'double_wifi': us['double_wifi'],
                'is_ai': us['is_ai']
            }
            # 从uid_channel里面取出通道配置信息
            uid_channel_set_qs = UidChannelSetModel.objects.filter(uid__id=us['id']) \
                .values('channel', 'channel_name',
                        'pir_audio', 'mic_audio',
                        'battery_status',
                        'battery_level',
                        'sleep_status',
                        'sleep_time',
                        'light_night_model',
                        'light_alarm_type',
                        'light_alarm_level',
                        'light_alarm_man_en',
                        'light_alarm_vol',
                        'light_long_light'
                        )
            channels_list = []
            for ucs in uid_channel_set_qs:
                channels_dict = {
                    '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_list.append(channels_dict)
            uid_set_dict[us['uid']]['channels'] = channels_list
        return uid_set_dict

    @classmethod
    def get_device_details(cls, device_info_list, uid_bucket_qs, uid_preview_qs, uid_set_dict):
        """
        设备详情
        @param device_info_list: 设备信息列表
        @param uid_bucket_qs: 套餐对象
        @param uid_preview_qs:
        @param uid_set_dict:
        @return:
        """
        now_time = int(time.time())
        data = []
        for p in device_info_list:
            # 获取iotDeviceInfo表的endpoint和tokenIotNumber
            p['iot'] = []
            if p['serial_number']:  # 存在序列号根据序列号查询
                iot_device_info_qs = iotdeviceInfoModel.objects.filter(serial_number=p['serial_number'][0:6])
            else:  # 根据uid查询
                iot_device_info_qs = iotdeviceInfoModel.objects.filter(uid=p['UID'])
            if iot_device_info_qs.exists():
                iot_device_Info = iot_device_info_qs.values('endpoint', 'token_iot_number')
                p['iot'].append({
                    'endpoint': iot_device_Info[0]['endpoint'],
                    'token_iot_number': iot_device_Info[0]['token_iot_number']
                })

            p['vod'] = []
            for dm in uid_bucket_qs:
                if p['UID'] == dm['uid']:
                    if dm['endTime'] > now_time:
                        p['vod'].append(dm)
            p['preview'] = []

            auth = oss2.Auth(OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET)
            bucket = oss2.Bucket(auth, 'oss-cn-hongkong.aliyuncs.com', 'statres')

            for up in uid_preview_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)

            p_uid = p['UID']

            # 返回设备初始化字符
            uid_qs = UIDModel.objects.filter(uid=p_uid).values('platform', 'init_string', 'init_string_app')
            if uid_qs.exists():
                p['platform'] = uid_qs[0]['platform']
                p['initString'] = uid_qs[0]['init_string']
                p['initStringApp'] = uid_qs[0]['init_string_app']

            if p_uid in uid_set_dict:
                # 设备版本号
                uidversion = uid_set_dict[p_uid]['version']
                if len(uidversion) > 6:
                    uidversion = uidversion[0: uidversion.rfind('.')]
                p['uid_version'] = uidversion
                p['ucode'] = uid_set_dict[p_uid]['ucode']
                p['detect_interval'] = uid_set_dict[p_uid]['detect_interval']
                p['detect_status'] = uid_set_dict[p_uid]['detect_status']
                p['detect_group'] = uid_set_dict[p_uid]['detect_group']
                p['region_alexa'] = uid_set_dict[p_uid]['region_alexa']
                p['is_alexa'] = uid_set_dict[p_uid]['is_alexa']
                p['deviceModel'] = uid_set_dict[p_uid]['deviceModel']
                p['TimeZone'] = uid_set_dict[p_uid]['TimeZone']
                p['TimeStatus'] = uid_set_dict[p_uid]['TimeStatus']
                p['SpaceUsable'] = uid_set_dict[p_uid]['SpaceUsable']
                p['SpaceSum'] = uid_set_dict[p_uid]['SpaceSum']
                p['MirrorType'] = uid_set_dict[p_uid]['MirrorType']
                p['RecordType'] = uid_set_dict[p_uid]['RecordType']
                p['OutdoorModel'] = uid_set_dict[p_uid]['OutdoorModel']
                p['WIFIName'] = uid_set_dict[p_uid]['WIFIName']
                p['isDetector'] = uid_set_dict[p_uid]['isDetector']
                p['DetectorRank'] = uid_set_dict[p_uid]['DetectorRank']
                p['is_human'] = uid_set_dict[p_uid]['is_human']
                p['is_custom_voice'] = uid_set_dict[p_uid]['is_custom_voice']
                p['is_ptz'] = uid_set_dict[p_uid]['is_ptz']
                p['channels'] = uid_set_dict[p_uid]['channels']
                p['double_wifi'] = uid_set_dict[p_uid]['double_wifi']
                p['is_ai'] = uid_set_dict[p_uid]['is_ai']
                # 设备昵称 调用影子信息昵称，先阶段不可
                if uid_set_dict[p_uid]['nickname']:
                    p['NickName'] = uid_set_dict[p_uid]['nickname']
            else:
                # 设备版本号
                p['uid_version'] = ''
                p['ucode'] = ''
            data.append(p)
        return data

    @classmethod
    def encrypt_pwd(cls, user_pwd):
        """
        用户密码加密
        @param user_pwd:用户密码
        @return: user_pwd 加密后的pwd
        """
        for i in range(1, 4):
            if i == 1:
                user_pwd = RandomStr(3, False) + user_pwd + RandomStr(3, False)
                user_pwd = base64.b64encode(str(user_pwd).encode("utf-8")).decode('utf8')
            if i == 2:
                user_pwd = RandomStr(2, False) + str(user_pwd) + RandomStr(2, False)
                user_pwd = base64.b64encode(str(user_pwd).encode("utf-8")).decode('utf8')
            if i == 3:
                user_pwd = RandomStr(1, False) + str(user_pwd) + RandomStr(1, False)
                user_pwd = base64.b64encode(str(user_pwd).encode("utf-8")).decode('utf8')
        return user_pwd

    # @classmethod
    # def family_save(cls, user_id, save_type, lang):
    #     # 0：默认创建家庭，1：新增，2：修改
    #     n_time = int(time.time())
    #     if save_type == 0:
    #         device_qs = Device_User.objects.filter(userID=user_id)
    #         if device_qs.exists():
    #             device_user = device_qs.first()
    #             family_name = device_user.username if device_user.username else device_user.userEmail
    #             family_name = family_name + "的家" if lang == 'cn' else family_name + " home"
    #             user_family = LoocamUserFamily.objects.create(name=family_name, updated_time=n_time,
    #                                                           created_time=n_time)
    #             if user_family.id:
    #                 pass
    #
    #     return ''

    # @classmethod
    # def family_query(cls, user_id):
    #     family_qs = LoocamFamilyMember.objects.filter(user_id=user_id)
    #     if family_qs.exists():
    #         return True
    #     else:
    #         return False