ASJServer/Controller/AiController.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
@AUTHOR: ASJRD018
@NAME: AnsjerFormal
@software: PyCharm
@DATE: 2018/12/5 9:30
@Version: python3.6
@MODIFY DECORD:ansjer dev
@file: cloudstorage.py
@Contact: chanjunkai@163.com
"""
import base64
import json
import os
import time
import urllib
from urllib.parse import quote, parse_qs, unquote

import apns2
import boto3
import jpush
import oss2
import paypalrestsdk
import threading
import calendar
import datetime
import logging
import sys

import requests
from aliyunsdkcore import client
from aliyunsdksts.request.v20150401 import AssumeRoleRequest
from boto3.session import Session
from django.http import JsonResponse, HttpResponseRedirect, HttpResponse
from django.db import transaction
from django.views.generic.base import View
import jwt
from Object.ETkObject import ETkObject
from pyfcm import FCMNotification
from Ansjer.config import OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET, OSS_ROLE_ARN, SERVER_DOMAIN, PAYPAL_CRD, \
    SERVER_DOMAIN_SSL, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_ARN, APNS_MODE, APNS_CONFIG, BASE_DIR, \
    JPUSH_CONFIG, FCM_CONFIG, OAUTH_ACCESS_TOKEN_SECRET
from Controller.CheckUserData import DataValid
from Model.models import Device_Info, Order_Model, Store_Meal, VodHlsModel, OssCrdModel, UID_Bucket, StsCrdModel, \
    ExperienceContextModel, Pay_Type, CDKcontextModel, Device_User, SysMassModel, SysMsgModel, UidPushModel, \
    Unused_Uid_Meal, UIDMainUser, UserModel, PromotionRuleModel, VideoPlaybackTimeModel, CloudLogModel, CouponModel, \
    AiStoreMeal, AiService, UidSetModel, Ai_Push_Info, iotdeviceInfoModel
from Object.AWS.S3Email import S3Email
from Object.AliPayObject import AliPayObject
from Object.AliSmsObject import AliSmsObject
from Object.RedisObject import RedisObject
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject
from Object.UidTokenObject import UidTokenObject
from Service.CommonService import CommonService
from Object.m3u8generate import PlaylistGenerator
from Object.WechatPayObject import WechatPayObject
from django.db.models import Q, F, Count
from Controller.PaymentCycle import Paypal
from decimal import Decimal
from Ansjer.config import SERVER_TYPE
from Service.ModelService import ModelService
from Object import MergePic
import boto3
import botocore
from botocore import client



# AI服务
class AiView(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):
        response = ResponseObject()
        if operation is None:
            return response.json(444, 'error path')
        elif operation == 'identification':  # ai识别
            return self.do_ai_identification(request.POST, response)
        else:
            token = request_dict.get('token', None)
            # 设备主键uid
            tko = TokenObject(token)
            response.lang = tko.lang
            if tko.code != 0:
                return response.json(tko.code)
            userID = tko.userID
            if operation == 'createpayorder':  # 创建支付订单
                ip = CommonService.get_ip_address(request)
                return self.do_create_pay_order(request_dict, userID, ip, response)
            elif operation == 'changeaistatus':  # 修改AI开关状态
                return self.do_change_ai_status(userID, request_dict, response)
            elif operation == 'getAiStatus':  # 获取AI开关状态
                return self.getAiStatus(userID, request_dict, response)
            elif operation == 'commoditylist':  # 修改云存状态，传送两个url，即getsignsts接口和storeplaylist接口
                return self.do_commodity_list(userID, request_dict, response)
            elif operation == 'identification':  # ai识别
                return self.do_ai_identification(request_dict, response)
            elif operation == 'queryInfo':  # 查询消息列表
                return self.queryInfo(userID, request_dict, response)
            else:
                return response.json(414)

    def do_change_ai_status(self, userID, request_dict, response):
        token_val = request_dict.get('token_val', None)
        appBundleId = request_dict.get('appBundleId', None)
        app_type = request_dict.get('app_type', None)
        push_type = request_dict.get('push_type', None)
        status = request_dict.get('status', None)
        m_code = request_dict.get('m_code', None)
        uid = request_dict.get('uid', None)
        # 设备语言
        lang = request_dict.get('lang', 'en')
        tz = request_dict.get('tz', '0')
        # 消息提醒功能新增

        # 如果传空上来，就默认为0
        if tz == '':
            tz = 0
        else:
            tz = tz.replace("GMT", "")
        detect_group = request_dict.get('detect_group', None)
        interval = request_dict.get('interval', None)
        if not status:
            return response.json(444, 'status')
        # 关闭推送
        if not all([appBundleId, app_type, token_val, uid, m_code]):
            return response.json(444, 'appBundleId,app_type,token_val,uid,m_code')
        # 判断推送类型对应key是否存在
        print('push_type:', push_type)

        if push_type == '0':
            if appBundleId not in APNS_CONFIG.keys():
                return response.json(904)
        elif push_type == '1':
            if appBundleId not in FCM_CONFIG.keys():
                return response.json(904)
        elif push_type == '2':
            if appBundleId not in JPUSH_CONFIG.keys():
                return response.json(904)
        else:
            return response.json(173)
        hasAiService = AiService.objects.filter(uid=uid,use_status=1)
        if not hasAiService.exists():
            return response.json(10053)
        nowTime = int(time.time())
        endTime = hasAiService.values('endTime')[0]['endTime']
        if nowTime >endTime:
            return response.json(10054)
        dvqs = Device_Info.objects.filter(userID_id=userID, UID=uid)
        status = int(status)
        nowTime = int(time.time())
        if dvqs.exists():
            # 修改状态
            # dvqs.update(NotificationMode=status)
            uid_set_qs = UidSetModel.objects.filter(uid=uid)
            # uid配置信息是否存在

            if uid_set_qs.exists():
                uid_set_id = uid_set_qs[0].id
                qs_data = {
                    'updTime': nowTime,

                }
                if interval:
                    qs_data['detect_interval'] = int(interval)
                if detect_group:
                    qs_data['detect_group'] = detect_group
                uid_set_qs.update(**qs_data)
            else:
                qs_data = {
                    'uid': uid,
                    'addTime': nowTime,
                    'updTime': nowTime,
                }
                if interval:
                    qs_data['detect_interval'] = int(interval)
                if detect_group:
                    qs_data['detect_group'] = detect_group
                # 添加设备配置
                uid_set_qs = UidSetModel.objects.create(**qs_data)
                uid_set_id = uid_set_qs.id

            topic_name = 'AiServer/{}'.format(uid)
            if status == 0:
                hasAiService.update(**qs_data)
                # UidPushModel.objects.filter(uid_set__uid=uid).delete()
                # 状态为0的时候删除redis缓存数据
                # self.do_delete_redis(uid)

                # mqtt通知设备关闭AI识别功能
                msg = {'AiStatus': 'inactive'},
                req_success = self.requestPublishMqtt(uid, topic_name, msg)
                if not req_success:
                    return response.json(10044)
                return response.json(0)
            elif status == 1:
                hasAiService.update(**qs_data)
                uid_push_qs = UidPushModel.objects.filter(userID_id=userID, m_code=m_code, uid_set__uid=uid)

                if uid_push_qs.exists():
                    uid_push_update_dict = {
                        'appBundleId': appBundleId,
                        'app_type': app_type,
                        'push_type': push_type,
                        'token_val': token_val,
                        'updTime': nowTime,
                        'lang': lang,
                        'tz': tz
                    }
                    uid_push_qs.update(**uid_push_update_dict)
                else:
                    # uid_set_id = uid_set_qs[0].id
                    uid_push_create_dict = {
                        'uid_set_id': uid_set_id,
                        'userID_id': userID,
                        'appBundleId': appBundleId,
                        'app_type': app_type,
                        'push_type': push_type,
                        'token_val': token_val,
                        'm_code': m_code,
                        'addTime': nowTime,
                        'updTime': nowTime,
                        'lang': lang,
                        'tz': tz
                    }
                    # 绑定设备推送
                    UidPushModel.objects.create(**uid_push_create_dict)

                # if interval:
                #     self.do_delete_redis(uid, int(interval))
                # else:
                #     self.do_delete_redis(uid)
                # utko = UidTokenObject()
                # # right
                # utko.generate(data={'uid': uid})
                etkObj = ETkObject(etk='')
                etk = etkObj.encrypt(uid)

                #只返回一个接口就行
                # detectUrl = "{DETECT_PUSH_DOMAIN}AiService/push?etk={etk}&endTime={endTime}". \
                #     format(etk=etk, DETECT_PUSH_DOMAIN=SERVER_DOMAIN_SSL, endTime=endTime)
                aiIdentificationUrl = "{DETECT_PUSH_DOMAIN}AiService/identification".format(DETECT_PUSH_DOMAIN=SERVER_DOMAIN_SSL)

                # mqtt通知设备开启AI识别功能
                msg = {
                          'AiStatus': 'active',
                          'etk': etk,
                          'endTime': endTime,
                          'aiIdentificationUrl': aiIdentificationUrl,
                      },
                req_success = self.requestPublishMqtt(uid, topic_name, msg)
                if not req_success:
                    return response.json(10044)
                return response.json(0, {'aiIdentificationUrl': aiIdentificationUrl, 'endTime': endTime, 'etk': etk})
        else:
            return response.json(14)

    def getAiStatus(self, userID, request_dict, response):
        uid = request_dict.get('uid', None)

        if not uid:
            return response.json(444)
        try:
            ai_server_qs = AiService.objects.filter(uid=uid).values('detect_status', 'detect_group')
            if not ai_server_qs.exists():
                return response,json(173)
            res = {
                'detect_status': ai_server_qs[0]['detect_status'],
                'detect_group': ai_server_qs[0]['detect_group'],
            }
            return response.json(0, {'data': res})
        except Exception as e:
            return response.json(500, repr(e))

    def requestPublishMqtt(self, thing_name, topic_name, msg):
        # 通用发布MQTT主题通知
        if not all([msg, thing_name, topic_name]):
            return False

        try:
            # 获取数据组织将要请求的url
            iot = iotdeviceInfoModel.objects.filter(
                thing_name__icontains=thing_name).values(
                'endpoint', 'token_iot_number')
            if not iot.exists():
                return False
            endpoint = iot[0]['endpoint']
            Token = iot[0]['token_iot_number']

            # api doc: https://docs.aws.amazon.com/zh_cn/iot/latest/developerguide/http.html
            # url: https://IoT_data_endpoint/topics/url_encoded_topic_name?qos=1
            # post请求url发布MQTT消息
            url = 'https://{}/topics/{}'.format(endpoint, topic_name)
            authorizer_name = 'Ansjer_Iot_Auth'
            signature = CommonService.rsa_sign(Token)  # Token签名
            headers = {
                'x-amz-customauthorizer-name': authorizer_name,
                'Token': Token,
                'x-amz-customauthorizer-signature': signature}
            r = requests.post(url=url, headers=headers, json=msg, timeout=2)
            if r.status_code == 200:
                res = r.json()
                if res['message'] == 'OK':
                    return True
                return False
            else:
                return False
        except Exception as e:
            return False

    def do_commodity_list(self, userID, request_dict, response):  # 查询套餐列表
        uid = request_dict.get('uid', None)
        lang = request_dict.get('lang', 'en')
        nowTime = int(time.time())
        # DVR/NVR设备暂不返回云存套餐列表
        device_info_qs = Device_Info.objects.filter(Q(UID=uid), Q(Type__lte=4) | Q(Type=10001))
        if device_info_qs.exists():
            return response.json(0)

        qs = AiStoreMeal.objects

        qs = qs.filter(is_show=1)  #过滤隐藏套餐
        qs = qs.annotate(ai_meal_id=F('id'))
        qs = qs.values("ai_meal_id", "title", "content", "price", "effective_day", "currency",
                       "virtual_price", "symbol", "pay_type")

        if qs.exists():
            res = list(qs)
            for key, val in enumerate(res):
                pay_types = Pay_Type.objects.filter(aistoremeal=res[key]['ai_meal_id']).values("id", "payment")
                res[key]['pay_type'] = list(pay_types)
            result = {
                'meals': res,
            }
            return response.json(0, result)
        else:
            return response.json(0)


    def do_create_pay_order(self, request_dict, userID, ip, response):
        uid = request_dict.get('uid', None)
        channel = request_dict.get('channel', None)
        pay_type = int(request_dict.get('pay_type', 1))
        ai_meal_id = request_dict.get('ai_meal_id', None)
        lang = request_dict.get('lang', 'en')
        if not uid or not channel or not pay_type or not ai_meal_id:
            return response.json(444)
        # dv_qs = Device_Info.objects.filter(userID_id=userID, UID=uid, isShare=False, isExist=1).values(
        #     'vodPrimaryUserID',
        #     'vodPrimaryMaster')
        # if not dv_qs.exists():
        #     return response.json(12)

        # dvq = Device_Info.objects.filter(UID=uid)
        # dvq = dvq.filter(~Q(vodPrimaryUserID='')).values('vodPrimaryUserID')
        # if dvq.exists():
        #     if dvq[0]['vodPrimaryUserID'] != userID:
        #         return response.json(10033)

        nowTime = int(time.time())
        smqs = AiStoreMeal.objects.filter(id=ai_meal_id, pay_type=pay_type, is_show=1). \
            values('currency', 'price', 'content', 'effective_day', 'title')
        if not smqs.exists():
            return response.json(173)
        currency = smqs[0]['currency']
        price = smqs[0]['price']
        content = smqs[0]['content']
        day = smqs[0]['effective_day']

        orderID = CommonService.createOrderID()
        price = float(price)
        price = round(price, 2)
        if pay_type == 1:
            #正常扣款
            cal_url = "{SERVER_DOMAIN_SSL}web/paid2/fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
            if lang != 'cn':
                cal_url = "{SERVER_DOMAIN_SSL}web/paid2/en_fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
            call_sub_url = "{SERVER_DOMAIN_SSL}cloudstorage/dopaypalcallback?orderID={orderID}&lang={lang}". \
                format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL, orderID=orderID, lang=lang)
            # call_sub_url = "http://binbin.uicp.vip/cloudstorage/dopaypalcallback?orderID={orderID}".format(
            # SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL, orderID=orderID)
            Order_Model.objects.create(orderID=orderID, UID=uid, channel=channel, userID_id=userID,
                                       desc=content, payType=pay_type, payTime=nowTime,
                                       price=price, currency=currency, addTime=nowTime, updTime=nowTime,
                                       pay_url='', commodity_code='', commodity_type=1,
                                       ai_rank_id=ai_meal_id, rank_id=1, order_type=1)
            has = AiService.objects.filter(uid=uid, channel=channel, use_status=1)
            if has.exists():
                use_status = 0
            else:
                use_status = 1
            # return response.json(0)
            AiService.objects.create(orders_id=orderID, uid=uid, channel=channel, detect_status=1,
                                       endTime=nowTime+(day*86400), addTime=nowTime, updTime=nowTime,
                                     use_status=use_status, detect_group='1')
            return response.json(0, {"orderID": orderID})
        return response.json(10, 'generate_order_false')


    def do_ai_identification(self, request_dict,response):
        etk = request_dict.get('etk', None)
        now_time = int(time.time())
        logger = logging.getLogger('info')
        logger.info('-----------into----ai--api')
        logger.info("etk={etk}".format(etk=etk))
        if not etk:
            return response.json(444)

        try:
            # 解密uid及判断长度
            eto = ETkObject(etk)
            uid = eto.uid
            logger.info("uid={uid}".format(uid=uid))
            if len(uid) != 20 and len(uid) != 14:
                return response.json(444)

            ##通过uid查出endTime是否过期，并且ai开关是否打开
            AiServiceQuery = AiService.objects.filter(uid=uid, detect_status=1, use_status=1, endTime__gt=now_time).\
                values('detect_group')
            if not AiServiceQuery.exists():
                logger.info('none-----aiService')
                return response.json(173)
            detect_group = AiServiceQuery[0]['detect_group']
            #{}??
            #
            file_post_one = request_dict.get('fileOne', None)
            file_post_two = request_dict.get('fileTwo', None)
            file_post_three = request_dict.get('fileThree', None)

            file_post_one = file_post_one.replace(' ', '+')
            file_post_two = file_post_two.replace(' ', '+')
            file_post_three = file_post_three.replace(' ', '+')

            file_post_one = base64.b64decode(file_post_one)
            file_post_two = base64.b64decode(file_post_two)
            file_post_three = base64.b64decode(file_post_three)

            file_list = [file_post_one, file_post_two, file_post_three]
            del file_post_one, file_post_two, file_post_three

            dir_path = os.path.join(BASE_DIR, 'static/ai/' + uid + '/' + str(now_time))
            if not os.path.exists(dir_path):
                os.makedirs(dir_path)
            file_path_list = []
            i = 1
            for index in file_list:
                file_path = dir_path + '/' + str(i) + '.jpg'
                file_path_list.append(file_path)
                with open(file_path, 'wb') as f:
                    f.write(index)
                    f.close()
                i += 1

            image_size = 500  # 每张小图片的大小
            image_colnum = 1  # 合并成一张图后，一行有几个小图
            MergePic.merge_images(dir_path, image_size, image_colnum)
            photo = open(dir_path + '.jpg', 'rb')  #打开合成图

            cover = dir_path + '/' + str(i-1) + '.jpg'
            desc = dir_path + '.jpg'
            logger.info('----------------cover')
            logger.info(cover)
            logger.info(desc)
            # photo = open(r'E:\test---------------\test\snipaste20220121_215952.jpg', 'rb')
            #识别合成图片
            maxLabels = 50
            minConfidence = 96

            client = boto3.client(
                'rekognition',
                aws_access_key_id='AKIA2E67UIMD6JD6TN3J',
                aws_secret_access_key='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',
                region_name='us-east-1')
            # doc:
            rekognition_res = client.detect_labels(
                Image={'Bytes': photo.read()},
                MaxLabels=maxLabels,
                MinConfidence=minConfidence)
            if rekognition_res['ResponseMetadata']['HTTPStatusCode'] != 200:
                return response.json(173)
            labels =rekognition_res['Labels']
            label_name = []
            logger.info('--------识别到的标签-------')
            logger.info(labels)
            for label in labels:
                label_name.append(label['Name'])
                for Parents in label['Parents']:
                    label_name.append(Parents['Name'])
            labels = self.checkLabels(detect_group, label_name)    #检查标签是否符合用户选择的识别类型
            if len(labels['label_list']) == 0:
                logger.info('没有识别到任何标签-----------------')
                return response.json(10055)
            event_type = ','.join(labels['label_type'])
            label_list = ','.join(labels['label_list'])
            logger.info(event_type)
            logger.info(label_list)
            #存储消息以及推送
            channel = request_dict.get('channel', '1')
            n_time = now_time
            is_st = 1  #单图

            # 查询推送数据
            uid_push_qs = UidPushModel.objects.filter(uid_set__uid=uid). \
                values('token_val', 'app_type', 'appBundleId', 'm_code', 'push_type', 'userID_id',
                       'userID__NickName',
                       'lang', 'm_code', 'tz', 'uid_set__nickname', 'uid_set__detect_interval',
                       'uid_set__detect_group',
                       'uid_set__channel')
            if not uid_push_qs.exists():
                return response.json(173)
            uid_push_list = []
            for qs in uid_push_qs:
                uid_push_list.append(qs)

            nickname = uid_push_list[0]['uid_set__nickname']
            if not nickname:
                nickname = uid

            eq_list = []
            userID_ids = []
            for up in uid_push_list:
                push_type = up['push_type']
                appBundleId = up['appBundleId']
                token_val = up['token_val']
                lang = up['lang']
                tz = up['tz']
                if tz is None or tz == '':
                    tz = 0

                # 推送标题
                msg_title = self.get_msg_title(appBundleId=appBundleId, nickname=nickname)
                # 推送内容
                msg_text = self.get_msg_text(channel=channel, n_time=n_time, lang=lang, tz=tz, label_list=label_list)
                kwargs = {
                    'uid': uid,
                    'channel': channel,
                    'event_type': event_type,
                    'n_time': n_time,
                    'appBundleId': appBundleId,
                    'token_val': token_val,
                    'msg_title': msg_title,
                    'msg_text': msg_text,
                }
                # 推送消息
                if push_type == 0:  # ios apns
                    logger.info('into-------apns')
                    res = self.do_apns(**kwargs)
                    logger.info(res)
                # elif push_type == 1:  # android gcm
                #     self.do_fcm(**kwargs)
                elif push_type == 2:  # android jpush
                    logger.info('into-------jpush')
                    res = self.do_jpush(**kwargs)
                    logger.info(res)

                # 以下是存库
                userID_id = up["userID_id"]
                if userID_id not in userID_ids:
                    now_time = int(time.time())
                    eq_list.append(Ai_Push_Info(
                        userID_id=userID_id,
                        eventTime=n_time,
                        eventType=event_type,
                        devUid=uid,
                        devNickName=nickname,
                        Channel=channel,
                        alarm='检查到{labels} \tChannel:{channel}'.format(labels=','.join(labels['label_list']), channel=channel),
                        is_st=is_st,
                        receiveTime=n_time,
                        addTime=now_time,
                        storage_location=2
                    ))
                    userID_ids.append(userID_id)
            Ai_Push_Info.objects.bulk_create(eq_list)

            #上传缩略图到s3
            upload_cover_path = "{uid}/{channel}/cover{n_time}.jpg".format(uid=uid, channel=channel, n_time=n_time)  #封面图
            upload_desc_path = "{uid}/{channel}/desc{n_time}.jpg".format(uid=uid, channel=channel, n_time=n_time)   #详情内容图
            c_res = self.upload_s3(cover, upload_cover_path)
            d_res = self.upload_s3(desc, upload_desc_path)
            if c_res and d_res:
                logger.info('upload-----S3----success')
                return JsonResponse(status=200, data='success', safe=False)
            return JsonResponse(status=500, data='fail', safe=False)

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


    ## 检查是否有符合条件的标签
    def checkLabels(self, user_detect_group, labels):
        labels_type = {
            '1': ['Person', 'Human'],    #人
            '2': ['Dog', 'Pet', 'Canine', 'Animal'],   #动物
            '3': ['Car', '', 'Vehicle', 'Transportation', 'Automobile']   #车
        }
        user_detect_list = user_detect_group.split(',')
        user_labels_type = {}
        for user_detect in user_detect_list:
            if user_detect in labels_type.keys():
                user_labels_type[user_detect] = labels_type[user_detect]
        label_list = []
        for k, labels_type in user_labels_type.items():
            for label in labels_type:
                if label in labels:
                    label_list.append(label)
        user_labels_list = list(user_labels_type.keys())
        user_labels_list.sort()
        return {'label_type': user_labels_list, 'label_list': label_list}


    def upload_s3(self, file_path, upload_path):
        try:
            aws_key = "AKIA2MMWBR4DSFG67DTG" #【你的 aws_access_key】
            aws_secret = "aI9gxcAKPmiGgPy9axrtFKzjYGbvpuytEX4xWweL" # 【你的 aws_secret_key】
            session = Session(aws_access_key_id=aws_key,
                              aws_secret_access_key=aws_secret,
                              region_name="cn-northwest-1")
            s3 = session.resource("s3")
            # client = session.client("s3")
            bucket = "aipush" # 【你 bucket 的名字】 # 首先需要保.证 s3 上已经存在该存储桶，否则报错
            upload_data = open(file_path, "rb")
            # upload_key = "test"
            s3.Bucket(bucket).put_object(Key=upload_path, Body=upload_data)
            return True
        except Exception as e:
            print(repr(e))
            return False

    def get_msg_title(self, appBundleId, nickname):
        package_title_config = {
            'com.ansjer.customizedd_a': 'DVS',
            'com.ansjer.zccloud_a': 'ZosiSmart',
            'com.ansjer.zccloud_ab': '周视',
            'com.ansjer.adcloud_a': 'ADCloud',
            'com.ansjer.adcloud_ab': 'ADCloud',
            'com.ansjer.accloud_a': 'ACCloud',
            'com.ansjer.loocamccloud_a': 'Loocam',
            'com.ansjer.loocamdcloud_a': 'Anlapus',
            'com.ansjer.customizedb_a': 'COCOONHD',
            'com.ansjer.customizeda_a': 'Guardian365',
            'com.ansjer.customizedc_a': 'PatrolSecure',
        }
        if appBundleId in package_title_config.keys():
            return package_title_config[appBundleId] + '(' + nickname + ')'
        else:
            return nickname

    def get_msg_text(self, channel, n_time, lang, tz, label_list):
        n_date = CommonService.get_now_time_str(n_time=n_time, tz=tz,lang=lang)
        if lang == 'cn':
            msg = '摄像头AI识别到了{}'.format(label_list)
            send_text = '{msg} 通道:{channel} 日期:{date}'.format(msg=msg, channel=channel, date=n_date)
        else:
            msg = 'Camera AI recognizes{}'.format(label_list)
            send_text = '{msg} channel:{channel} date:{date}'.format(msg=msg, channel=channel, date=n_date)
        return send_text

    def do_jpush(self, uid, channel, appBundleId, token_val, event_type, n_time, msg_title, msg_text):
        app_key = JPUSH_CONFIG[appBundleId]['Key']
        master_secret = JPUSH_CONFIG[appBundleId]['Secret']
        # 此处换成各自的app_key和master_secre
        _jpush = jpush.JPush(app_key, master_secret)
        push = _jpush.create_push()
        push.audience = jpush.registration_id(token_val)
        push_data = {"alert": "Motion ", "event_time": n_time, "event_type": event_type, "msg": "",
                     "received_at": n_time, "sound": "sound.aif", "uid": uid, "zpush": "1", "channel": channel}
        android = jpush.android(alert=msg_text, priority=1, style=1, alert_type=7,
                                big_text=msg_text, title=msg_title,
                                extras=push_data)
        push.notification = jpush.notification(android=android)
        push.platform = jpush.all_
        res = push.send()
        print(res)
        return res.status_code

    def do_fcm(self, uid, channel, appBundleId, token_val, event_type, n_time, msg_title, msg_text):
        try:
            serverKey = FCM_CONFIG[appBundleId]
        except Exception as e:
            return 'serverKey abnormal'
        push_service = FCMNotification(api_key=serverKey)
        data = {"alert": "Motion ", "event_time": n_time, "event_type": event_type, "msg": "",
                "received_at": n_time, "sound": "sound.aif", "uid": uid, "zpush": "1", "channel": channel}
        result = push_service.notify_single_device(registration_id=token_val, message_title=msg_title,
                                                   message_body=msg_text, data_message=data,
                                                   extra_kwargs={
                                                       'default_vibrate_timings': True,
                                                       'default_sound': True,
                                                       'default_light_settings': True
                                                   })
        print('fcm push ing')
        print(result)
        return result

    def do_apns(self, uid, channel, appBundleId, token_val, event_type, n_time, msg_title, msg_text):
        logger = logging.getLogger('info')
        logger.info("进来do_apns函数了")
        logger.info(token_val)
        logger.info(APNS_MODE)
        logger.info(os.path.join(BASE_DIR, APNS_CONFIG[appBundleId]['pem_path']))
        try:
            cli = apns2.APNSClient(mode=APNS_MODE, client_cert=os.path.join(BASE_DIR, APNS_CONFIG[appBundleId]['pem_path']))
            push_data = {"alert": "Motion ", "event_time": n_time, "event_type": event_type, "msg": "",
                         "received_at": n_time, "sound": "", "uid": uid, "zpush": "1", "channel": channel}
            alert = apns2.PayloadAlert(body=msg_text, title=msg_title)
            payload = apns2.Payload(alert=alert, custom=push_data, sound="default")
            n = apns2.Notification(payload=payload, priority=apns2.PRIORITY_LOW)
            res = cli.push(n=n, device_token=token_val, topic=appBundleId)

            if res.status_code == 200:
                return res.status_code
            else:
                logger.info('apns push fail')
                logger.info(res.reason)
                return res.status_code
        except (ValueError, ArithmeticError):
            return 'The program has a numeric format exception, one of the arithmetic exceptions'
        except Exception as e:
            print(repr(e))
            logger.info(repr(e))
            return repr(e)

    def queryInfo(self, userID, request_dict, response):
        page = int(request_dict.get('page', None))
        line = int(request_dict.get('line', None))
        if not page or not line:
            return response.json(444, 'page,line')
        startTime = request_dict.get('startTime', None)
        endTime = request_dict.get('endTime', None)
        eventType = request_dict.get('eventType', None)

        now_time = int(time.time())
        seven_days_ago = now_time - 7 * 24 * 3600   # 查询7天内的数据
        qs = Ai_Push_Info.objects.filter(userID_id=userID, eventTime__gt=seven_days_ago).order_by('-eventTime')

        if startTime and endTime:
            qs = qs.filter(eventTime__range=(startTime, endTime))
        # if eventType:
        #     qs = qs.filter(eventType__contains=eventType)
        uids = request_dict.get('uids', None)
        if uids:
            uid_list = uids.split(',')
            qs = qs.filter(devUid__in=uid_list)
            dvqs = Device_Info.objects.filter(UID__in=uid_list, userID_id=userID).values('UID', 'Type', 'NickName')
            uid_type_dict = {}
            for dv in dvqs:
                uid_type_dict[dv['UID']] = {'type': dv['Type'], 'NickName': dv['NickName']}
        else:
            dvqs = Device_Info.objects.filter(userID_id=userID).values('UID', 'Type', 'NickName')
            uid_type_dict = {}
            for dv in dvqs:
                uid_type_dict[dv['UID']] = {'type': dv['Type'], 'NickName': dv['NickName']}

        if not qs.exists():
            return response.json(0, {'datas': [], 'count': 0})

        count = qs.count()
        qs = qs.values('id', 'devUid', 'devNickName', 'Channel', 'eventType', 'status', 'alarm', 'eventTime',
                       'receiveTime', 'is_st', 'addTime', 'storage_location')

        qs = qs[(page - 1) * line:page * line]
        res = []

        aws_s3_client = boto3.client(
            's3',
            aws_access_key_id=AWS_ACCESS_KEY_ID[0],
            aws_secret_access_key=AWS_SECRET_ACCESS_KEY[0],
            config=botocore.client.Config(signature_version='s3v4'),
            region_name='cn-northwest-1'
        )

        for p in qs:
            p['eventType'] = int(p['eventType'][0])
            devUid = p['devUid']
            eventTime = p['eventTime']
            channel = p['Channel']
            storage_location = p['storage_location']
            if p['is_st'] == 1:
                s3_img_cover = '{uid}/{channel}/cover{time}.jpg'.format(uid=devUid, channel=channel, time=eventTime)
                s3_img_desc = '{uid}/{channel}/desc{time}.jpg'.format(uid=devUid, channel=channel, time=eventTime)
                response_url_cover = aws_s3_client.generate_presigned_url('get_object',
                                                                    ExpiresIn=300,
                                                                    Params={
                                                                        'Bucket': 'aipush', 'Key': s3_img_cover
                                                                    },
                                                                    )
                response_url_desc = aws_s3_client.generate_presigned_url('get_object',
                                                                          ExpiresIn=300,
                                                                          Params={
                                                                              'Bucket': 'aipush', 'Key': s3_img_desc
                                                                          },
                                                                          )
                p['img'] = response_url_cover
                p['img_list'] = [response_url_desc]

            elif p['is_st'] == 2:
                pass

            if devUid in uid_type_dict.keys():
                p['uid_type'] = uid_type_dict[devUid]['type']
                p['devNickName'] = uid_type_dict[devUid]['NickName']
            else:
                p['uid_type'] = ''
            res.append(p)
        return response.json(0, {'datas': res, 'count': count})