ASJServer/Controller/AiController.py

import time
import boto3
import logging
import botocore
import paypalrestsdk

from botocore import client
from boto3.session import Session
from django.db import transaction
from django.db.models import Q, F, Sum
from django.views.generic.base import View
from django.http import HttpResponseRedirect, HttpResponse

from Ansjer.config import PAYPAL_CRD, SERVER_DOMAIN_SSL, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, DETECT_PUSH_DOMAINS
from Model.models import Device_Info, Order_Model, ExperienceAiModel, Pay_Type, CDKcontextModel, UidPushModel, \
    AiStoreMeal, AiService, UidSetModel, Ai_Push_Info
from Object.AliPayObject import AliPayObject
from Object.ETkObject import ETkObject
from Object.RedisObject import RedisObject
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject
from Object.WechatPayObject import WechatPayObject
from Service.CommonService import CommonService
from Service.ModelService import ModelService
from urllib.parse import quote, parse_qs, unquote


class AiView(View):
    """
    AI业务功能
    AI套餐,开关,消息列表
    """

    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 == 'doPayPalCallBack':  # paypal支付回调
            return self.do_pay_by_paypal_callback(request_dict, response)
        elif operation == 'doAlipayCallBack':  # 支付宝支付回调
            return self.do_alipay_callback(request_dict, response)
        elif operation == 'doWechatCallBack':  # 微信支付回调
            return self.do_wechat_callback(request, response)
        else:
            token = request_dict.get('token', None)
            tko = TokenObject(token)
            response.lang = tko.lang
            if tko.code != 0:
                return response.json(tko.code)
            userID = tko.userID
            if operation == 'createpayorder':  # 创建支付订单
                return self.do_create_pay_order(request_dict, request, userID, response)
            elif operation == 'getAiStatus':  # 获取AI开关状态
                return self.get_ai_status(request_dict, response)
            elif operation == 'changeaistatus':  # 修改AI开关状态
                return self.do_change_ai_status(userID, request_dict, response)
            elif operation == 'commoditylist':  # 获取AI套餐列表
                return self.do_commodity_list(request_dict, response)
            elif operation == 'queryInfo':  # 查询消息列表
                return self.queryInfo(userID, request_dict, response)
            elif operation == 'readInfo':  # 消息已读
                return self.readInfo(userID, request_dict, response)
            elif operation == 'deleteInfo':  # 删除消息
                return self.deleteInfo(userID, request_dict, response)
            elif operation == 'queryorderlist':  # 查询订单
                return self.do_querylist(userID, request_dict, response)
            elif operation == 'getUsingPackage':  # 获取当前使用的ai套餐
                return self.getUsingPackage(request_dict, userID, response)
            elif operation == 'experienceOrder':  # 体验AI套餐
                return self.experience_order(request_dict, userID, response)
            else:
                return response.json(414)

    @staticmethod
    def get_ai_status(request_dict, response):
        """
        获取AI开关状态
        @param request_dict: 请求数据
        @request_dict uid: uid
        @param response: 响应
        @return: response
        """
        uid = request_dict.get('uid', None)
        if not uid:
            return response.json(444)
        try:
            ai_server_qs = AiService.objects.filter(uid=uid, use_status=1).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))

    @staticmethod
    def do_change_ai_status(userID, request_dict, response):
        """
        修改AI开关状态
        @param userID: 用户id
        @param request_dict: 请求数据
        @request_dict token_val: 设备验证令牌
        @request_dict appBundleId: app包id
        @request_dict app_type: app类型
        @request_dict push_type: 推送类型
        @request_dict status: 开关状态, 0: 关, 1: 开
        @request_dict m_code: 手机唯一标识
        @request_dict uid: uid
        @request_dict lang: 语言
        @request_dict tz: 时区
        @request_dict detect_group: 检测类型
        @request_dict interval: 推送间隔
        @param response: 响应
        @return: 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')
        detect_group = request_dict.get('detect_group', None)
        interval = request_dict.get('interval', None)

        if not all([appBundleId, app_type, token_val, uid, m_code, status]):
            return response.json(444, 'appBundleId, app_type, token_val, uid,m_code, status')

        # 如果传空上来，就默认为0
        tz = '0' if tz == '' else tz.replace('GMT', '')

        try:
            ai_service_qs = AiService.objects.filter(uid=uid, use_status=1)
            if not ai_service_qs.exists():
                return response.json(10053)
            nowTime = int(time.time())
            endTime = ai_service_qs.values('endTime')[0]['endTime']
            if nowTime > endTime:
                return response.json(10054)

            # 查询设备是否属于该用户
            device_info_qs = Device_Info.objects.filter(userID_id=userID, UID=uid)
            if not device_info_qs.exists():
                return response.json(14)
            status = int(status)
            nowTime = int(time.time())

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

            qs_data['detect_status'] = status  # ai开关状态
            ai_service_qs.update(**qs_data)
            thing_name = CommonService.query_serial_with_uid(uid)  # 存在序列号则为使用序列号作为物品名
            topic_name = 'ansjer/generic/{}'.format(thing_name)

            if status == 0:  # 关闭
                # mqtt通知设备关闭AI识别功能
                msg = {'commandType': 'AIDisable'}
                req_success = CommonService.req_publish_mqtt_msg(thing_name, topic_name, msg)
                if not req_success:
                    return response.json(10044)
                return response.json(0)
            elif status == 1:  # 开启
                # 更新或创建uid_push数据
                uid_push_qs = UidPushModel.objects.filter(userID_id=userID, m_code=m_code, uid_set__uid=uid)
                uid_push_data = {
                    'appBundleId': appBundleId,
                    'app_type': app_type,
                    'push_type': push_type,
                    'token_val': token_val,
                    'updTime': nowTime,
                    'lang': lang,
                    'tz': tz
                }

                if uid_push_qs.exists():
                    uid_push_qs.update(**uid_push_data)
                else:
                    uid_push_data['uid_set_id'] = uid_set_id
                    uid_push_data['userID_id'] = userID
                    uid_push_data['m_code'] = m_code
                    uid_push_data['addTime'] = nowTime
                    UidPushModel.objects.create(**uid_push_data)

                etkObj = ETkObject(etk='')
                etk = etkObj.encrypt(uid)

                # mqtt通知设备开启AI识别功能
                aiIdentificationUrl = '{}AiService/identification'.format(DETECT_PUSH_DOMAINS)
                msg = {
                    'commandType': 'AIEnable',
                    'payload': {
                        'etk': etk,
                        'endTime': endTime,
                        'aiIdentificationUrl': aiIdentificationUrl,
                    }
                }
                req_success = CommonService.req_publish_mqtt_msg(thing_name, topic_name, msg)
                if not req_success:
                    return response.json(10044)
                return response.json(0, {'aiIdentificationUrl': aiIdentificationUrl, 'endTime': endTime, 'etk': etk})
        except Exception as e:
            return response.json(500, repr(e))

    # 获取AI套餐列表
    @staticmethod
    def do_commodity_list(request_dict, response):
        uid = request_dict.get('uid', None)
        lang = request_dict.get('lang', 'en')

        try:
            # 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)

            # 没免费体验过的设备只返回体验套餐数据,体验过的不再返回
            exc_ai_qs = ExperienceAiModel.objects.filter(uid=uid, experience_type=0)
            if exc_ai_qs.exists():
                ai_meal_qs = AiStoreMeal.objects.filter(~Q(pay_type=10))
            else:
                ai_meal_qs = AiStoreMeal.objects.filter(pay_type=10)

            # 查询套餐数据
            ai_meal_qs = ai_meal_qs.filter(is_show=1, lang__lang=lang). \
                annotate(ai_meal_id=F('id'), title=F('lang__title'), content=F('lang__content')). \
                values("ai_meal_id", "title", "content", "price", "effective_day", "currency", "virtual_price",
                       "symbol", "is_beta")
            if not ai_meal_qs.exists():
                return response.json(0)

            # 查询每种套餐的所有支付方式
            ai_meal_list = list(ai_meal_qs)
            for ai_meal in ai_meal_list:
                pay_type_qs = Pay_Type.objects.filter(aistoremeal=ai_meal['ai_meal_id']).values('id', 'payment')
                ai_meal['pay_type'] = list(pay_type_qs)
            result = {
                'meals': ai_meal_list,
            }
            return response.json(0, result)
        except Exception as e:
            print(e)
            return response.json(500, repr(e))

    def do_querylist(self, userID, request_dict, response):
        page = request_dict.get('page', None)
        line = request_dict.get('line', None)
        uid = request_dict.get('uid', None)
        lang = request_dict.get('lang', 'en')
        if not page or not line:
            return response.json(444, 'page,line')

        try:
            page = int(page)
            line = int(line)
            omqs = Order_Model.objects.filter(userID_id=userID, status=1, order_type=1, ai_rank__lang__lang=lang)
            # 筛选指定设备id的订单
            if uid:
                omqs.filter(UID=uid)
            if not omqs.exists():
                return response.json(173)
            count = omqs.count()
            omqs = omqs.annotate(rank__title=F('ai_rank__lang__title'), rank__content=F('ai_rank__lang__content'),
                                 rank__day=F('ai_rank__effective_day'), rank__price=F('ai_rank__price'),
                                 rank__expire=F('ai_rank__effective_day'), rank__id=F('ai_rank_id'),
                                 rank__currency=F('ai_rank__currency'))
            order_ql = omqs[(page - 1) * line:page * line].values("orderID", "UID", "channel", "desc", "price",
                                                                  "currency",
                                                                  "addTime",
                                                                  "updTime", "paypal", "rank__day", "payType",
                                                                  "rank__price", "status",
                                                                  "rank__content", "rank__title", "rank__currency",
                                                                  "rank__expire", "ai_rank_id")
            order_list = list(order_ql)
            data = []
            nowTime = int(time.time())
            # 这里需要进行优化
            uid_list = []
            for od in order_list:
                uid_list.append(od['UID'])
            didqs = Device_Info.objects.filter(userID_id=userID, UID__in=uid_list).values('id', 'UID', 'Type')
            for d in order_list:
                if d['status'] == 0:
                    if d['addTime'] + 3600 < nowTime:
                        d['status'] = 3
                for did in didqs:
                    if d['UID'] == did['UID']:
                        d['did'] = did['id']
                        d['Type'] = did['Type']
                        data.append(d)
                # d['rank__lang__content'] = '月' if lang == 'cn' else 'month'
            return response.json(0, {'data': data, 'count': count})
        except Exception as e:
            print(e)
        return response.json(500, repr(e))

    # 获取当前使用的ai套餐
    def getUsingPackage(self, request_dict, userID, response):
        uid = request_dict.get('uid', None)
        lang = request_dict.get('lang', 'en')
        # dv_qs = Device_Info.objects.filter(userID_id=userID, UID=uid, isShare=False, isExist=1, vodPrimaryUserID=userID)
        # if not dv_qs.exists():
        #     return response.json(12)
        try:
            ai_service_qs = AiService.objects.filter(uid=uid, use_status=1, orders__ai_rank__lang__lang=lang)
            if not ai_service_qs.exists():
                return response.json(0, [])

            # 计算套餐过期时间
            sum_end_time = AiService.objects.filter(Q(uid=uid), ~Q(use_status=2)).aggregate(Sum('endTime'))[
                'endTime__sum']
            ai_service_qs = ai_service_qs.order_by('addTime').annotate(
                bucket__content=F('orders__ai_rank__lang__title')). \
                values('uid', 'use_status', 'bucket__content')

            ai_service_data = ai_service_qs[0]
            # 如果存在序列号返回完整序列号
            device_info_qs = Device_Info.objects.filter(UID=uid).values('serial_number', 'Type')
            serial_number = device_info_qs[0]['serial_number']
            device_type = device_info_qs[0]['Type']
            if serial_number:
                ai_service_data['serial_number'] = CommonService.get_full_serial_number(uid, serial_number, device_type)

            ai_service_data['endTime'] = sum_end_time
            return response.json(0, [ai_service_data])
        except Exception as e:
            print(e)
            return response.json(500, repr(e))

    # 体验AI套餐
    @staticmethod
    def experience_order(request_dict, userID, response):
        logger = logging.getLogger('info')
        uid = request_dict.get('uid', None)
        channel = request_dict.get('channel', None)
        pay_type = int(request_dict.get('pay_type', None))
        rank = request_dict.get('rank', None)
        cdk = request_dict.get('cdk', None)
        lang = request_dict.get('lang', 'en')

        # 使用redis设置唯一key加锁
        redisObj = RedisObject()
        redis_key = uid + 'do_experience_ai_order'
        isLock = redisObj.CONN.setnx(redis_key, 1)
        redisObj.CONN.expire(redis_key, 60)
        if not isLock:
            return response.json(5)
        try:
            if pay_type == 10:  # 判断是否已体验过套餐
                exc_ai_qs = ExperienceAiModel.objects.filter(uid=uid, experience_type=0)
                if exc_ai_qs.exists():
                    return response.json(5)

            if cdk is not None and pay_type == 11:
                cdk_qs = CDKcontextModel.objects.filter(cdk=cdk).values('is_activate', 'rank__id',
                                                                        'rank__commodity_code')
                if not cdk_qs.exists():
                    return response.json(10040)
                if cdk_qs[0]['is_activate'] == 1:
                    return response.json(10039)
                rank = cdk_qs[0]['rank__id']

            if uid is None or channel is None or pay_type is None or rank is None:
                redisObj.del_data(key=redis_key)
                return response.json(444)

            # 判断是否为主用户操作
            device_info_qs = Device_Info.objects.filter(Q(UID=uid) & ~Q(vodPrimaryUserID='')).values('vodPrimaryUserID')
            if device_info_qs.exists():
                if device_info_qs[0]['vodPrimaryUserID'] != userID:
                    if pay_type == 10:
                        return response.json(10035)
                    if pay_type == 11:
                        return response.json(10036)

            dv_qs = Device_Info.objects.filter(userID_id=userID, UID=uid, isShare=False, isExist=1)
            if not dv_qs.exists():
                return response.json(12)

            orderID = CommonService.createOrderID()
            nowTime = int(time.time())
            ai_store_meal_qs = AiStoreMeal.objects.filter(id=rank, lang__lang=lang, is_show=1). \
                values('lang__content', 'price', 'currency', 'effective_day')
            if not ai_store_meal_qs.exists():
                return response.json(173)

            effective_day = ai_store_meal_qs[0]['effective_day']
            endTime = int(time.time()) + effective_day * 24 * 60 * 60  # 套餐结束时间
            ai_cn_store_meal_qs = AiStoreMeal.objects.filter(id=rank, lang__lang='cn', is_show=1). \
                values('lang__content', 'lang__title')
            if ai_cn_store_meal_qs.exists():
                store_meal_name = ai_cn_store_meal_qs[0]['lang__title'] + '-' + ai_cn_store_meal_qs[0]['lang__content']
            else:
                store_meal_name = '未知套餐'
            with transaction.atomic():
                # 订单表创建数据
                Order_Model.objects.create(orderID=orderID, UID=uid, channel=channel, userID_id=userID,
                                           desc=ai_store_meal_qs[0]['lang__content'], payType=pay_type, payTime=nowTime,
                                           price=ai_store_meal_qs[0]['price'], currency=ai_store_meal_qs[0]['currency'],
                                           addTime=nowTime, updTime=nowTime, pay_url='AI体验',
                                           store_meal_name=store_meal_name, order_type=1,
                                           rank_id=1, ai_rank_id=rank, status=1)
                # ai服务表创建数据
                AiService.objects.create(uid=uid, channel=channel, orders_id=orderID, detect_status=1, endTime=endTime,
                                         addTime=nowTime, updTime=nowTime, use_status=1)
                logger.info('{}成功开通AI体验,结束时间{}'.format(uid, endTime))
                if pay_type == 10:
                    ExperienceAiModel.objects.create(
                        experience_type=0,
                        uid=uid,
                        do_time=nowTime
                    )

                elif pay_type == 11:
                    CDKcontextModel.objects.filter(cdk=cdk).update(is_activate=1, order=orderID)

                redisObj.del_data(key=redis_key)
                pay_ok_url = "{}cloudstorage/payOK?paytype={}&lang={}".format(SERVER_DOMAIN_SSL, pay_type, lang)
                return response.json(0, pay_ok_url)
        except Exception as e:
            print(e)
            redisObj.del_data(key=redis_key)
            return response.json(474)

    def do_create_pay_order(self, request_dict, request, userID, response):
        uid = request_dict.get('uid', None)
        channel = request_dict.get('channel', None)
        pay_type = int(request_dict.get('pay_type', 1))
        rank = request_dict.get('rank', None)
        lang = request_dict.get('lang', 'en')
        if not uid or not channel or not pay_type or not rank:
            return response.json(444)

        try:
            # 判断是否为主用户
            # 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)

            # 获取ai套餐数据
            ai_sm_qs = AiStoreMeal.objects.filter(id=rank, pay_type=pay_type, is_show=1, lang__lang=lang). \
                values('lang__title', 'lang__content', 'currency', 'price')
            if not ai_sm_qs.exists():
                return response.json(173)
            title = ai_sm_qs[0]['lang__title']
            content = ai_sm_qs[0]['lang__content']
            currency = ai_sm_qs[0]['currency']
            price = ai_sm_qs[0]['price']
            ai_store_meal_qs = AiStoreMeal.objects.filter(id=rank, is_show=1, lang__lang='cn'). \
                values('lang__title', 'lang__content')
            if ai_store_meal_qs.exists():
                store_meal_name = ai_store_meal_qs[0]['lang__title'] + '-' + ai_store_meal_qs[0]['lang__content']
            else:
                store_meal_name = '未知套餐'
            nowTime = int(time.time())
            orderID = CommonService.createOrderID()
            price = round(float(price), 2)

            order_dict = {
                'orderID': orderID,
                'UID': uid,
                'channel': channel,
                'userID_id': userID,
                'desc': content,
                'payType': pay_type,
                'payTime': nowTime,
                'price': price,
                'currency': currency,
                'addTime': nowTime,
                'updTime': nowTime,
                'ai_rank_id': rank,
                'rank_id': 1,
                'order_type': 1,
                'store_meal_name': store_meal_name
            }

            if pay_type == 1:  # PayPal支付
                order_dict['paymentID'], order_dict['pay_url'] = self.create_paypal_payment(lang, orderID, price,
                                                                                            currency, content, response)
                res_data = {'redirectUrl': order_dict['pay_url'], 'orderID': orderID}
            elif pay_type == 2:  # 支付宝
                order_dict['pay_url'] = self.create_alipay_payment(lang, orderID, price, title, content, response)
                res_data = {'redirectUrl': order_dict['pay_url'], 'orderID': orderID}
            elif pay_type == 3:  # 微信支付
                ip = CommonService.get_ip_address(request)
                order_dict['pay_url'], sign_params = self.create_wechat_payment(lang, orderID, price, ip, content,
                                                                                response)
                res_data = {'redirectUrl': order_dict['pay_url'], 'orderID': orderID, 'result': sign_params}
            else:
                return response.json(444, {'param': 'pay_type'})
            Order_Model.objects.create(**order_dict)
            return response.json(0, res_data)
        except Exception as e:
            print(e)
            return response.json(500, repr(e))

    @staticmethod
    def create_paypal_payment(lang, orderID, price, currency, content, response):
        cancel_url = CommonService.get_payment_status_url(lang, 'fail')
        call_sub_url = "{}AiService/doPayPalCallBack?orderID={}&lang={}".format(SERVER_DOMAIN_SSL, orderID, lang)

        paypalrestsdk.configure(PAYPAL_CRD)
        payment = paypalrestsdk.Payment({
            "intent": "sale",
            "payer": {"payment_method": "paypal"},
            "redirect_urls": {"return_url": call_sub_url, "cancel_url": cancel_url},
            "transactions": [{
                "item_list": {"items": [
                    {"name": "Cloud video", "sku": "1", "price": price, "currency": "USD", "quantity": 1}]},
                "amount": {"total": price, "currency": currency},
                "description": content}]})
        if not payment.create():  # 创建失败
            return response.json(10, payment.error)
        paymentID = payment['id']  # 获取paymentID
        for link in payment.links:
            if link.rel == "approval_url":
                pay_url = str(link.href)
                return paymentID, pay_url
        return response.json(10, 'create_ai_order_failed')

    @staticmethod
    def create_alipay_payment(lang, orderID, price, title, content, response):
        aliPayObj = AliPayObject()
        alipay = aliPayObj.conf()
        subject = title + content
        order_string = alipay.api_alipay_trade_wap_pay(
            out_trade_no=orderID,
            total_amount=price,
            subject=subject,
            return_url="{}web/paid2/success.html".format(SERVER_DOMAIN_SSL),
            notify_url="{}AiService/doAlipayCallBack".format(SERVER_DOMAIN_SSL),
            quit_url="{}web/paid2/fail.html".format(SERVER_DOMAIN_SSL),
            passback_params=quote("lang=" + lang)
        )
        if not order_string:
            return response.json(10, '生成订单错误.')
        return aliPayObj.alipay_prefix + order_string

    @staticmethod
    def create_wechat_payment(lang, orderID, price, ip, content, response):
        pay = WechatPayObject()
        pay_url = "{}AiService/doWechatCallBack".format(SERVER_DOMAIN_SSL)
        # 统一调用接口
        pay.get_parameter(orderID, content, float(price) * 100, ip, pay_url, quote("lang=" + lang))
        sign_params = pay.re_finall(orderid=orderID)
        if not sign_params:
            return response.json(10, '生成订单错误.')
        return pay_url, sign_params

    def do_pay_by_paypal_callback(self, request_dict, response):
        logger = logging.getLogger('info')
        logger.info('AI订单---paypal支付回调')
        paymentId = request_dict.get('paymentId', None)
        PayerID = request_dict.get('PayerID', None)
        orderID = request_dict.get('orderID', None)
        lang = request_dict.get('lang', 'en')

        if not orderID:
            pay_failed_url = CommonService.get_payment_status_url(lang, 'fail')
            return HttpResponseRedirect(pay_failed_url)

        logger.info("paymentID: {}, payerID: {}".format(paymentId, PayerID))

        # redis加锁，防止订单重复
        redisObj = RedisObject()
        isLock = redisObj.CONN.setnx(orderID + 'do_notify', 1)
        redisObj.CONN.expire(orderID + 'do_notify', 60)
        if not isLock:
            return response.json(5)

        try:
            order_qs = Order_Model.objects.filter(orderID=orderID, status=0)
            if not order_qs.exists():
                return response.json(173)

            paypalrestsdk.configure(PAYPAL_CRD)
            payment = paypalrestsdk.Payment.find(paymentId)
            logger.info("payment: {}".format(payment))

            payer = payment.execute({"payer_id": PayerID})
            logger.info('payres: {}'.format(payer))
            if not payer:
                pay_failed_url = CommonService.get_payment_status_url(lang, 'fail')
                redisObj.del_data(key=orderID + 'do_notify')
                return HttpResponseRedirect(pay_failed_url)
            return self.payment_success(orderID, lang, order_qs, redisObj)
        except Exception as e:
            logger.info('AI订单paypal支付回调异常:{}'.format(repr(e)))
            order_qs.update(status=10)
            pay_failed_url = CommonService.get_payment_status_url(lang, 'fail')
            redisObj.del_data(key=orderID + 'do_notify')
            return HttpResponseRedirect(pay_failed_url)

    def do_alipay_callback(self, request_dict, response):  # 支付宝支付回调
        logger = logging.getLogger('info')
        logger.info('AI订单---支付宝支付回调')
        try:
            data = request_dict.dict()
            passback_params = data['passback_params']
            parmap = dict([(k, v[0]) for k, v in parse_qs(unquote(passback_params)).items()])
            lang = parmap['lang']
            signature = data['sign']
            data.pop('sign')
            orderID = data['out_trade_no']

            # redis加锁，防止订单重复
            redisObj = RedisObject()
            isLock = redisObj.CONN.setnx(orderID + 'do_notify', 1)
            redisObj.CONN.expire(orderID + 'do_notify', 60)
            if not isLock:
                return response.json(5)

            order_qs = Order_Model.objects.filter(orderID=orderID, status=0)
            if not order_qs.exists():
                return response.json(173)

            aliPayObj = AliPayObject()
            alipay = aliPayObj.conf()
            success = alipay.verify(data, signature)
            if not success or data["trade_status"] not in ("TRADE_SUCCESS", "TRADE_FINISHED"):
                return response.json(0, signature)
            return self.payment_success(orderID, lang, order_qs, redisObj)
        except Exception as e:
            logger.info('AI订单支付宝支付回调异常:{}'.format(repr(e)))
            order_qs.update(status=10)
            redisObj.del_data(key=orderID + 'do_notify')
            pay_failed_url = CommonService.get_payment_status_url(lang, 'fail')
            redisObj.del_data(key=orderID + 'do_notify')
            return HttpResponseRedirect(pay_failed_url)

    def do_wechat_callback(self, request, response):  # 微信支付回调
        logger = logging.getLogger('info')
        logger.info('AI订单---微信支付回调')
        try:
            pay = WechatPayObject()
            data = pay.weixinpay_call_back(request.body)
            attach = data["attach"]
            parmap = dict([(k, v[0]) for k, v in parse_qs(unquote(attach)).items()])
            lang = parmap['lang']
            trade_status = data['result_code']  # 业务结果  SUCCESS/FAIL
            orderID = data['out_trade_no']  # 商户订单号
            order_qs = Order_Model.objects.filter(orderID=orderID, status=0)
            if not order_qs.exists():
                return response.json(173)

            if trade_status != 'SUCCESS':
                order_qs.update(status=10)
                return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL'}))
            check_sign = pay.get_notifypay(data)
            if not check_sign:
                return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL', 'return_msg': '签名失败'}))

            # redis加锁，防止订单重复
            redisObj = RedisObject()
            isLock = redisObj.CONN.setnx(orderID + 'do_notify', 1)
            redisObj.CONN.expire(orderID + 'do_notify', 60)
            if not isLock:
                return response.json(5)

            return self.payment_success(self, orderID, lang, order_qs, redisObj, True)
        except Exception as e:
            order_qs.update(status=10)
            redisObj.del_data(key=orderID + 'do_notify')
            return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL', 'return_msg': repr(e)}))

    def payment_success(self, orderID, lang, order_qs, redisObj, is_wechat_pay=False):
        nowTime = int(time.time())
        order_list = order_qs.values("UID", "channel", "commodity_code", "ai_rank__effective_day", "isSelectDiscounts",
                                     "userID__userID", "userID__username", "coupon_id")
        userid = order_list[0]['userID__userID']
        username = order_list[0]['userID__username']
        UID = order_list[0]['UID']
        channel = order_list[0]['channel']
        effective_day = order_list[0]['ai_rank__effective_day']

        ai_service_qs = AiService.objects.filter(Q(uid=UID), Q(channel=channel), Q(use_status=1))
        ai_service_dict = {'orders_id': orderID,
                           'uid': UID,
                           'channel': channel,
                           'detect_status': 1,
                           'addTime': nowTime,
                           'updTime': nowTime,
                           }
        if ai_service_qs.exists():  # 有正在使用的套餐,套餐结束时间保存为套餐有效期
            ai_service_dict['endTime'] = effective_day * 24 * 60 * 60
        else:
            ai_service_dict['use_status'] = 1
            ai_service_dict['endTime'] = nowTime + effective_day * 24 * 60 * 60
        with transaction.atomic():
            # 更新设备主用户
            Device_Info.objects.filter(UID=UID, vodPrimaryUserID='', vodPrimaryMaster=''). \
                update(vodPrimaryUserID=userid, vodPrimaryMaster=username)
            # 更新订单数据,返回支付成功url
            order_qs.update(status=1, updTime=nowTime)
            # 创建AiService数据
            AiService.objects.create(**ai_service_dict)

        pay_success_url = CommonService.get_payment_status_url(lang, 'success')
        redisObj.del_data(key=orderID + 'do_notify')
        if is_wechat_pay:
            return HttpResponse("<xml>\
              <return_code><![CDATA[SUCCESS]]></return_code>\
              <return_msg><![CDATA[OK]]></return_msg>\
            </xml>")
        else:
            return HttpResponseRedirect(pay_success_url)

    def upload_s3(self, file_path, upload_path):
        try:
            aws_key = "AKIA2E67UIMD45Y3HL53"  # 【你的 aws_access_key】
            aws_secret = "ckYLg4Lo9ZXJIcJEAKkzf2rWvs8Xth1FCjqiAqUw"  # 【你的 aws_secret_key】
            session = Session(aws_access_key_id=aws_key,
                              aws_secret_access_key=aws_secret,
                              region_name="us-east-1")
            s3 = session.resource("s3")
            # client = session.client("s3")
            bucket = "foreignpush"  # 【你 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 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
            elif p['is_st'] == 3:
                # 列表装载回放时间戳标记
                p['img_list'] = []
                for i in range(4):
                    thumbspng = '{uid}/{channel}/{time}_{st}.jpg'.format(uid=devUid, channel=p['Channel'],
                                                                         time=eventTime, st=i)
                    response_url = aws_s3_client.generate_presigned_url('get_object',
                                                                        ExpiresIn=300,
                                                                        Params={
                                                                            'Bucket': 'aipush', 'Key': thumbspng
                                                                        },
                                                                        )
                    p['img_list'].append(response_url)

            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})

    def readInfo(self, userID, request_dict, response):
        is_update_all = request_dict.get('is_update_all', 0)

        try:
            if int(is_update_all) == 1:  # 全部已读
                is_update = Ai_Push_Info.objects.filter(userID_id=userID).update(status=1)
                return response.json(0, {'update_count': is_update})
            else:
                id_list = request_dict.get('id_list', None)
                if not id_list:
                    request_dict.getlist('id_list[]', None)  # 获取IOS数组传参
                logger = logging.getLogger('info')
                logger.info('已读ai消息id_list:{}'.format(id_list))
                if not id_list:
                    return response.json(444)
                id_list = eval(id_list)  # 字符串转列表
                param_flag = CommonService.get_param_flag(data=id_list)
                if not param_flag:
                    return response.json(444)
                count = 0
                for id in id_list:
                    ai_push_qs = Ai_Push_Info.objects.filter(id=int(id))
                    if ai_push_qs.exists():
                        own_dev = ModelService.check_own_device(userID, ai_push_qs[0].devUid)
                        if own_dev:
                            count += 1
                            ai_push_qs.update(status=1)
                return response.json(0, {'update_success': count})
        except Exception as e:
            print(e)
            return response.json(500, repr(e))

    def deleteInfo(self, userID, request_dict, response):
        id_list = request_dict.get('id_list', None)
        if not id_list:
            request_dict.getlist('id_list[]', None)  # 获取IOS数组传参
        logger = logging.getLogger('info')
        logger.info('删除ai消息id_list:{}'.format(id_list))
        if not id_list:
            return response.json(444)
        try:
            id_list = eval(id_list)  # 字符串转列表
            param_flag = CommonService.get_param_flag(data=id_list)
            if not param_flag:
                return response.json(444)
            for id in id_list:
                ai_push_qs = Ai_Push_Info.objects.filter(id=id)
                if ai_push_qs.exists():
                    own_dev = ModelService.check_own_device(userID, ai_push_qs[0].devUid)
                    if own_dev:
                        ai_push_qs.delete()
            return response.json(0)
        except Exception as e:
            print(e)
            return response.json(500, repr(e))