ASJPush/Controller/gatewayController.py

# -*- coding: utf-8 -*-
"""
@Author ： Rocky
@Time ： 2022/5/9 10:51
@File ：gatewayController.py
"""
import time

from django.views.generic.base import View

from AnsjerPush.Config.gatewaySensorConfig import SENSOR_TYPE, EVENT_TYPE
from AnsjerPush.config import LOGGER
from Model.models import SensorRecord, GatewaySubDevice, GatewayPush, Device_Info, SceneLog, SmartScene, CountryModel
from Object.RedisObject import RedisObject
from Object.ResponseObject import ResponseObject
from Object.utils import LocalDateTimeUtil
from Service.CommonService import CommonService
from Service.EquipmentInfoService import EquipmentInfoService
from Service.HuaweiPushService.HuaweiPushService import HuaweiPushObject
from Service.PushService import PushObject


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

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

    def validation(self, request_dict, operation):
        response = ResponseObject()
        if operation == 'gatewayPush':  # 网关推送
            return self.gateway_push(request_dict, response)
        elif operation == 'sceneLogPush':  # 场景日志推送
            return self.scene_log_push(request_dict, response)
        elif operation == 'socketPush':  # 插座推送
            return self.socket_msg_push(request_dict, response)
        else:
            return response.json(414)

    @classmethod
    def gateway_push(cls, request_dict, response):
        """
        网关推送
        @param request_dict: 请求参数
        @request_dict serial_number: 序列号
        @request_dict ieee_addr: 长地址
        @request_dict sensor_type: 传感器类型
        @request_dict event_type: 事件类型
        @request_dict defense: 防御状态,0:撤防,1:防御
        @request_dict sensor_status: 拆动状态,拆动时传参
        @param response: 响应对象
        @return: response
        """
        serial_number = request_dict.get('serial_number', None)
        ieee_addr = request_dict.get('ieee_addr', None)
        sensor_type = int(request_dict.get('sensor_type', None))
        event_type = int(request_dict.get('event_type', None))
        defense = int(request_dict.get('defense', None))
        LOGGER.info('---调用网关推送接口--- request_dict:{}'.format(request_dict))
        if not all([serial_number, ieee_addr, sensor_type, event_type]):
            return response.json(444)

        n_time = int(time.time())

        try:
            # 查询子设备表id
            gateway_sub_device_qs = GatewaySubDevice.objects.filter(device__serial_number=serial_number,
                                                                    device_type=sensor_type, ieee_addr=ieee_addr). \
                values('id', 'nickname', 'device__userID__region_country')
            if not gateway_sub_device_qs.exists():
                return response.json(173)

            country_id = gateway_sub_device_qs[0]['device__userID__region_country']
            lang = cls.confirm_lang(country_id)
            alarm = cls.get_alarm(lang, event_type)

            gateway_sub_device_id = gateway_sub_device_qs[0]['id']
            nickname = gateway_sub_device_qs[0]['nickname']
            sensor_record_dict = {
                'gateway_sub_device_id': gateway_sub_device_id,
                'alarm': alarm,
                'event_type': event_type,
                'created_time': n_time,
            }
            # 处理温湿度,不推送
            if sensor_type == SENSOR_TYPE['tem_hum_sensor'] and (
                    event_type == EVENT_TYPE['temperature'] or event_type == EVENT_TYPE['humidity']):
                num = request_dict.get('num', None)
                num = str(int(num) / 100)
                sensor_record_dict['alarm'] = num
                SensorRecord.objects.create(**sensor_record_dict)
                return response.json(0)

            SensorRecord.objects.create(**sensor_record_dict)

            # 门磁被拆动/拆动恢复,修改拆动状态
            if event_type == 2152:
                gateway_sub_device_qs.update(is_tampered=1)
            elif event_type == 2156:
                gateway_sub_device_qs.update(is_tampered=0)

            # 撤防状态不推送
            if defense == 0:
                return response.json(0)

            device_info_qs = Device_Info.objects.filter(serial_number=serial_number).values('userID_id')
            if not device_info_qs.exists():
                return response.json(173)

            equipment_info_list = []

            for device_info in device_info_qs:
                user_id = device_info['userID_id']

                # 组织存储数据
                local_date_time = CommonService.get_now_time_str(n_time=n_time, tz=0, lang='cn')[:10]
                equipment_info_list.append(EquipmentInfoService.get_equipment_info_obj(
                    local_date_time,
                    add_time=n_time,
                    event_time=n_time,
                    receive_time=n_time,
                    device_uid=serial_number,
                    device_nick_name=nickname,
                    alarm=alarm,
                    event_type=event_type,
                    device_user_id=user_id,
                ))
                if equipment_info_list:
                    # 根据日期获得星期几
                    week = LocalDateTimeUtil.date_to_week(local_date_time)
                    EquipmentInfoService.equipment_info_bulk_create(week, equipment_info_list)

                # 查询推送配置数据
                gateway_push_qs = GatewayPush.objects.filter(user_id=user_id, logout=False). \
                    values('user_id', 'app_bundle_id', 'app_type', 'push_type', 'token_val', 'm_code', 'lang', 'm_code',
                           'tz')
                if not gateway_push_qs.exists():
                    continue

                kwargs = {
                    'n_time': n_time,
                    'event_type': event_type,
                    'nickname': nickname,
                }

                # 推送到每台登录账号的手机
                for gateway_push in gateway_push_qs:
                    app_bundle_id = gateway_push['app_bundle_id']
                    push_type = gateway_push['push_type']
                    token_val = gateway_push['token_val']
                    lang = gateway_push['lang']
                    tz = gateway_push['tz'] if gateway_push['tz'] else 0

                    # 获取推送所需数据
                    msg_title = PushObject.get_msg_title(nickname)
                    msg_text = PushObject.get_gateway_msg_text(n_time, tz, lang, alarm)

                    kwargs['msg_title'] = msg_title
                    kwargs['msg_text'] = msg_text
                    kwargs['app_bundle_id'] = app_bundle_id
                    kwargs['token_val'] = token_val

                    try:
                        # 推送消息
                        cls.push_msg(push_type, **kwargs)
                    except Exception as e:
                        LOGGER.info('网关推送消息异常,errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
                        continue

            return response.json(0)
        except Exception as e:
            LOGGER.info('---网关推送接口异常--- {}'.format(repr(e)))
            return response.json(500, 'error_ine:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def confirm_lang(country_id):
        """
        根据country_id确定语言
        @param country_id: 国家id
        @return lang: 语言
        """
        country_qs = CountryModel.objects.filter(id=country_id).values('country_code')
        if not country_qs.exists():
            lang = 'NA'
        else:
            lang = country_qs[0]['country_code']
        return lang

    @staticmethod
    def get_alarm(lang, event_type):
        """
        根据语言和事件类型确定警报内容
        @param lang: 语言
        @param event_type: 事件类型
        @return alarm: 警报内容
        """
        alarm = ''
        if lang == 'CN':
            # 门磁
            if event_type == 2150:
                alarm = '门磁开'
            elif event_type == 2151:
                alarm = '门磁关'
            elif event_type == 2152:
                alarm = '被拆动'
            elif event_type == 2156:
                alarm = '拆动恢复'

            # 智能按钮
            elif event_type == 2160:
                alarm = '紧急按钮按下'
            elif event_type == 2161:
                alarm = '单击'
            elif event_type == 2162:
                alarm = '双击'
            elif event_type == 2163:
                alarm = '长按'

            # 水浸
            elif event_type == 2170:
                alarm = '水浸触发'
            elif event_type == 2171:
                alarm = '水浸恢复'

            # 烟雾
            elif event_type == 2180:
                alarm = '烟雾触发'
            elif event_type == 2181:
                alarm = '烟雾恢复'

            # 人体红外
            elif event_type == 2190:
                alarm = '有人移动'
            elif event_type == 2191:
                alarm = '无人移动'

            # 低电量
            elif event_type in (2153, 2164, 2172, 2182, 2193):
                alarm = '低电量'
        else:
            # 门磁
            if event_type == 2150:
                alarm = 'Door magnetic opening'
            elif event_type == 2151:
                alarm = 'Door magnetic closing'
            elif event_type == 2152:
                alarm = 'Be dismantled'
            elif event_type == 2156:
                alarm = 'Dismantling recovery'

            # 智能按钮
            elif event_type == 2160:
                alarm = 'Emergency button pressed'
            elif event_type == 2161:
                alarm = 'Single click'
            elif event_type == 2162:
                alarm = 'Double click'
            elif event_type == 2163:
                alarm = 'Long press'

            # 水浸
            elif event_type == 2170:
                alarm = 'Water immersion trigger'
            elif event_type == 2171:
                alarm = 'Water immersion recovery'

            # 烟雾
            elif event_type == 2180:
                alarm = 'Smoke triggering'
            elif event_type == 2181:
                alarm = 'Smoke recovery'

            # 人体红外
            elif event_type == 2190:
                alarm = 'Someone moving'
            elif event_type == 2191:
                alarm = 'Unmanned movement'

            # 低电量
            elif event_type in (2153, 2164, 2172, 2182, 2193):
                alarm = 'LOW BATTERY'
        return alarm

    @classmethod
    def scene_log_push(cls, request_dict, response):
        """
        网关智能场景日志推送
        @param request_dict: 请求参数
        @request_dict sceneId: 场景id
        @request_dict status: 状态
        @param response: 响应对象
        @return: response
        """
        scene_id = request_dict.get('sceneId', None)
        status = request_dict.get('status', None)
        LOGGER.info('---场景日志推送接口--- request_dict:{}'.format(request_dict))
        if not all([scene_id, status]):
            return response.json(444)

        smart_scene_qs = SmartScene.objects.filter(id=scene_id).values('scene_name', 'conditions', 'tasks', 'device_id',
                                                                       'sub_device_id', 'user_id')
        if not smart_scene_qs.exists():
            return response.json(173)

        scene_name = smart_scene_qs[0]['scene_name']
        tasks = smart_scene_qs[0]['tasks']
        device_id = smart_scene_qs[0]['device_id']
        sub_device_id = smart_scene_qs[0]['sub_device_id']
        n_time = int(time.time())
        user_id = smart_scene_qs[0]['user_id']
        if sub_device_id:
            gateway_sub_device_qs = GatewaySubDevice.objects.filter(id=sub_device_id).values('nickname')
            nickname = gateway_sub_device_qs[0]['nickname'] if gateway_sub_device_qs.exists() else ''
        else:
            device_qs = Device_Info.objects.filter(id=device_id).values('NickName')
            nickname = device_qs[0]['NickName'] if device_qs.exists() else ''
        log_dict = {
            'scene_id': scene_id,
            'scene_name': scene_name,
            'tasks': tasks,
            'status': status,
            'device_id': device_id,
            'sub_device_id': sub_device_id,
            'created_time': n_time,
        }
        tasks = eval(tasks)

        try:
            SceneLog.objects.create(**log_dict)
            # 推送日志
            gateway_push_qs = GatewayPush.objects.filter(user_id=user_id, logout=False). \
                values('user_id', 'app_bundle_id', 'app_type', 'push_type', 'token_val', 'm_code', 'lang', 'm_code',
                       'tz')
            if not gateway_push_qs.exists():
                return response.json(174)
            for task in tasks:
                event_type = task['event_type']
                if event_type == '1001':
                    kwargs = {
                        'n_time': n_time,
                        'event_type': event_type,
                        'nickname': nickname,
                    }
                    event_info = task['value']
                    # 推送到每台登录账号的手机
                    for gateway_push in gateway_push_qs:
                        app_bundle_id = gateway_push['app_bundle_id']
                        push_type = gateway_push['push_type']
                        token_val = gateway_push['token_val']

                        kwargs['msg_title'] = PushObject.get_msg_title(nickname)
                        kwargs['msg_text'] = event_info
                        kwargs['app_bundle_id'] = app_bundle_id
                        kwargs['token_val'] = token_val

                        try:
                            # 推送消息
                            cls.push_msg(push_type, **kwargs)
                        except Exception as e:
                            LOGGER.info(
                                '场景日志推送消息异常,errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
                            continue
            return response.json(0)
        except Exception as e:
            LOGGER.info('---场景日志推送接口异常--- {}'.format(repr(e)))
            return response.json(500, 'error_ine:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def push_msg(push_type, **kwargs):
        """
        发送推送消息
        @param push_type: 推送类型
        @param kwargs: 推送参数
        @return: None
        """
        if push_type == 0:  # ios apns
            PushObject.ios_apns_push(**kwargs)
        elif push_type == 1:  # android gcm
            PushObject.android_fcm_push(**kwargs)
        elif push_type == 2:  # android 极光推送
            PushObject.android_jpush(**kwargs)
        elif push_type == 3:
            huawei_push_object = HuaweiPushObject()
            huawei_push_object.send_push_notify_message(**kwargs)
        elif push_type == 4:  # android 小米推送
            channel_id = 104551
            PushObject.android_xmpush(channel_id=channel_id, **kwargs)
        elif push_type == 5:  # android vivo推送
            PushObject.android_vivopush(**kwargs)
        elif push_type == 6:  # android oppo推送
            channel_id = 'DEVICE_REMINDER'
            PushObject.android_oppopush(channel_id=channel_id, **kwargs)
        elif push_type == 7:  # android 魅族推送
            PushObject.android_meizupush(**kwargs)

    @classmethod
    def socket_msg_push(cls, request_dict, response):
        """
        智能插座开关状态推送
        """
        event_key = ''
        redis_obj = RedisObject(db=7)
        try:
            switch_key = 'LOOCAM:SOCKET:SERIAL:NUMBER:{}:{}:{}'
            serial_number = request_dict.get('serialNumber', None)
            device_time = request_dict.get('deviceTime', None)
            status = request_dict.get('status', None)
            event_key = f'LOOCAM:SOCKET:SETNX:{serial_number}:{status}:{device_time}'
            is_nx = redis_obj.CONN.setnx(event_key, 1)  # 获取锁
            if not is_nx:
                return response.json(5)
            if not all([serial_number, status, device_time]):
                redis_obj.del_data(event_key)  # 释放锁
                return response.json(444)
            status = int(status)
            switch_key = switch_key.format(serial_number, status, device_time)
            switch = redis_obj.get_data(switch_key)
            if switch and int(switch) == status:
                redis_obj.del_data(event_key)  # 释放锁
                return response.json(0, "电源开关状态重复上报")
            now_time = int(device_time) if device_time else int(time.time())
            LOGGER.info('已订阅成功接收：事件类型{},状态：{}'.format(serial_number, status))
            # 获取主用户设备id
            log_dict = {
                'status': status,
                'device_id': serial_number,
                'created_time': now_time,
            }
            SceneLog.objects.create(**log_dict)
            redis_obj.set_data(switch_key, status, 60 * 10)
            redis_obj.del_data(event_key)  # 释放锁
            return response.json(0)
        except Exception as e:
            print(repr(e))
            redis_obj.del_data(event_key)
            LOGGER.info('---插座开关日志推送接口异常--- {}'.format(repr(e)))
            return response.json(500, repr(e))