ASJServer/Controller/SensorGateway/GatewayDeviceController.py

# -*- encoding: utf-8 -*-
"""
@File    : GatewayDeviceController.py
@Time    : 2022/6/6 13:50
@Author  : stephen
@Email   : zhangdongming@asj6.wecom.work
@Software: PyCharm
"""
from django.db import transaction
from django.db.models import Q
from django.views.generic.base import View

from Controller.SensorGateway.EquipmentFamilyController import EquipmentFamilyView
from Model.models import FamilyRoomDevice, FamilyRoom, GatewaySubDevice, Device_Info, UserFamily, FamilyMember, \
    UidSetModel, iotdeviceInfoModel, SmartScene
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject


# 网关主页
class GatewayDeviceView(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)
        response = ResponseObject(lang) if lang else ResponseObject(token.lang)
        if token.code != 0:
            return response.json(token.code)
        user_id = token.userID

        # 网关设备
        if operation == 'list':
            return self.gateway_device_list(request_dict, response)
        elif operation == 'del':
            return self.gateway_device_del(user_id, request_dict, response)
        elif operation == 'update':
            return self.gateway_device_update(user_id, request_dict, response)
        elif operation == 'my/family/list':
            return self.my_family_list(user_id, response)
        elif operation == 'location-setting':
            return self.device_location_setting(user_id, request_dict, response)

    @classmethod
    def device_location_setting(cls, user_id, request_dict, response):
        """
        网关位置迁移
        @param user_id: 用户id
        @param request_dict: 请求参数字典
        @param response: 响应对象
        @return: []
        """
        device_id = request_dict.get('deviceId', None)
        family_id = request_dict.get('familyId', None)
        room_id = request_dict.get('roomId', None)
        if not all([device_id, family_id]):
            return response.json(444)
        family_id = int(family_id)
        permission = EquipmentFamilyView.get_member_permission_details(user_id, family_id)
        if not permission or permission == '003':
            return response.json(404)
        try:
            with transaction.atomic():
                family_room_device_qs = FamilyRoomDevice.objects.filter(device_id=device_id, family_id=family_id)
                if family_room_device_qs.exists():
                    family_room_device_qs = family_room_device_qs.filter(sub_device=0)
                    if family_room_device_qs.exists() and room_id:
                        family_room_device_qs.update(room_id=int(room_id))
                else:
                    user_family_qs = UserFamily.objects.filter(id=family_id)
                    if not user_family_qs:
                        return response.json(173)
                    family_room_device_qs = FamilyRoomDevice.objects.filter(device_id=device_id)
                    if family_room_device_qs.exists():
                        param_data = {'family_id': family_id, 'room_id': 0}
                        if room_id:
                            param_data['room_id'] = room_id
                        family_room_device_qs.update(**param_data)
                return response.json(0)
        except Exception as e:
            print(e)
            return response.json(177, repr(e))

    @classmethod
    def gateway_device_update(cls, user_id, request_dict, response):
        """
        网关设备修改名称
        @param user_id:
        @param request_dict:
        @param response:
        @return:
        """
        device_name = request_dict.get('deviceName')
        device_id = request_dict.get('deviceId')
        if not all([device_name, device_id]):
            return response.json(444)
        device_info_qs = Device_Info.objects.filter(userID_id=user_id, id=device_id)
        if device_info_qs.exists():
            device_info_qs.update(NickName=device_name)
        return response.json(0)

    @classmethod
    def my_family_list(cls, user_id, response):
        """
        我的家庭列表
        @param user_id:
        @param response:
        @return:
        """
        user_family_qs = UserFamily.objects.filter(user_id=user_id).values()
        family_list = []
        if user_family_qs.exists():
            family_member_qs = FamilyMember.objects.filter(user_id=user_id, identity=1) \
                .order_by('sort').values('identity', 'family_id', 'family__name', 'permission_id', 'permission__no',
                                         'family__location', 'user__username', 'user__userIconUrl')
            items = EquipmentFamilyView.family_info_list(family_member_qs)
            return response.json(0, items)
        return response.json(0, family_list)

    @classmethod
    def gateway_device_del(cls, user_id, request_dict, response):
        """
        网关设备删除或删除子设备
        @param user_id:
        @param request_dict:
        @param response:
        @return:
        """
        device_id = request_dict.get('deviceId')
        family_id = request_dict.get('familyId')
        # 1 删除网关 否则删除子设备
        sub_ids = request_dict.get('subIds')
        if not family_id:
            return response.json(444)
        permission = EquipmentFamilyView.get_member_permission_details(user_id, family_id)
        if not permission or permission == '003':
            return response.json(404)
        try:
            with transaction.atomic():
                if device_id:
                    device_qs = Device_Info.objects.filter(id=device_id)
                    if device_qs.exists():
                        family_device_qs = FamilyRoomDevice.objects.filter(device_id=device_id)
                        if family_device_qs.exists():
                            family_device_qs.delete()
                        gateway_qs = GatewaySubDevice.objects.filter(device_id=device_id)
                        if gateway_qs.exists():
                            gateway_qs.delete()
                        uid_set_qs = UidSetModel.objects.filter(uid=device_qs.first().UID)
                        if uid_set_qs.exists():
                            uid_set_qs.delete()
                        SmartScene.objects.filter(device_id=device_id).delete()
                        device_qs.delete()
                elif sub_ids:
                    sub_ids = sub_ids.split(',')
                    ids = []
                    for item in sub_ids:
                        sub_id = int(item)
                        ids.append(sub_id)
                    family_device_qs = FamilyRoomDevice.objects.filter(sub_device__in=ids)
                    if family_device_qs.exists():
                        family_device_qs.delete()
                    gateway_sub_qs = GatewaySubDevice.objects.filter(id__in=ids)
                    if gateway_sub_qs.exists():
                        gateway_sub_qs.delete()
                    SmartScene.objects.filter(sub_device_id__in=ids).delete()
                return response.json(0)
        except Exception as e:
            print(e)
            return response.json(177, repr(e))

    @classmethod
    def gateway_device_list(cls, request_dict, response):
        """
        网关设备列表
        @param request_dict:
        @param response:
        @return:
        """
        device_id = request_dict.get('deviceId', None)
        if not device_id:
            return response.json(444)
        device_qs = FamilyRoomDevice.objects.filter(device_id=device_id, sub_device=0)
        if not device_qs.exists():
            return response.json(173)
        try:
            device_qs = device_qs.values('family_id', 'device_id', 'room_id', 'device__Type', 'device__NickName',
                                         'device__UID',
                                         'device__serial_number')
            device_qs = device_qs.first()
            room_id = device_qs['room_id']
            family_id = device_qs['family_id']
            gateway_room_name = ''
            if room_id:
                room_qs = FamilyRoom.objects.filter(id=room_id)
                gateway_room_name = room_qs.first().name if room_qs.exists() else ''

            iot_device_info_qs = iotdeviceInfoModel.objects.filter(
                serial_number=device_qs['device__serial_number'][0:6])
            iot_data = {}
            if iot_device_info_qs.exists():
                iot_device_Info = iot_device_info_qs.values('endpoint', 'token_iot_number')
                iot_data = {
                    'endpoint': iot_device_Info[0]['endpoint'],
                    'token_iot_number': iot_device_Info[0]['token_iot_number']
                }
            gateway = {
                'deviceId': device_qs['device_id'],
                'deviceType': device_qs['device__Type'],
                'deviceNickName': device_qs['device__NickName'],
                'UID': device_qs['device__UID'],
                'serialNumber': device_qs['device__serial_number'],
                'roomName': gateway_room_name,
                'iot': iot_data,
                'roomId': room_id,
                'familyId': family_id
            }
            family_device_qs = FamilyRoomDevice.objects.filter(device_id=device_id)
            family_device_qs = family_device_qs.filter(~Q(sub_device=0)).order_by('-created_time')

            sub_device = []
            sub_id_list = []
            if family_device_qs.exists():
                family_device_qs = family_device_qs.values()
                for item in family_device_qs:
                    sub_id = item['sub_device']
                    sub_id_list.append(sub_id)
                    gateway_sub_qs = GatewaySubDevice.objects.filter(device_id=device_id, id=sub_id).values(
                        'id', 'device_type',
                        'nickname',
                        'src_addr', 'status',
                        'created_time', 'ieee_addr')
                    if not gateway_sub_qs.exists():
                        continue
                    room_id = item['room_id']
                    room_qs = FamilyRoom.objects.filter(id=room_id)
                    gateway_room_name = room_qs.first().name if room_qs.exists() else ''
                    gateway_sub_qs = gateway_sub_qs.first()
                    sub_device.append({
                        'gatewaySubId': gateway_sub_qs['id'],
                        'nickName': gateway_sub_qs['nickname'],
                        'deviceType': gateway_sub_qs['device_type'],
                        'srcAddr': gateway_sub_qs['src_addr'],
                        'status': gateway_sub_qs['status'],
                        'createdTime': gateway_sub_qs['created_time'],
                        'roomName': gateway_room_name,
                        'roomId': room_qs.first().id if room_qs.exists() else 0,
                        'ieeeAddr': gateway_sub_qs['ieee_addr'],
                        'familyId': family_id,
                    })
            scene_count = SmartScene.objects.filter(Q(device_id=device_id) | Q(sub_device_id__in=sub_id_list)).count()
            res = {'gateway': gateway, 'sub_device': sub_device, 'sub_device_count': len(sub_device),
                   'scene_count': scene_count}
            return response.json(0, res)

        except Exception as e:
            print(e.args)
            return response.json(500)