ASJPush/Controller/DetectControllerV2.py

import json
import logging
import threading

from django.http import JsonResponse
from django.views.generic.base import View

from AnsjerPush.config import CONFIG_EUR, CONFIG_INFO, CONFIG_US, UNRESTRICTED_FREQUENCY_PUSH_EVENT_TYPE_LIST, \
    CONFIG_TEST, CONFIG_CN
from Object.RedisObject import RedisObject
from Object.enums.RedisKeyConstant import RedisKeyConstant
from Service.DevicePushService import DevicePushService

TIME_LOGGER = logging.getLogger('time')
ERROR_INFO_LOGGER = logging.getLogger('error_info')


# 移动侦测V2接口
class NotificationV2View(View):

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

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

    @staticmethod
    def validation(request_dict):
        """
        设备触发报警消息推送
        @param request_dict:uidToken 加密uid
        @param request_dict:etk 加密uid
        @param request_dict:channel 设备通道号
        @param request_dict:n_time 设备触发报警时间
        @param request_dict:event_type 设备事件类型
        @param request_dict:is_st 文件类型(0,2:无图, 1:单张图片, 3:三张图片)
        @param request_dict:region 文件存储区域（1：国外, 2:国内)
        @param request_dict:electricity 电量值
        @param request_dict:time_token 时间戳token
        @param request_dict:uid uid
        @param request_dict:dealings_type 往来检测 1：来，2：离开
        @param request_dict:detection 检测类型 0：普通，1：算法
        """
        uidToken = request_dict.get('uidToken', None)
        etk = request_dict.get('etk', None)
        channel = request_dict.get('channel', '1')
        n_time = request_dict.get('n_time', None)
        event_type = request_dict.get('event_type', None)
        is_st = request_dict.get('is_st', None)
        region = request_dict.get('region', None)
        electricity = request_dict.get('electricity', '')
        dealings_type = int(request_dict.get('dealingsType', 0))
        detection = int(request_dict.get('detection', 0))
        button = request_dict.get('button', '1')
        storage_location = request_dict.get('storage_location', None)
        uid = request_dict.get('uid', None)
        # 参数校验
        if not all([channel, n_time]):
            return JsonResponse(status=200, data={'code': 444, 'msg': 'param is wrong'})
        if not region or not is_st:
            return JsonResponse(status=200, data={'code': 404, 'msg': 'no region or is_st'})

        is_st = int(is_st)
        region = int(region)
        event_type = int(event_type)
        redis_obj = RedisObject()
        try:
            if uid is None:
                uid = DevicePushService.decode_uid(etk, uidToken)
            if len(uid) != 20 and len(uid) != 14:
                return JsonResponse(status=200, data={'code': 404, 'msg': 'wrong uid'})
            TIME_LOGGER.info('开始推送,uid:{},参数:{}'.format(uid, request_dict))
            # 判断是否为系统消息
            is_sys_msg = DevicePushService.judge_sys_msg(event_type)
            if is_sys_msg:
                push_interval = '{}_{}_{}_flag'.format(uid, channel, event_type)
            else:
                push_interval = '{}_{}_flag'.format(uid, channel)

            req_limiting = '{}_{}_{}_ptl'.format(uid, channel, event_type)
            cache_req_limiting = redis_obj.get_data(key=req_limiting)  # 获取请求限流缓存数据
            cache_app_push = redis_obj.get_data(key=push_interval)  # 获取APP推送消息时间间隔缓存数据
            if event_type not in UNRESTRICTED_FREQUENCY_PUSH_EVENT_TYPE_LIST:
                if cache_req_limiting:  # 限流存在则直接返回
                    return JsonResponse(status=200, data={'code': 0, 'msg': 'Push again in one minute'})
            redis_obj.set_data(key=req_limiting, val=1, expire=60)  # 当缓存不存在限流数据 重新设置一分钟请求一次

            # OZI定制客户儿童保护模式
            child_protection = event_type == 1023 and detection == 0
            # 查询uid_push和uid_set数据
            if child_protection:
                uid_push_qs = DevicePushService.get_uid_push_by_uid(uid)  # 查主用户
            else:
                uid_push_qs = DevicePushService.query_uid_push(uid, event_type, button)
            if uid_push_qs is None:
                return JsonResponse(status=200, data={'code': 175, 'msg': 'device_info数据不存在'})
            if not uid_push_qs.exists():
                TIME_LOGGER.info('推送响应,uid:{},uid_push数据不存在!'.format(uid))
                return JsonResponse(status=200, data={'code': 176, 'msg': 'uid_push数据不存在'})

            ai_type = 0 if child_protection else uid_push_qs.first()['uid_set__ai_type']
            device_type = uid_push_qs.first()['uid_set__device_type']

            # uid_push_qs转存列表
            uid_set_push_list = DevicePushService.qs_to_list(uid_push_qs)
            nickname = uid_set_push_list[0]['uid_set__nickname']
            nickname = uid if not nickname else nickname

            # APP消息提醒推送间隔
            detect_interval = uid_set_push_list[0]['uid_set__detect_interval']
            if event_type not in UNRESTRICTED_FREQUENCY_PUSH_EVENT_TYPE_LIST:
                if not cache_app_push:
                    # 缓存APP提醒推送间隔 默认1分钟提醒一次
                    DevicePushService.cache_push_detect_interval(redis_obj, push_interval, detect_interval,
                                                                 uid_set_push_list[0]['uid_set__new_detect_interval'])
            else:
                cache_app_push = ''

            bucket = ''
            aws_s3_client = ''
            # 推图,初始化s3 client
            if is_st == 1 or is_st == 3:
                aws_s3_client = DevicePushService.get_s3_client(region=region)
                bucket = 'foreignpush' if region == 1 else 'push'

            # 推送相关参数
            push_kwargs = {
                'uid': uid,
                'channel': channel,
                'event_type': event_type,
                'n_time': n_time,
            }
            # 对象存储区域, 测试/国内: 旧:aws(2),新:阿里云(1),华为云(5),设备传参, 美洲: oci凤凰城(3), 欧洲: oci伦敦(4)
            if CONFIG_INFO == CONFIG_US:
                storage_location = 3
            elif CONFIG_INFO == CONFIG_EUR:
                storage_location = 4
                try:
                    config_key = RedisKeyConstant.PUSH_STORAGE_CONFIG_UID.value + uid
                    config_value = redis_obj.get_data(key=config_key)
                    if config_value:  # 有配置则使用配置
                        storage_location = int(config_value)
                except Exception as e:
                    TIME_LOGGER.error('获取缓存推送存储位置异常uid:{},error:{}'.format(uid, repr(e)))
            elif CONFIG_INFO in [CONFIG_TEST, CONFIG_CN]:
                # 测试/国内服: 优先使用设备传参,否则默认阿里云
                if storage_location is not None:
                    storage_location = int(storage_location)
                else:
                    storage_location = 1  # 默认阿里云
            else:
                if storage_location is not None:
                    storage_location = int(storage_location)
                else:
                    storage_location = 1

            params = {'nickname': nickname, 'uid': uid, 'push_kwargs': push_kwargs, 'is_st': is_st, 'region': region,
                      'is_sys_msg': is_sys_msg, 'channel': channel, 'event_type': event_type, 'n_time': n_time,
                      'electricity': electricity, 'bucket': bucket, 'aws_s3_client': aws_s3_client,
                      'app_push': cache_app_push, 'storage_location': storage_location, 'ai_type': ai_type,
                      'device_type': device_type,
                      'dealings_type': dealings_type, 'detection': detection,
                      'app_push_config': uid_set_push_list[0]['uid_set__msg_notify'],
                      'uid_set_push_list': uid_set_push_list, 'redis_obj': redis_obj}

            # 异步推送消息和保存数据
            push_thread = threading.Thread(
                target=push_and_save_data,
                kwargs=params)
            push_thread.start()

            # 视频通话不返回图片链接
            if event_type in [607, 1022]:
                TIME_LOGGER.info('推送响应,uid:{},n_time:{},事件类型:{}'.format(uid, n_time, event_type))
                return JsonResponse(status=200, data={'code': 0, 'msg': 'success'})

            # 获取S3对象上传链接
            kwargs = {
                'is_st': is_st,
                'uid': uid,
                'channel': channel,
                'n_time': n_time,
                'region': region,
                'aws_s3_client': aws_s3_client,
                'storage_location': storage_location
            }
            res_data = DevicePushService.get_res_data(**kwargs)

            TIME_LOGGER.info('推送响应,uid:{},n_time:{},事件类型:{},响应:{}'.format(
                uid, n_time, event_type, json.dumps(res_data)))
            return JsonResponse(status=200, data=res_data)
        except Exception as e:
            ERROR_INFO_LOGGER.info('V2推送接口异常,uid:{},etk:{},error_line:{},error_msg:{}'.
                                   format(uid, etk, e.__traceback__.tb_lineno, repr(e)))
            data = {
                'error_line': e.__traceback__.tb_lineno,
                'error_msg': repr(e)
            }
            return JsonResponse(status=200, data=json.dumps(data), safe=False)


def push_and_save_data(**params):
    uid = params['uid']
    try:
        TIME_LOGGER.info('{}开始异步存表和推送'.format(uid))

        # 异步推送消息
        push_thread = threading.Thread(
            target=DevicePushService.push_msg,
            kwargs=params)
        push_thread.start()
        # 保存推送数据
        result = DevicePushService.save_msg_push(**params)
        TIME_LOGGER.info('{}存表结果:{}'.format(uid, result))
    except Exception as e:
        ERROR_INFO_LOGGER.info(
            'V2推送第一个线程异常{},error_line:{},error_msg:{}'.format(uid, e.__traceback__.tb_lineno, repr(e)))