ASJServer/Controller/SensorGateway/GatewayFamilyRoomController.py

# -*- encoding: utf-8 -*-
"""
@File    : GatewayFamilyRoomController.py
@Time    : 2022/5/24 19:43
@Author  : stephen
@Email   : zhangdongming@asj6.wecom.work
@Software: PyCharm
"""

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

from Model.models import FamilyRoomDevice, FamilyRoom
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject
from Controller.SensorGateway.EquipmentFamilyController import EquipmentFamilyView


# 家庭房间管理
class GatewayFamilyRoomView(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 = request.META.get('HTTP_AUTHORIZATION')
        token = TokenObject(token)
        lang = request_dict.get('lang', token.lang)
        response = ResponseObject(lang)
        if token.code != 0:
            return response.json(token.code)
        app_user_id = token.userID
        # 添加设备关联房间
        if operation == 'device-changes':
            return self.room_device_save(app_user_id, request_dict, response)
        # 房间排序
        elif operation == 'sort':
            return self.room_sort_save(request_dict, response)
        # 房间删除
        elif operation == 'del':
            return self.room_del(app_user_id, request_dict, response)
        # 房间详情
        elif operation == 'details':
            return self.get_room_details(app_user_id, request_dict, response)

    @classmethod
    def room_device_save(cls, app_user_id, request_dict, response):
        """
        房间加入设备or移除设备
        @param app_user_id:
        @param request_dict:
        @param response:
        @return:
        """
        family_id = request_dict.get('familyId', None)
        device_ids = request_dict.getlist('deviceIds', None)
        room_id = request_dict.get('roomId', None)
        operate = request_dict.get('operate', None)
        if not all([family_id, device_ids, operate, room_id]):
            return response.json(444)
        operate = int(operate)
        is_owner = EquipmentFamilyView.get_family_owner(app_user_id, family_id)
        if not is_owner:
            return response.json(404)
        with transaction.atomic():
            room_qs = FamilyRoom.objects.filter(family_id=family_id, id=room_id)
            if not room_qs.exists():
                return response.json(173)
            for item in device_ids:
                qs = FamilyRoomDevice.objects.filter(family_id=family_id, device_id=item)
                if qs.exists():
                    qs.update(room_id=0) if operate == 1 else qs.update(room_id=int(room_id))
            return response.json(0)

    @classmethod
    def room_del(cls, user_id, request_dict, response):
        """
        房间多选删除
        @param user_id: 当前登录用户id
        @param request_dict: 请求参数
        @param response: 响应参数
        @return:
        """
        ids = request_dict.get('roomIds', None)
        if not ids:
            return response.json(444)
        ids = ids.split(',')
        room_id = ids[0]
        room_info = FamilyRoom.objects.filter(id=room_id)
        if not room_info.exists():
            return response.json(173)
        is_owner = EquipmentFamilyView.get_family_owner(user_id, room_info.first().family_id)
        if not is_owner:
            return response.json(404)
        try:
            with transaction.atomic():
                for item in ids:
                    room_id = int(item)
                    room_device = FamilyRoomDevice.objects.filter(room_id=room_id)
                    if room_device.exists():
                        room_device.update(room_id=0)
                    FamilyRoom.objects.filter(id=room_id).delete()
                return response.json(0)
        except Exception as e:
            print(e)
            return response.json(177, repr(e))

    @classmethod
    def room_sort_save(cls, request_dict, response):
        """
        房间排序
        @param request_dict: 请求参数
        @param response: 响应参数
        @return:
        """
        ids = request_dict.get('ids', None)
        if not ids:
            return response.json(444)
        items = ids.split(',')
        for item in items:
            vals = item.split('-')
            room_id = vals[0]
            sort = vals[1]
            family_room = FamilyRoom.objects.filter(id=int(room_id))
            if family_room.exists():
                family_room.update(sort=int(sort))
        return response.json(0)

    @classmethod
    def get_room_details(cls, app_user_id, request_dict, response):
        """
        房间设备详情
        @param app_user_id:
        @param request_dict:
        @param response:
        @return:
        """
        family_id = request_dict.get('familyId', None)
        room_id = request_dict.get('roomId', None)
        page_no = request_dict.get('pageNo', None)
        page_size = request_dict.get('pageSize', None)
        if not all([family_id, room_id, page_no, page_size]):
            return response.json(444)
        room_count = FamilyRoomDevice.objects.filter(family_id=int(family_id), room_id=int(room_id)).values(
            'device_id').annotate(count=Count('device_id')).count()
        device_room = []
        # 房间设备列表
        if room_count > 0:
            device_room_list = EquipmentFamilyView.get_family_device_list(user_id=app_user_id, page_no=1,
                                                                          page_size=room_count,
                                                                          family_id=int(family_id),
                                                                          room_id=int(room_id))

            if device_room_list:
                room_name = FamilyRoom.objects.get(id=room_id).name

                for item in device_room_list:
                    device_room.append({
                        'deviceId': item['id'],
                        'deviceType': item['Type'],
                        'nickName': item['NickName'],
                        'roomName': room_name,
                    })
        device_not_room = []
        device_not_room_count = FamilyRoomDevice.objects.filter(family_id=int(family_id), room_id=0).values(
            'device_id').annotate(count=Count('device_id')).count()
        if device_not_room_count > 0:
            not_room_device_list = EquipmentFamilyView.get_family_device_list(user_id=app_user_id, page_no=int(page_no),
                                                                              page_size=int(page_size),
                                                                              family_id=int(family_id), room_id=0,
                                                                              is_room_other=True)
            if not_room_device_list:
                for item in not_room_device_list:
                    room_device_qs = FamilyRoomDevice.objects.filter(family_id=int(family_id))
                    room_device_qs = room_device_qs.filter(~Q(room_id=0))
                    name = ''
                    if room_device_qs.exists():
                        family_room_qs = FamilyRoom.objects.filter(id=room_device_qs.first().room_id)
                        if family_room_qs.exists():
                            name = family_room_qs.first().name
                    device_not_room.append({
                        'deviceId': item['id'],
                        'deviceType': item['Type'],
                        'nickName': item['NickName'],
                        'roomName': name
                    })
        return response.json(0, {'deviceRooms': device_room, 'deviceNotRooms': device_not_room})