ASJPush/Controller/DetectControllerV2.py

import json
import logging
import threading

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

from Object.RedisObject import RedisObject
from Service.DevicePushService import DevicePushService
TIME_LOGGER = logging.getLogger('time')


# 移动侦测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:无,1:图片,2:视频)
        @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：算法
        """
        logger = logging.getLogger('info')
        logger.info('消息推送V2接口参数:{}'.format(request_dict))
        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))

        # 参数校验
        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:
            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:{},n_time:{},事件类型:{}'.format(uid, n_time, event_type))
            # 判断是否为系统消息
            is_sys_msg = DevicePushService.judge_sys_msg(int(event_type))
            if is_sys_msg:
                push_interval = '{uid}_{channel}_{event_type}_flag'.format(uid=uid, channel=channel,
                                                                           event_type=event_type)
            else:
                push_interval = '{uid}_{channel}_flag'.format(uid=uid, channel=channel)

            req_limiting = '{uid}_{channel}_{event_type}_ptl'.format(uid=uid, channel=channel, event_type=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 [606, 607]:
                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)  # 当缓存不存在限流数据 重新设置一分钟请求一次

            # 查询uid_push和uid_set数据
            uid_push_qs = DevicePushService.query_uid_push(uid, event_type)
            if not uid_push_qs.exists():
                logger.info('消息推送-{}uid_push数据不存在'.format(uid))
                return JsonResponse(status=200, data={'code': 176, 'msg': 'no uid_push data'})

            ai_type = 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 [606, 607]:
                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 = ''
            if is_st == 1 or is_st == 3:  # 使用aws s3
                aws_s3_client = DevicePushService.get_s3_client(region=region)
                bucket = 'foreignpush' if region == 1 else 'push'

            kwag_args = {
                'uid': uid,
                'channel': channel,
                'event_type': event_type,
                'n_time': n_time,
            }
            params = {'nickname': nickname, 'uid': uid, 'kwag_args': kwag_args, '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': 2, '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']}

            # 推送消息,生成推送数据列表
            result = DevicePushService.save_msg_push(uid_set_push_list, **params)
            # 保存推送数据
            DevicePushService.save_sys_msg(
                is_sys_msg,
                result['local_date_time'],
                result['sys_msg_list'],
                result['new_device_info_list'])

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

            params['aws_s3_client'] = aws_s3_client
            params['uid_set_push_list'] = uid_set_push_list

            result_dict = DevicePushService.get_push_url(**params)  # 获取S3对象上传链接
            TIME_LOGGER.info('推送响应,uid:{},n_time:{},事件类型:{},响应:{}'.format(
                uid, n_time, event_type, json.dumps(result_dict)))
            return JsonResponse(status=200, data=result_dict)
        except Exception as e:
            logger.info('V2推送接口异常, errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
            data = {
                'errLine': e.__traceback__.tb_lineno,
                'errMsg': repr(e),
            }
            return JsonResponse(status=200, data=json.dumps(data), safe=False)


def push_and_save_data(uid_set_push_list, is_sys_msg, **params):
    # 推送消息,生成推送数据列表
    result = DevicePushService.save_msg_push(uid_set_push_list, **params)
    # 保存推送数据
    DevicePushService.save_sys_msg(
        is_sys_msg,
        result['local_date_time'],
        result['sys_msg_list'],
        result['new_device_info_list'])