ASJServer/Controller/Cron/CronTaskController.py

#!/usr/bin/python3.6
# -*- coding: utf-8 -*-
#
# Copyright (C) 2022 #
# @Time    : 2022/4/1 11:27
# @Author  : ming
# @Email   : zhangdongming@asj6.wecom.work
# @File    : CronTaskController.py
# @Software: PyCharm
import datetime
import io
import json
import threading
import time
import zipfile

import paypalrestsdk
import requests
import csv
import math
from django.db import connection, connections, transaction
from django.db.models import Q, Sum, Count
from django.views import View

from Ansjer.config import USED_SERIAL_REDIS_LIST, UNUSED_SERIAL_REDIS_LIST, CONFIG_INFO, CONFIG_US, \
    RESET_REGION_ID_SERIAL_REDIS_LIST, LOGGER, PAYPAL_CRD, CONFIG_EUR, DETECT_PUSH_DOMAINS, ACCESS_KEY_ID, \
    SECRET_ACCESS_KEY, REGION_NAME, CONFIG_CN
from Model.models import Device_User, Device_Info, UidSetModel, UID_Bucket, Unused_Uid_Meal, Order_Model, StsCrdModel, \
    VodHlsModel, ExperienceContextModel, AiService, VodHlsSummary, VideoPlaybackTimeModel, DeviceUserSummary, \
    CountryModel, DeviceTypeModel, OrdersSummary, DeviceInfoSummary, CompanySerialModel, \
    CloudLogModel, UidCloudStorageCount, UserExModel, DeviceDomainRegionModel, VodHlsTag, VodHlsTagType, \
    Store_Meal, Lang, VodBucketModel, UnicomComboOrderInfo, UnicomDeviceInfo, AbnormalOrder, DailyReconciliation, \
    CustomizedPush, UIDCompanySerialModel, UIDModel, LogModel, OperatingCosts, UidBucketStatistics, AppScannedSerial, \
    SerialUnbindUID, UidUserModel, UidPushModel, iotdeviceInfoModel, ExperienceAiModel
from Object.AWS.AmazonS3Util import AmazonS3Util
from Object.AWS.S3Email import S3Email
from Object.RedisObject import RedisObject
from Object.ResponseObject import ResponseObject
from Object.utils import LocalDateTimeUtil
from Service.CommonService import CommonService
from Service.EquipmentInfoService import EQUIPMENT_INFO_MODEL_LIST, EquipmentInfoService
from Service.VodHlsService import SplitVodHlsObject
from Object.UnicomObject import UnicomObjeect
from Object.WechatPayObject import WechatPayObject
from Object.AliPayObject import AliPayObject
from dateutil.relativedelta import relativedelta


class CronDelDataView(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 == 'delAccessLog':  # 定时删除访问接口数据
            return self.delAccessLog(response)
        elif operation == 'delPushInfo':  # 定时删除推送数据
            return self.delPushInfo(response)
        elif operation == 'delPushInfoV2':  # 定时删除推送数据V2
            return self.delPushInfoV2(response)
        elif operation == 'delSysMsg':  # 定时删除系统消息数据
            return self.delSysMsg(response)
        elif operation == 'delVodHls':  # 定时删除云存播放列表
            return self.delVodHls(response)
        elif operation == 'delCloudLog':  # 定时删除云存接口数据
            return self.delCloudLog(response)
        elif operation == 'delTesterDevice':  # 定时删除测试账号下的设备数据
            return self.delTesterDevice(response)
        elif operation == 'delAppLog':  # 定时删除app日志
            return self.delAppLog(response)
        elif operation == 'delDeviceLog':  # 定时删除设备日志
            return self.delDeviceLog(response)
        elif operation == 'UpdateConfiguration':  # 定时更新配置
            return self.UpdateConfiguration(response)
        elif operation == 'cloud-log':
            return self.uid_cloud_storage_upload_count(response)
        elif operation == 'delDeviceLog':  # 定时删除设备日志
            return self.del_device_log(response)
        else:
            return response.json(404)

    @staticmethod
    def UpdateConfiguration(response):
        """
        定时更新配置
        @param response: 响应对象
        @return:
        """
        try:
            ucode_list = ['823C01552AA',
                          '823C01550AA',
                          '823C01550XA',
                          '823C01850XA',
                          '730201350AA',
                          '730201350AA',
                          '730201450AA',
                          '730201450MA',
                          '72V201252AA',
                          '72V201253AA',
                          '72V201353AA',
                          '72V201354AA',
                          '72V201355AA',
                          '72V201254AA',
                          'V82301850AA',
                          'V82301850XA',
                          '72V201257AA', '72V201256AA']
            UidSetModel.objects.filter(ucode__in=ucode_list, is_human=0).update(is_human=1)

            ucode_list = ['72V201257AA', '72V201254AA']  # 4G规格码
            UidSetModel.objects.filter(ucode__in=ucode_list, mobile_4g=0).update(mobile_4g=1)

            # 根据设备规格码定时更新默认算法类型类型
            ucode_list = ['823C01552AA', '823C01550AA', '823C01550XA', 'C18201550KA',
                          '823C01550TA', '823C01550VA', '823C01850XA', 'C18201850KA',
                          '823C01850TA', '823C01850VA', 'C22501850VA']
            UidSetModel.objects.filter(ucode__in=ucode_list, ai_type=0).update(ai_type=47)

            ucode_list = ['730201350AA', '730201450AA', '730201450MA', '730201450NA']
            UidSetModel.objects.filter(ucode__in=ucode_list, ai_type=0).update(ai_type=7)

            ucode_list = ['V82301850AA', 'V82301850XA']
            UidSetModel.objects.filter(ucode__in=ucode_list, ai_type=0).update(ai_type=2031)

            # 根据设备规格码更新默认个性化语音值
            ucode_list = ['823C01552AA', '823C01550XA', 'C18201550KA', '823C01550TA',
                          '823C01550VA', '823C01850XA', 'C18201850KA', '823C01850TA', '823C01850VA',
                          '730201450AA', '730201450MA', '730201450NA', '72V201252AA', '72V201253AA',
                          '72V201353AA', '72V201354AA', '72V201355AA', '72V201254AA', 'C22501850VA',
                          'V82301850AA', 'V82301850XA', '72V201257AA', '72V201256AA']
            UidSetModel.objects.filter(ucode__in=ucode_list, is_custom_voice=0).update(is_custom_voice=1)

            # 根据设备规格码更新is_ai
            ucode_list = ['823C01552AA', '823C01550XA', 'C18201550KA', '823C01550TA',
                          '823C01550VA', '823C01850XA', 'C18201850KA', '823C01850TA', '823C01850VA',
                          '730201450AA', '730201450MA', '730201450NA', '72V201252AA', '72V201253AA',
                          '72V201353AA', '72V201354AA', '72V201355AA', '72V201254AA', 'C22501850VA',
                          'V82301850AA', 'V82301850XA', '72V201257AA', '72V201256AA', '730201350AA']
            UidSetModel.objects.filter(ucode__in=ucode_list, is_ai=2).update(is_ai=1)

            # 根据设备规格码更新alexa
            ucode_list = ['823C01552AA', '823C01550AA', '823C01550XA', '522001352AA',
                          '823C01550TA', '823C01550VA', '823C01850XA', 'C18201850KA', '823C01850TA',
                          'C22501850VA', 'V82301850AA', 'V82301850XA', '730201350AA', '72V201252AA',
                          '72V201253AA', '72V201353AA', '72V201354AA', '72V201355AA', '72V201256AA']
            UidSetModel.objects.filter(ucode__in=ucode_list, is_alexa=0).update(is_alexa=1)

            # 根据ai类型和设备类型修改516 type
            uid_list = UidSetModel.objects.filter(ai_type=18563).values_list('uid')
            Device_Info.objects.filter(Type=10, UID__in=uid_list).update(Type=24)
            return response.json(0)
        except Exception as e:
            LOGGER.info('UpdateConfiguration异常详情,errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def delAppLog(response):
        """
        定时删除app日志
        @param response: 响应对象
        @return:
        """
        nowTime = int(time.time())
        try:
            cursor = connection.cursor()
            month_ago_time = nowTime - 30 * 24 * 60 * 60  # 保留近30天的数据
            sql = 'DELETE FROM `app_log` WHERE add_time<{}'.format(month_ago_time)
            cursor.execute(sql)
            cursor.close()
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def delDeviceLog(response):
        """
        定时删除设备日志
        @param response: 响应对象
        @return:
        """
        nowTime = int(time.time())
        size = 5000
        try:
            cursor = connection.cursor()
            month_ago_time = nowTime - 30 * 24 * 60 * 60  # 保留近30天的数据
            month_ago_time_str = CommonService.timestamp_to_str(month_ago_time)
            sql = "DELETE FROM `device_log` WHERE add_time<'{}' LIMIT {}".format(month_ago_time_str, size)
            cursor.execute(sql)
            cursor.close()
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def uid_cloud_storage_upload_count(response):
        try:
            now_time = int(time.time())
            local_time = LocalDateTimeUtil.get_before_days_timestamp(now_time)
            format_str = '%Y-%m-%d'
            date_str = LocalDateTimeUtil.time_stamp_to_time(local_time, format_str)
            start_time, end_time = LocalDateTimeUtil.get_start_and_end_time(date_str, format_str)
            cs_uid_qs = UID_Bucket.objects.filter(addTime__gte=int(1669824000)).values('uid')
            if not cs_uid_qs.exists():
                return response.json(0)
            for item in cs_uid_qs:
                uid = item['uid']
                cloud_log_qs = CloudLogModel.objects.filter(uid=uid, operation=r'cloudstorage/storeplaylist',
                                                            time__gte=start_time, time__lte=end_time)
                cloud_log_qs = cloud_log_qs.values('uid')[0:1]
                if not cloud_log_qs.exists():
                    continue
                count_data = {'uid': uid, 'count': cloud_log_qs.count(), 'created_time': end_time,
                              'updated_time': end_time}
                UidCloudStorageCount.objects.create(**count_data)
            return response.json(0)
        except Exception as e:
            LOGGER.info('异常详情,errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
            return response.json(500)

    @staticmethod
    def delAccessLog(response):
        try:
            cursor = connection.cursor()
            # 删除7天前的数据
            last_week = LocalDateTimeUtil.get_last_week()
            sql = 'DELETE FROM access_log WHERE time < %s limit %s'
            cursor.execute(sql, [last_week, 10000])
            # 关闭游标
            cursor.close()
            connection.close()
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @classmethod
    def delPushInfo(cls, response):
        now_time = int(time.time())
        try:
            # 当前时间转日期
            local_date_now = str(datetime.datetime.fromtimestamp(int(now_time)).date())
            # 根据日期获取周几
            week_val = LocalDateTimeUtil.date_to_week(local_date_now)
            # 根据当前时间获取7天前时间戳
            expiration_time = LocalDateTimeUtil.get_before_days_timestamp(now_time, 7)

            # 异步删除推送消息
            kwargs = {
                'week_val': week_val,
                'expiration_time': expiration_time
            }
            del_push_info_thread = threading.Thread(
                target=cls.del_push_info_data,
                kwargs=kwargs)
            del_push_info_thread.start()
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def del_push_info_data(**kwargs):
        cursor = connections['mysql02'].cursor()

        # 获取删除星期列表
        week_val = kwargs['week_val']
        del_week_val_list = [i for i in range(1, 8)]
        # 移除当天和前后两天
        del_week_val_list.remove(week_val)

        if week_val == 1:
            pre_week_val = 7
        else:
            pre_week_val = week_val - 1
        del_week_val_list.remove(pre_week_val)

        if week_val == 7:
            nex_week_val = 1
        else:
            nex_week_val = week_val + 1
        del_week_val_list.remove(nex_week_val)

        expiration_time = kwargs['expiration_time']
        # 每次删除条数
        size = 5000
        # 删除7天前的数据
        sql = "DELETE FROM equipment_info WHERE addTime<= %s LIMIT %s "
        cursor.execute(sql, [expiration_time, size])
        for week_val in del_week_val_list:
            if week_val == 1:
                sql = "DELETE FROM equipment_info_monday WHERE add_time<= %s LIMIT %s "
            if week_val == 2:
                sql = "DELETE FROM equipment_info_tuesday WHERE add_time<= %s LIMIT %s "
            if week_val == 3:
                sql = "DELETE FROM equipment_info_wednesday WHERE add_time<= %s LIMIT %s "
            if week_val == 4:
                sql = "DELETE FROM equipment_info_thursday WHERE add_time<= %s LIMIT %s "
            if week_val == 5:
                sql = "DELETE FROM equipment_info_friday WHERE add_time<= %s LIMIT %s "
            if week_val == 6:
                sql = "DELETE FROM equipment_info_saturday WHERE add_time<= %s LIMIT %s "
            if week_val == 7:
                sql = "DELETE FROM equipment_info_sunday WHERE add_time<= %s LIMIT %s "
            cursor.execute(sql, [expiration_time, size])
        # 关闭游标
        cursor.close()

    @classmethod
    def delPushInfoV2(cls, response):
        try:
            del_push_info_thread = threading.Thread(
                target=cls.del_push_info_data_v2)
            del_push_info_thread.start()
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def delSysMsg(response):
        try:
            cursor = connections['mysql02'].cursor()

            # 获取90天前时间戳
            now_time = int(time.time())
            expiration_time = LocalDateTimeUtil.get_before_days_timestamp(now_time, 90)

            # 每次删除条数
            size = 5000

            sql = "DELETE FROM sys_msg WHERE addTime< %s LIMIT %s "
            cursor.execute(sql, [expiration_time, size])

            # 关闭游标
            cursor.close()
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def del_push_info_data_v2():
        cursor = connections['mysql02'].cursor()

        # 获取7天前时间戳
        now_time = int(time.time())
        expiration_time = LocalDateTimeUtil.get_before_days_timestamp(now_time, 7)

        # 每次删除条数
        size = 5000

        for i in range(1, len(EQUIPMENT_INFO_MODEL_LIST) + 1):
            sql = "DELETE FROM equipment_info_{} WHERE add_time< %s LIMIT %s ".format(i)
            cursor.execute(sql, [expiration_time, size])

        # 关闭游标
        cursor.close()

    @staticmethod
    def delVodHls(response):
        nowTime = int(time.time())
        try:
            CronDelDataView.del_vod_hls_tag()
            cursor = connection.cursor()
            month_ago_time = nowTime - 3 * 30 * 24 * 60 * 60  # 删除3个月前的数据
            sql = 'DELETE FROM `vod_hls` WHERE endTime<{} LIMIT 50000'.format(month_ago_time)
            cursor.execute(sql)
            cursor.close()
            # 删除vod_hls分表数据
            split_vod_hls_obj = SplitVodHlsObject()
            split_vod_hls_obj.del_vod_hls_data(end_time__lt=month_ago_time)
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def del_vod_hls_tag():
        """
        删除AI标签记录
        """
        e_time = LocalDateTimeUtil.get_before_days_timestamp(int(time.time()), 30)
        VodHlsTagType.objects.filter(created_time__lt=e_time).delete()
        VodHlsTag.objects.filter(created_time__lt=e_time).delete()

    @staticmethod
    def delCloudLog(response):
        nowTime = int(time.time())
        cursor = connection.cursor()
        try:
            # 删除3个月前的数据
            sql = "DELETE FROM `cloud_log` WHERE time<={} LIMIT 50000".format(
                nowTime - 3 * 30 * 24 * 60 * 60)
            cursor.execute(sql)
            # 关闭游标
            cursor.close()
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def delTesterDevice(response):
        try:
            userID_list = [
                'tech01@ansjer.com',
                'tech02@ansjer.com',
                'tech03@ansjer.com',
                'tech04@ansjer.com',
                'tech05@ansjer.com',
                'tech06@ansjer.com',
                'tech07@ansjer.com',
                'tech08@ansjer.com',
                'tech09@ansjer.com',
                'tech10@ansjer.com',
                'fix01@ansjer.com',
                'fix02@ansjer.com',
                'fix03@ansjer.com',
                'fix04@ansjer.com',
                'fix05@ansjer.com']
            device_user = Device_User.objects.filter(username__in=userID_list)
            device_info_qs = Device_Info.objects.filter(
                userID__in=device_user).values('UID')
            uid_list = []
            for device_info in device_info_qs:
                uid_list.append(device_info['UID'])
            with transaction.atomic():
                # 删除设备云存相关数据
                UidSetModel.objects.filter(uid__in=uid_list).delete()
                UID_Bucket.objects.filter(uid__in=uid_list).delete()
                Unused_Uid_Meal.objects.filter(uid__in=uid_list).delete()
                # Order_Model.objects.filter(UID__in=uid_list).delete()
                StsCrdModel.objects.filter(uid__in=uid_list).delete()
                VodHlsModel.objects.filter(uid__in=uid_list).delete()
                # 删除vod_hls分表数据
                split_vod_hls_obj = SplitVodHlsObject()
                split_vod_hls_obj.del_vod_hls_data(uid__in=uid_list)
                ExperienceContextModel.objects.filter(uid__in=uid_list).delete()
                Device_Info.objects.filter(userID__in=device_user).delete()
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def del_device_log(response):
        """
        定时删除设备日志
        @param response: 响应对象
        @return:
        """
        nowTime = int(time.time())
        try:
            cursor = connection.cursor()
            month_ago_time = nowTime - 30 * 24 * 60 * 60  # 保留近30天的数据

            sql = 'DELETE FROM `device_log` WHERE unix_timestamp(add_time)<{}'.format(month_ago_time)
            cursor.execute(sql)
            cursor.close()
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))


class CronUpdateDataView(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 == 'updateUnusedUidBucket':  # 定时更新过期云存关联的未使用套餐状态
            return self.updateUnusedUidBucket(response)
        elif operation == 'updateUnusedAiService':  # 定时更新过期ai关联的未使用套餐状态
            return self.updateUnusedAiService(response)
        elif operation == 'reqUpdateSerialStatus':  # 定时请求更新序列号状态
            return self.reqUpdateSerialStatus(response)
        elif operation == 'updateSerialStatus':  # 更新序列号状态
            return self.updateSerialStatus(request_dict, response)
        elif operation == 'deleteUidData':  # 清除uid数据
            return self.deleteUidData(request_dict, response)
        elif operation == 'reset-region-id':  # 重置地区id
            return self.reset_region_id(request_dict, response)
        elif operation == 'updateVodMeal':  # 定时修改体验套餐有效期为1个月
            return self.update_vod_meal(request_dict, response)
        elif operation == 'checkCustomizedPush':  # 定时检查定制化推送,重新执行没有推送成功的请求
            return self.check_customized_push(response)
        else:
            return response.json(404)

    @staticmethod
    def updateUnusedUidBucket(response):
        """
        监控云存套餐过期修改状态
        @param response:
        @return:
        """
        # 定时更新已过期套餐修改状态为2
        now_time = int(time.time())
        expired_uid_bucket = UID_Bucket.objects.filter(endTime__lte=now_time)
        expired_uid_bucket = expired_uid_bucket.filter(~Q(use_status=2)).values('id')
        if expired_uid_bucket.exists():
            # 如果没有未使用套餐,或下个未使用套餐不是AI云存套餐,mqtt下发停用AI指令
            # 下个未使用套餐是AI云存套餐,mqtt下发启用AI指令
            for bucket in expired_uid_bucket:
                uid_bucket = UID_Bucket.objects.get(id=bucket['id'])
                uid = uid_bucket.uid
                # 存在序列号则为使用序列号作为物品名
                thing_name = CommonService.query_serial_with_uid(uid)
                topic_name = 'ansjer/generic/{}'.format(thing_name)
                msg = {'commandType': 'AIDisable'}
                if not uid_bucket.has_unused:
                    CommonService.req_publish_mqtt_msg(thing_name, topic_name, msg)
                else:
                    next_unused = Unused_Uid_Meal.objects.filter(uid=uid).order_by('addTime').first()
                    if next_unused is None or not getattr(next_unused, 'is_ai', 0):
                        CommonService.req_publish_mqtt_msg(thing_name, topic_name, msg)
                    else:
                        msg = {'commandType': 'AIEnable'}
                        CommonService.req_publish_mqtt_msg(thing_name, topic_name, msg)
            expired_uid_bucket.update(use_status=2)

        # 监控有未使用套餐则自动生效
        expired_uid_buckets = UID_Bucket.objects.filter(endTime__lte=now_time, has_unused=1).values("id", "uid")[0:1000]
        for expired_uid_bucket in expired_uid_buckets:
            unuseds = Unused_Uid_Meal.objects.filter(
                uid=expired_uid_bucket['uid']).values(
                "id",
                "uid",
                "channel",
                "addTime",
                "expire",
                "is_ai",
                "bucket_id",
                "order_id").order_by('addTime')
            if not unuseds.exists():
                continue
            unused = unuseds[0]
            try:
                with transaction.atomic():
                    count_unused = Unused_Uid_Meal.objects.filter(uid=expired_uid_bucket['uid']).count()
                    has_unused = 1 if count_unused > 1 else 0
                    end_time = CommonService.calcMonthLater(unused['expire'])
                    UID_Bucket.objects.filter(
                        uid=expired_uid_bucket['uid']).update(
                        channel=unused['channel'],
                        endTime=end_time,
                        bucket_id=unused['bucket_id'],
                        updateTime=now_time,
                        use_status=1,
                        has_unused=has_unused,
                        orderId=unused['order_id'])
                    if unused['is_ai']:
                        ai_service = AiService.objects.filter(uid=expired_uid_bucket['uid'], channel=unused['channel'])
                        if ai_service.exists():
                            ai_service.update(updTime=now_time, use_status=1, orders_id=unused['order_id'],
                                              endTime=end_time)
                        else:
                            AiService.objects.create(uid=expired_uid_bucket['uid'], channel=unused['channel'],
                                                     detect_status=1, addTime=now_time, orders_id=unused['order_id'],
                                                     updTime=now_time, endTime=end_time, use_status=1)
                    Unused_Uid_Meal.objects.filter(id=unused['id']).delete()
                    StsCrdModel.objects.filter(uid=expired_uid_bucket['uid']).delete()  # 删除sts记录
            except Exception as e:
                print(repr(e))
                continue
        return response.json(0)

    @staticmethod
    def updateUnusedAiService(response):
        now_time = int(time.time())
        ai_service_qs = AiService.objects.filter(
            endTime__lte=now_time,
            use_status=1).values(
            'id',
            'uid')[
                        0:200]
        for ai_service in ai_service_qs:
            try:
                with transaction.atomic():
                    AiService.objects.filter(
                        id=ai_service['id']).update(
                        use_status=2)  # 更新过期ai订单状态
                    # 如果存在未使用套餐,更新为使用
                    unused_ai_service = AiService.objects.filter(
                        uid=ai_service['uid'],
                        use_status=0).order_by('addTime')[
                                        :1].values(
                        'id',
                        'endTime')
                    if unused_ai_service.exists():
                        # 未使用套餐的endTime在购买的时候保存为有效时间
                        effective_day = unused_ai_service[0]['endTime']
                        endTime = now_time + effective_day
                        AiService.objects.filter(
                            id=unused_ai_service[0]['id']).update(
                            use_status=1, endTime=endTime, updTime=now_time)
            except Exception:
                continue
        return response.json(0)

    @classmethod
    def reqUpdateSerialStatus(cls, response):
        redis_obj = RedisObject()

        # 更新已使用序列号其他服务器的状态
        used_serial_redis_list = redis_obj.lrange(USED_SERIAL_REDIS_LIST, 0, -1)  # 读取redis已使用序列号
        if used_serial_redis_list:
            LOGGER.info('---请求更新已使用序列号列表---used_serial_redis_list:{}'.format(used_serial_redis_list))
            used_serial_redis_list = [str(i, 'utf-8') for i in used_serial_redis_list]
            cls.do_request_function(used_serial_redis_list, 3)

        # 更新未使用序列号其他服务器的状态
        unused_serial_redis_list = redis_obj.lrange(UNUSED_SERIAL_REDIS_LIST, 0, -1)  # 读取redis未使用序列号
        if unused_serial_redis_list:
            LOGGER.info('---请求更新未使用序列号列表---unused_serial_redis_list:{}'.format(unused_serial_redis_list))
            unused_serial_redis_list = [str(i, 'utf-8') for i in unused_serial_redis_list]
            cls.do_request_function(unused_serial_redis_list, 1)

        # 重置地区id
        reset_region_id_serial_redis_list = redis_obj.lrange(RESET_REGION_ID_SERIAL_REDIS_LIST, 0, -1)  # 读取redis未使用序列号
        if reset_region_id_serial_redis_list:
            LOGGER.info('---请求重置地区id的序列号列表---:{}'.format(reset_region_id_serial_redis_list))
            reset_region_id_serial_redis_list = [str(i, 'utf-8') for i in reset_region_id_serial_redis_list]
            cls.do_request_reset_region_id(reset_region_id_serial_redis_list)
        return response.json(0)

    @staticmethod
    def do_request_function(serial_redis_list, status):
        """
        请求更新序列号状态
        @param serial_redis_list: 序列号redis列表
        @param status: 状态, 1: 未使用, 3: 已占用
        """
        data = {
            'serial_redis_list': str(serial_redis_list),
            'status': status
        }
        # 确认域名列表
        orders_domain_name_list = CommonService.get_orders_domain_name_list()
        redis_obj = RedisObject()
        LOGGER.info('---请求更新序列号线程---data:{},orders_domain_name_list:{}'.format(data, orders_domain_name_list))
        try:
            requests_failed_flag = False  # 请求失败标志位
            for domain_name in orders_domain_name_list:
                url = '{}cron/update/updateSerialStatus'.format(domain_name)
                response = requests.post(url=url, data=data, timeout=5)
                LOGGER.info('---请求更新序列号响应时间---:{}'.format(response.elapsed.total_seconds()))
                result = response.json()
                if result['result_code'] != 0:  # 请求失败标志位置位
                    requests_failed_flag = True
                    break

                # 状态为未使用,重置扫码记录和美洲服的地区id
                if status == 1:
                    # 扫码记录
                    AppScannedSerial.objects.filter(serial__in=serial_redis_list).delete()
                    # 地区id
                    # 美洲服直接更新
                    if CONFIG_INFO == CONFIG_US:
                        DeviceDomainRegionModel.objects.filter(~Q(region_id=0), serial_number__in=serial_redis_list). \
                            update(region_id=0)
                    # 其他服请求到美洲服更新
                    else:
                        req_url = 'https://www.dvema.com/cron/update/reset-region-id'
                        req_data = {
                            'serial_redis_list': str(serial_redis_list)
                        }
                        response = requests.post(url=req_url, data=req_data, timeout=5)
                        LOGGER.info('---请求重置地区id响应时间---:{}'.format(response.elapsed.total_seconds()))
                        result = response.json()
                        if result['result_code'] != 0:  # 请求失败标志位置位
                            requests_failed_flag = True
                            break

            if not requests_failed_flag:  # 请求成功删除redis序列号
                if status == 1:
                    for i in serial_redis_list:
                        redis_obj.lrem(UNUSED_SERIAL_REDIS_LIST, 0, i)
                elif status == 3:
                    for i in serial_redis_list:
                        redis_obj.lrem(USED_SERIAL_REDIS_LIST, 0, i)
        except Exception as e:
            LOGGER.info('---更新序列号状态异常---:{}'.format(repr(e)))

    @staticmethod
    def do_request_reset_region_id(reset_region_id_serial_redis_list):
        """
        请求重置地区id
        @param reset_region_id_serial_redis_list: 序列号redis列表
        """
        redis_obj = RedisObject()
        requests_failed_flag = False  # 请求失败标志位
        data = {
            'serial_redis_list': str(reset_region_id_serial_redis_list),
        }
        url = 'https://www.dvema.com/cron/update/reset-region-id'

        try:
            response = requests.post(url=url, data=data, timeout=5)
            result = response.json()
            if result['result_code'] != 0:  # 请求失败标志位置位
                requests_failed_flag = True
            if not requests_failed_flag:  # 请求成功删除redis序列号
                for serial in reset_region_id_serial_redis_list:
                    redis_obj.lrem(RESET_REGION_ID_SERIAL_REDIS_LIST, 0, serial)
        except Exception as e:
            LOGGER.info('---请求重置地区id异常---:{}'.format(repr(e)))

    @staticmethod
    def updateSerialStatus(request_dict, response):
        """
        更新序列号状态
        @param request_dict: 请求参数
        @request_dict serial_redis_list: 序列号redis列表
        @request_dict status: 状态, 1: 未使用, 3: 已占用
        @param response: 响应对象
        """
        serial_redis_list = request_dict.get('serial_redis_list', None)
        status = request_dict.get('status', None)
        LOGGER.info('---更新序列号状态参数---serial_redis_list:{},status:{}'.format(serial_redis_list, status))
        if not all([serial_redis_list, status]):
            return response.json(444)
        now_time = int(time.time())
        try:
            serial_redis_list = eval(serial_redis_list)
            CompanySerialModel.objects.filter(serial_number__in=serial_redis_list).update(status=int(status),
                                                                                          update_time=now_time)
            uid_serial_qs = UIDCompanySerialModel.objects.filter(company_serial__serial_number__in=serial_redis_list)
            if uid_serial_qs:
                uid_list = list(uid_serial_qs.values_list('uid__uid', flat=True))
                serial_list = list(uid_serial_qs.values_list('company_serial__serial_number', flat=True))
                UIDModel.objects.filter(uid__in=uid_list).update(status=3, mac='', update_time=now_time)
                uid_serial_qs.delete()
                # 记录操作日志
                content = json.loads(json.dumps(request_dict))
                log = {
                    'ip': '127.0.0.1',
                    'user_id': 1,
                    'status': 200,
                    'time': now_time,
                    'content': json.dumps(content),
                    'url': 'cron/update/updateSerialStatus',
                    'operation': '序列号{}解绑uid: {}'.format(serial_list, uid_list),
                }
                LogModel.objects.create(**log)
            return response.json(0)
        except Exception as e:
            LOGGER.info('---更新序列号状态异常---:{}'.format(repr(e)))
            return response.json(500)

    @staticmethod
    def deleteUidData(request_dict, response):
        """
        清除uid数据
        @param request_dict: 请求参数
        @request_dict serial_redis_list: 序列号redis列表
        @param response: 响应对象
        """
        serial_unbind_uid_qs = SerialUnbindUID.objects.filter(status=0).values('serial', 'uid')
        # 没有需要清除的数据直接返回
        if not serial_unbind_uid_qs.exists():
            return response.json(0)
        # 获取序列号,uid列表
        serial_list, uid_list = [], []
        for serial_unbind_uid in serial_unbind_uid_qs:
            serial_list.append(serial_unbind_uid['serial'])
            uid_list.append(serial_unbind_uid['uid'])

        now_time = int(time.time())
        redis_obj = RedisObject()
        try:
            with transaction.atomic():
                # 更新序列号解绑uid表状态
                serial_unbind_uid_qs.update(status=1, updated_time=now_time)
                # 更新序列号状态
                CompanySerialModel.objects.filter(serial_number__in=serial_list).update(status=1, update_time=now_time)
                UIDCompanySerialModel.objects.filter(company_serial__serial_number__in=serial_list).delete()
                # 删除设备相关数据,参考后台的设备重置删除的数据
                Device_Info.objects.filter(UID__in=uid_list).delete()
                UidSetModel.objects.filter(uid__in=uid_list).delete()
                UidUserModel.objects.filter(UID__in=uid_list).delete()
                UidPushModel.objects.filter(uid_set__uid__in=uid_list).delete()
                iotdeviceInfoModel.objects.filter(serial_number__in=serial_list).delete()
                # 删除推送消息
                EquipmentInfoService.delete_all_equipment_info(device_uid__in=uid_list)

                # 重置设备云存
                UID_Bucket.objects.filter(uid__in=uid_list).delete()
                Unused_Uid_Meal.objects.filter(uid__in=uid_list).delete()
                # Order_Model.objects.filter(UID__in=uid_list).delete()
                StsCrdModel.objects.filter(uid__in=uid_list).delete()
                VodHlsModel.objects.filter(uid__in=uid_list).delete()
                # 删除vod_hls分表数据
                split_vod_hls_obj = SplitVodHlsObject()
                split_vod_hls_obj.del_vod_hls_data(uid__in=uid_list)
                ExperienceContextModel.objects.filter(uid__in=uid_list).delete()

                # 重置AI
                ExperienceAiModel.objects.filter(uid__in=uid_list).delete()
                AiService.objects.filter(uid__in=uid_list).delete()

                # 写入未使用序列号redis列表
                redis_obj.rpush_list(UNUSED_SERIAL_REDIS_LIST, serial_list)

                # 重置region_id,不为美洲服,则写入redis列表
                if CONFIG_INFO == CONFIG_US:
                    DeviceDomainRegionModel.objects.filter(serial_number__in=serial_list).update(region_id=0)
                else:
                    redis_obj.rpush_list(RESET_REGION_ID_SERIAL_REDIS_LIST, serial_list)

                # 重置已使用的uid的使用状态为未使用,更新时间
                UIDModel.objects.filter(uid__in=uid_list, status=2).update(status=0, mac='', update_time=now_time)

                # 重置扫码记录
                AppScannedSerial.objects.filter(serial__in=serial_list).delete()

                # 记录操作日志
                end_time = int(time.time())
                log = {
                    'user_id': 1,
                    'status': 200,
                    'time': now_time,
                    'url': 'cron/update/deleteUidData',
                    'operation': '已解绑序列号{}清除uid{}成功,执行时间{}秒'.format(serial_list, uid_list, end_time-now_time)
                }
                LogModel.objects.create(**log)

            return response.json(0)
        except Exception as e:
            # 记录操作日志
            log = {
                'user_id': 1,
                'status': 200,
                'time': now_time,
                'url': 'cron/update/deleteUidData',
                'operation': '已解绑序列号{}清除uid{}异常:{}'.format(serial_list, uid_list, repr(e))
            }
            LogModel.objects.create(**log)
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def reset_region_id(request_dict, response):
        """
        重置地区id
        @param request_dict: 请求参数
        @request_dict serial_redis_list: 序列号redis列表
        @param response: 响应对象
        """
        serial_redis_list = request_dict.get('serial_redis_list', None)
        LOGGER.info('---重置地区id参数---serial_redis_list:{}'.format(serial_redis_list))
        if not serial_redis_list:
            return response.json(444)
        try:
            serial_redis_list = eval(serial_redis_list)
            DeviceDomainRegionModel.objects.filter(serial_number__in=serial_redis_list).update(region_id=0)
            return response.json(0)
        except Exception as e:
            LOGGER.info('---重置地区id异常---:{}'.format(repr(e)))
            return response.json(500)

    @staticmethod
    def update_vod_meal(request_dict, response):
        """
        定时修改体验套餐有效期为1个月
        @param request_dict: 请求参数
        @param response: 响应对象
        """
        try:
            Store_Meal.objects.filter(is_show=0, expire=12, pixel_level=0).update(price='39.99',
                                                                                  virtual_price='56.6',
                                                                                  sort=1)
            Store_Meal.objects.filter(is_show=0, cycle_config_id=1, pixel_level=0).update(price='3.65',
                                                                                          virtual_price='5.66',
                                                                                          sort=2)
            Store_Meal.objects.filter(id=12).update(price='3.99', virtual_price='5.66', sort=3)
            Store_Meal.objects.filter(id__in=(16, 17, 18)).update(is_show=0)
            return response.json(0)
        except Exception as e:
            LOGGER.info('---修改云存套餐内容异常---:{}'.format(repr(e)))
            return response.json(500)

    @staticmethod
    def check_customized_push(response):
        try:
            now_time = int(time.time())
            # 查询推送时间小于当前时间且推送状态为待推送的数据
            customized_push_qs = CustomizedPush.objects.filter(push_timestamp__lt=now_time, push_satus=0).values('id')
            if customized_push_qs.exists():
                for customized_push in customized_push_qs:
                    customized_push_id = customized_push['id']
                    data = {'customized_push_id': customized_push_id}
                    url = DETECT_PUSH_DOMAINS + 'customized_push/start'
                    req = requests.post(url=url, data=data, timeout=8)
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))


class CronCollectDataView(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 == 'collectPlayBack':  # 定时保存云存视频回放
            return self.collect_play_back(response)
        elif operation == 'collectDeviceUser':  # 定时保存用户数据
            return self.collect_device_user(response)
        elif operation == 'collectActivityUser':  # 定时保存用户数据
            return self.collect_activity_user(response)
        elif operation == 'collectOrder':  # 定时保存订单数据
            return self.collect_order(response)
        elif operation == 'collectDeviceInfo':  # 定时保存设备数据
            return self.collect_device_info(response)
        elif operation == 'collectFlowInfo':  # 定时保存设备数据
            return self.collect_flow_info(response)
        elif operation == 'collectOperatingCosts':  # 定时运营成本
            return self.collect_operating_costs(response)
        elif operation == 'collectObjSize':  # 定时设备s3存储量
            return self.collect_obj_size(response)
        elif operation == 'checkRequest':  # 定时检查各个服的https请求
            return self.check_request(response)
        else:
            return response.json(404)

    @staticmethod
    def collect_play_back(response):
        try:
            now_time = int(time.time())
            today = datetime.datetime.today()
            start_time = datetime.datetime(today.year, today.month, today.day)
            end_time = start_time + datetime.timedelta(days=1)
            start_time = CommonService.str_to_timestamp(start_time.strftime('%Y-%m-%d %H:%M:%S'))
            end_time = CommonService.str_to_timestamp(end_time.strftime('%Y-%m-%d %H:%M:%S'))
            this_month_str = datetime.datetime(today.year, today.month, 1)
            this_month_stamp = CommonService.str_to_timestamp(this_month_str.strftime('%Y-%m-%d %H:%M:%S'))
            video_play_back_time_qs = VideoPlaybackTimeModel.objects.filter(startTime__gte=start_time,
                                                                            startTime__lt=end_time,
                                                                            playMode='cloud').values('uid').annotate(
                play_duration=Sum('duration'), play_frequency=Count('uid'))
            with transaction.atomic():
                for item in video_play_back_time_qs:
                    vod_hls_summary_qs = VodHlsSummary.objects.filter(uid=item['uid'], time=this_month_stamp)
                    if vod_hls_summary_qs.exists():
                        vod_hls_summary = vod_hls_summary_qs.first()
                        vod_hls_summary.play_duration += item['play_duration']
                        vod_hls_summary.play_frequency += 1
                        vod_hls_summary.updated_time = now_time
                        vod_hls_summary.save()
                    else:
                        VodHlsSummary.objects.create(uid=item['uid'], time=this_month_stamp, created_time=now_time,
                                                     play_duration=item['play_duration'], play_frequency=1,
                                                     updated_time=now_time)

            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def collect_device_user(response):
        try:
            created_time = int(time.time())
            today = datetime.datetime.today()
            start_time = datetime.datetime(today.year, today.month, today.day)
            end_time = start_time + datetime.timedelta(days=1)
            increase_user_qs = Device_User.objects.filter(data_joined__year=today.year, data_joined__month=today.month,
                                                          data_joined__day=today.day).values('region_country')
            start_time = CommonService.str_to_timestamp(start_time.strftime('%Y-%m-%d %H:%M:%S'))
            end_time = CommonService.str_to_timestamp(end_time.strftime('%Y-%m-%d %H:%M:%S'))
            active_user_qs = UserExModel.objects.filter(updTime__gte=start_time, updTime__lt=end_time).values(
                'userID__region_country')
            country_qs = CountryModel.objects.all().values('id', 'region__name', 'country_name')
            country_dict = {}
            continent_dict = {}
            for item in country_qs:
                country_dict[item['id']] = item['country_name']
                continent_dict[item['country_name']] = item['region__name']
            with transaction.atomic():
                if increase_user_qs.exists():
                    increase_user_count = increase_user_qs.count()
                    increase_user_country_list = increase_user_qs.values('region_country').annotate(
                        count=Count('region_country')).order_by('count')
                    increase_user_country_dict = {}
                    increase_user_continent_dict = {}
                    for item in increase_user_country_list:
                        country_name = country_dict.get(item['region_country'], '未知国家')
                        continent_name = continent_dict.get(country_name, '未知大洲')
                        increase_user_country_dict[country_name] = item['count']
                        if continent_name not in increase_user_continent_dict:
                            increase_user_continent_dict[continent_name] = 0
                        increase_user_continent_dict[continent_name] += item['count']
                    DeviceUserSummary.objects.create(time=start_time, count=increase_user_count,
                                                     country=increase_user_country_dict, created_time=created_time,
                                                     continent=increase_user_continent_dict)
                if active_user_qs.exists():
                    active_user_count = active_user_qs.count()
                    active_user_country_list = active_user_qs.values('userID__region_country').annotate(
                        count=Count('userID__region_country')).order_by('count')
                    active_user_country_dict = {}
                    active_user_continent_dict = {}
                    for item in active_user_country_list:
                        country_name = country_dict.get(item['userID__region_country'], '未知国家')
                        continent_name = continent_dict.get(country_name, '未知大洲')
                        active_user_country_dict[country_name] = item['count']
                        if continent_name not in active_user_continent_dict:
                            active_user_continent_dict[continent_name] = 0
                        active_user_continent_dict[continent_name] += item['count']
                    user_qs = DeviceUserSummary.objects.filter(time=start_time, query_type=1)
                    if user_qs.exists():
                        user_qs.update(count=active_user_count, country=active_user_country_dict,
                                       continent=active_user_continent_dict)
                    else:
                        DeviceUserSummary.objects.create(time=start_time, query_type=1, count=active_user_count,
                                                         country=active_user_country_dict, created_time=created_time,
                                                         continent=active_user_continent_dict)

            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def collect_order(response):
        try:
            created_time = int(time.time())
            today = datetime.datetime.today()
            start_time = datetime.datetime(today.year, today.month, today.day)
            end_time = start_time + datetime.timedelta(days=1)
            start_time = CommonService.str_to_timestamp(start_time.strftime('%Y-%m-%d %H:%M:%S'))
            end_time = CommonService.str_to_timestamp(end_time.strftime('%Y-%m-%d %H:%M:%S'))
            order_qs = Order_Model.objects.filter(addTime__gte=start_time, addTime__lt=end_time,
                                                  status=1).values('UID', 'order_type',
                                                                   'store_meal_name', 'price',
                                                                   'addTime', 'currency').order_by(
                'addTime')
            uid_list = []
            all_order_qs = Order_Model.objects.filter(addTime__lt=start_time, status=1).values('UID')
            for item in all_order_qs:
                if item['UID'] not in uid_list:
                    uid_list.append(item['UID'])
            # 国家表数据
            country_qs = CountryModel.objects.values('id', 'country_name')
            country_dict = {}
            for item in country_qs:
                country_dict[item['id']] = item['country_name']
            # 设备类型数据
            device_type_qs = DeviceTypeModel.objects.values('name', 'type')
            device_type_dict = {}
            for item in device_type_qs:
                device_type_dict[item['type']] = item['name']

            with transaction.atomic():
                for item in order_qs:
                    is_pay = 0
                    price = float(item['price'])
                    currency = item['currency']
                    uid_set_qs = UidSetModel.objects.filter(uid=item['UID']).values('tb_country')
                    country_id = uid_set_qs[0]['tb_country'] if uid_set_qs.exists() else 0
                    country_name = country_dict.get(country_id, '未知国家')
                    order_type = item['order_type']
                    device_info_qs = Device_Info.objects.filter(UID=item['UID']).values('Type')
                    device_type_id = device_info_qs[0]['Type'] if device_info_qs.exists() else 0
                    device_type_name = device_type_dict.get(device_type_id, '未知设备')
                    store_meal_name = item['store_meal_name']
                    add_time_stamp = item['addTime']
                    add_time_str = datetime.datetime.fromtimestamp(int(add_time_stamp))
                    add_time_str = datetime.datetime(add_time_str.year, add_time_str.month, add_time_str.day)
                    add_time_stamp = CommonService.str_to_timestamp(add_time_str.strftime('%Y-%m-%d %H:%M:%S'))
                    if price == 0:
                        is_pay = 1
                        order_summary_qs = OrdersSummary.objects.filter(time=add_time_stamp, query_type=1,
                                                                        service_type=order_type)
                    else:
                        order_summary_qs = OrdersSummary.objects.filter(time=add_time_stamp, query_type=0,
                                                                        service_type=order_type)
                        if item['UID'] not in uid_list:
                            pay_order_summary_qs = OrdersSummary.objects.filter(time=add_time_stamp, query_type=2,
                                                                                service_type=order_type)
                            query_type = 2
                        else:
                            pay_order_summary_qs = OrdersSummary.objects.filter(time=add_time_stamp, query_type=3,
                                                                                service_type=order_type)
                            query_type = 3
                        if pay_order_summary_qs.exists():
                            pay_order_summary = pay_order_summary_qs.first()
                            pay_order_summary.count += 1
                            temp_total = eval(pay_order_summary.total)
                            if currency not in temp_total:
                                temp_total[currency] = price
                            else:
                                temp_total[currency] = round(temp_total[currency] + price, 2)
                            pay_order_summary.total = temp_total
                            country_temp_dict = eval(pay_order_summary.country)
                            if country_name in country_temp_dict:
                                country_temp_dict[country_name]['数量'] += 1
                                if currency not in country_temp_dict[country_name]:
                                    country_temp_dict[country_name][currency] = price
                                else:
                                    country_temp_dict[country_name][currency] = round(
                                        country_temp_dict[country_name][currency] + price, 2)
                            else:
                                country_temp_dict[country_name] = {'数量': 1, currency: price}
                            pay_order_summary.country = country_temp_dict
                            device_type_temp_dict = eval(pay_order_summary.device_type)
                            if device_type_name in device_type_temp_dict:
                                device_type_temp_dict[device_type_name]['数量'] += 1
                                if currency not in device_type_temp_dict[device_type_name]:
                                    device_type_temp_dict[device_type_name][currency] = price
                                else:
                                    device_type_temp_dict[device_type_name][currency] = round(
                                        device_type_temp_dict[device_type_name][currency] + price, 2)
                            else:
                                device_type_temp_dict[device_type_name] = {'数量': 1, currency: price}
                            pay_order_summary.device_type = device_type_temp_dict
                            store_meal_temp_dict = eval(pay_order_summary.store_meal)
                            if store_meal_name in store_meal_temp_dict:
                                store_meal_temp_dict[store_meal_name]['数量'] += 1
                                if currency not in store_meal_temp_dict[store_meal_name]:
                                    store_meal_temp_dict[store_meal_name][currency] = price
                                else:
                                    store_meal_temp_dict[store_meal_name][currency] = round(
                                        store_meal_temp_dict[store_meal_name][currency] + price, 2)
                            else:
                                store_meal_temp_dict[store_meal_name] = {'数量': 1, currency: price}
                            pay_order_summary.store_meal = store_meal_temp_dict
                            pay_order_summary.save()
                        else:
                            final_total = {currency: price}
                            country_temp_dict = {
                                country_name: {
                                    '数量': 1,
                                    currency: price
                                }
                            }
                            device_type_temp_dict = {
                                device_type_name: {
                                    '数量': 1,
                                    currency: price
                                }
                            }
                            store_meal_temp_dict = {
                                store_meal_name: {
                                    '数量': 1,
                                    currency: price
                                }
                            }
                            OrdersSummary.objects.create(time=add_time_stamp, count=1, query_type=query_type,
                                                         service_type=order_type, total=final_total,
                                                         country=country_temp_dict, created_time=created_time,
                                                         device_type=device_type_temp_dict,
                                                         store_meal=store_meal_temp_dict)
                    if order_summary_qs.exists():
                        order_summary = order_summary_qs.first()
                        order_summary.count += 1
                        temp_total = eval(order_summary.total)
                        if currency not in temp_total:
                            temp_total[currency] = price
                        else:
                            temp_total[currency] = round(temp_total[currency] + price, 2)
                        order_summary.total = temp_total
                        country_temp_dict = eval(order_summary.country)
                        if country_name in country_temp_dict:
                            if is_pay == 0:
                                country_temp_dict[country_name]['数量'] += 1
                                if currency not in country_temp_dict[country_name]:
                                    country_temp_dict[country_name][currency] = price
                                else:
                                    country_temp_dict[country_name][currency] = round(
                                        country_temp_dict[country_name][currency] + price, 2)
                            else:
                                country_temp_dict[country_name] += 1
                        else:
                            if is_pay == 0:
                                country_temp_dict[country_name] = {'数量': 1, currency: price}
                            else:
                                country_temp_dict[country_name] = 1
                        order_summary.country = country_temp_dict
                        device_type_temp_dict = eval(order_summary.device_type)
                        if device_type_name in device_type_temp_dict:
                            if is_pay == 0:
                                device_type_temp_dict[device_type_name]['数量'] += 1
                                if currency not in device_type_temp_dict[device_type_name]:
                                    device_type_temp_dict[device_type_name][currency] = price
                                else:

                                    device_type_temp_dict[device_type_name][currency] = round(
                                        device_type_temp_dict[device_type_name][currency] + price, 2)
                            else:
                                device_type_temp_dict[device_type_name] += 1
                        else:
                            if is_pay == 0:
                                device_type_temp_dict[device_type_name] = {'数量': 1, currency: price}
                            else:
                                device_type_temp_dict[device_type_name] = 1
                        order_summary.device_type = device_type_temp_dict
                        store_meal_temp_dict = eval(order_summary.store_meal)
                        if store_meal_name in store_meal_temp_dict:
                            if is_pay == 0:
                                store_meal_temp_dict[store_meal_name]['数量'] += 1
                                if currency not in store_meal_temp_dict[store_meal_name]:
                                    store_meal_temp_dict[store_meal_name][currency] = price
                                else:
                                    store_meal_temp_dict[store_meal_name][currency] = round(
                                        store_meal_temp_dict[store_meal_name][currency] + price, 2)
                            else:
                                store_meal_temp_dict[store_meal_name] += 1
                        else:
                            if is_pay == 0:
                                store_meal_temp_dict[store_meal_name] = {'数量': 1, currency: price}
                            else:
                                store_meal_temp_dict[store_meal_name] = 1
                        order_summary.store_meal = store_meal_temp_dict
                        order_summary.save()
                    else:
                        final_total = {currency: price}
                        if is_pay == 0:
                            country_temp_dict = {
                                country_name: {
                                    '数量': 1,
                                    currency: price
                                }
                            }
                            device_type_temp_dict = {
                                device_type_name: {
                                    '数量': 1,
                                    currency: price
                                }
                            }
                            store_meal_temp_dict = {
                                store_meal_name: {
                                    '数量': 1,
                                    currency: price
                                }
                            }
                        else:
                            device_type_temp_dict = {
                                device_type_name: 1
                            }
                            store_meal_temp_dict = {
                                store_meal_name: 1
                            }
                            country_temp_dict = {
                                country_name: 1
                            }
                        OrdersSummary.objects.create(time=add_time_stamp, count=1, query_type=is_pay,
                                                     service_type=order_type, total=final_total,
                                                     country=country_temp_dict, created_time=created_time,
                                                     device_type=device_type_temp_dict, store_meal=store_meal_temp_dict)
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def collect_operating_costs(response):
        try:
            today = datetime.datetime.today()
            end_time = datetime.datetime(today.year, today.month, today.day)
            yesterday = end_time - datetime.timedelta(days=1)
            start_time = datetime.datetime(yesterday.year, yesterday.month, 1)
            start_time_stamp = int(start_time.timestamp())
            end_time_stamp = int(end_time.timestamp())
            thread = threading.Thread(target=CronCollectDataView.thread_collect_operating_costs,
                                      args=(start_time_stamp, end_time_stamp, start_time, end_time))
            thread.start()  # 启动线程
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def thread_collect_operating_costs(start_time_stamp, end_time_stamp, start_time, end_time):
        try:
            create_time = int(time.time())
            today_end_time = end_time_stamp + 86400
            operating_costs_qs_1 = OperatingCosts.objects.filter(time=start_time_stamp).exclude(
                created_time__gte=end_time_stamp, created_time__lt=today_end_time).values('order_id', 'end_time', 'uid')
            operating_costs_qs_2 = OperatingCosts.objects.filter(time=start_time_stamp,
                                                                 created_time__gte=end_time_stamp,
                                                                 created_time__lt=today_end_time, start_time=0).values(
                'order_id', 'end_time', 'uid')
            operating_costs_qs = operating_costs_qs_1.union(operating_costs_qs_2)
            storage_univalence = 0.023 / 30
            api_univalence = 0.005 / 1000
            region = '国内' if CONFIG_INFO == CONFIG_CN else '国外'
            country_qs = CountryModel.objects.values('id', 'country_name')
            country_dict = {}
            for item in country_qs:
                country_dict[item['id']] = item['country_name']
            for item in operating_costs_qs:
                order_qs = Order_Model.objects.filter(orderID=item['order_id'], order_type__in=[0, 1]).values('price',
                                                                                                              'payTime',
                                                                                                              'rank__expire',
                                                                                                              'fee',
                                                                                                              'payType',
                                                                                                              'userID__region_country')
                if order_qs.exists():
                    order = order_qs[0]
                    country_name = country_dict.get(order['userID__region_country'], '未知国家')
                    order_type = '云存'
                    expire = str(order_qs[0]['rank__expire']) + '个月'
                    price = float(order['price'])
                    if order['payType'] in [2, 3]:
                        fee = round(0.0054 * price, 2)
                    else:
                        fee = float(order['fee']) if order['fee'] else 0
                    order_start_time = int((datetime.datetime.fromtimestamp(item['end_time']) - relativedelta(
                        months=order['rank__expire'])).timestamp())
                    order_days = math.ceil((item['end_time'] - order_start_time) / 86400)
                    if item['end_time'] > end_time_stamp:  # 订单结束时间大于统计时间
                        if order_start_time <= start_time_stamp:  # 订单月初之前开始
                            settlement_days = (end_time - start_time).days  # 当月结算天数=月初-月底
                            uid_bucket_statistics = UidBucketStatistics.objects.filter(time__gte=start_time_stamp,
                                                                                       time__lte=end_time_stamp,
                                                                                       uid=item['uid'])
                        elif order_start_time >= end_time_stamp:  # 订单在统计时间之后开始
                            settlement_days = 1
                            uid_bucket_statistics = UidBucketStatistics.objects.filter(time__gte=end_time_stamp,
                                                                                       time__lt=order_start_time,
                                                                                       uid=item['uid'])
                        else:  # 订单月初和统计时间之间开始
                            settlement_days = math.ceil((end_time_stamp - order_start_time) / 86400)
                            uid_bucket_statistics = UidBucketStatistics.objects.filter(time__gte=order_start_time,
                                                                                       time__lte=end_time_stamp,
                                                                                       uid=item['uid'])
                        remaining_usage_time = math.ceil((item['end_time'] - end_time_stamp) / 86400)  # 剩余使用时间
                    else:  # 订单结束时间小于统计时间
                        if order_start_time <= start_time_stamp:
                            settlement_days = math.ceil((item['end_time'] - start_time_stamp) / 86400)
                            uid_bucket_statistics = UidBucketStatistics.objects.filter(time__gte=start_time_stamp,
                                                                                       time__lt=item['end_time'],
                                                                                       uid=item['uid'])
                        else:
                            settlement_days = math.ceil((item['end_time'] - order_start_time) / 86400)
                            uid_bucket_statistics = UidBucketStatistics.objects.filter(time__gte=order_start_time,
                                                                                       time__lt=item['end_time'],
                                                                                       uid=item['uid'])
                        remaining_usage_time = 0
                    day_average_price = round(price / order_days, 2)  # 收入分摊/天
                    month_average_price = round(day_average_price * settlement_days, 2)  # 收入分摊/月
                    monthly_income = round((price - fee) / order_days * settlement_days, 2)  # 当月结算收入
                    real_income = round(price - fee, 2)
                    result = uid_bucket_statistics.aggregate(size=Sum('storage_size'), api_count=Sum('api_count'))
                    actual_storage = round(result['size'], 2) if result['size'] else 0
                    actual_api = result['api_count'] if result['api_count'] else 0
                    storage_cost = actual_storage / 1024 * storage_univalence * settlement_days
                    api_cost = actual_api * api_univalence
                    if CONFIG_INFO == CONFIG_CN:  # 国内要换算汇率
                        storage_cost = storage_cost * 7
                        api_cost = api_cost * 7
                    profit = round(monthly_income - storage_cost - api_cost, 2)  # 利润=月结算金额-月成本
                    storage_cost = round(storage_cost, 2)
                    api_cost = round(api_cost, 2)
                    if monthly_income == 0.0:
                        profit_margin = 0
                    else:
                        profit_margin = round(profit / month_average_price, 2)  # 利润率=利润/每月收入分摊
                    OperatingCosts.objects.filter(time=start_time_stamp, order_id=item['order_id'],
                                                  uid=item['uid']).update(day_average_price=day_average_price,
                                                                          month_average_price=month_average_price,
                                                                          monthly_income=monthly_income,
                                                                          actual_storage=actual_storage,
                                                                          settlement_days=settlement_days,
                                                                          actual_api=actual_api, fee=fee,
                                                                          created_time=create_time, region=region,
                                                                          start_time=order_start_time,
                                                                          remaining_usage_time=remaining_usage_time,
                                                                          storage_cost=storage_cost, api_cost=api_cost,
                                                                          profit=profit, profit_margin=profit_margin,
                                                                          real_income=real_income, price=price,
                                                                          country_name=country_name,
                                                                          order_type=order_type, expire=expire)
            print('结束')
        except Exception as e:
            LOGGER.info(
                'thread_collect_operating_costs接口异常：errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))


    @staticmethod
    def collect_obj_size(response):
        try:
            today = datetime.datetime.today()
            end_time = datetime.datetime(today.year, today.month, today.day)
            start_time = end_time - datetime.timedelta(days=1)
            first_date = datetime.datetime(start_time.year, start_time.month, 1)
            start_time_stamp = int(start_time.timestamp())
            end_time_stamp = int(end_time.timestamp())
            first_date_stamp = int(first_date.timestamp())
            thread = threading.Thread(target=CronCollectDataView.thread_collect_obj_size,
                                      args=(start_time_stamp, end_time_stamp, first_date_stamp))
            thread.start()  # 启动线程

            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def thread_collect_obj_size(start_time, end_time, first_date):
        try:
            creat_time = int(time.time())
            uid_list = UidBucketStatistics.objects.filter(time=start_time).values_list('uid', flat=True)
            uid_vod = UID_Bucket.objects.filter(Q(endTime__gte=start_time), ~Q(uid__in=uid_list)).values('uid',
                                                                                                         'bucket__bucket',
                                                                                                         'orderId',
                                                                                                         'channel',
                                                                                                         'endTime')
            s3_obj = AmazonS3Util(ACCESS_KEY_ID, SECRET_ACCESS_KEY, REGION_NAME)
            for item in uid_vod:
                path = '{uid}/vod{channel}'.format(uid=item['uid'], channel=item['channel'])
                s3_result = s3_obj.get_object_list(item['bucket__bucket'], path,
                                                   path + '/{}'.format(start_time), end_time)
                actual_storage = 0
                actual_api = 0
                for obj in s3_result:
                    temp_time = int(obj['Key'].split('/')[2])
                    if temp_time < end_time:
                        actual_storage += obj['Size']
                        actual_api += 1
                actual_storage = round(actual_storage / 1024 / 1024, 2)
                with transaction.atomic():
                    if actual_api:
                        UidBucketStatistics.objects.create(uid=item['uid'], storage_size=actual_storage,
                                                           api_count=actual_api,
                                                           created_time=creat_time,
                                                           time=start_time)
                    operating_costs_qs = OperatingCosts.objects.filter(order_id=item['orderId'], uid=item['uid'],
                                                                       time=first_date)
                    if not operating_costs_qs.exists():
                        OperatingCosts.objects.create(order_id=item['orderId'], uid=item['uid'],
                                                      created_time=creat_time, time=first_date,
                                                      end_time=item['endTime'])
                print(actual_storage, actual_api)
            print('结束')
        except Exception as e:
            LOGGER.info('统计s3信息异常：errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @classmethod
    def check_request(cls, response):
        domain_name_list = [
            'test.zositechc.cn', 'test.push.zositechc.cn',
            'www.zositechc.cn', 'api.loocam2.cn', 'common.neutral2.cn', 'api.aiotserver.cn', 'push.zositechc.cn',
            'www.dvema.com', 'api.zositech2.com', 'api.loocam2.com', 'common.neutral2.com', '149.neutral2.com',
            '365.neutral2.com', 'push.dvema.com',
            'www.zositeche.com', 'api.zositeche.com', 'api.loocam3.com', 'common.neutral3.com',
            'push.zositeche.com',
            'www.zositech.xyz', 'smart.loocam2.com'
        ]
        for domain_name in domain_name_list:
            thread = threading.Thread(target=cls.initial_request, args=(domain_name,))
            thread.start()
        return response.json(0)

    @staticmethod
    def initial_request(domain_name):
        url = 'https://{}/init/health-check'.format(domain_name)
        try:
            requests.post(url=url, timeout=30)
        except Exception as e:
            email_content = 'https请求域名{}出现异常!error_msg:{}'.format(domain_name, repr(e))
            S3Email().faEmail(email_content, 'servers@ansjer.com')

    @staticmethod
    def collect_device_info(response):
        try:
            created_time = int(time.time())
            today = datetime.datetime.today()
            start_time = datetime.datetime(today.year, today.month, today.day)
            end_time = start_time + datetime.timedelta(days=1)
            start_time = CommonService.str_to_timestamp(start_time.strftime('%Y-%m-%d %H:%M:%S'))
            end_time = CommonService.str_to_timestamp(end_time.strftime('%Y-%m-%d %H:%M:%S'))
            increase_device_qs = UidSetModel.objects.filter(addTime__gte=start_time, addTime__lt=end_time).values(
                'tb_country',
                'uid',
                'device_type',
                'cloud_vod',
                'is_ai',
                'mobile_4g',
                'addTime')
            video_play_back_time_qs = VideoPlaybackTimeModel.objects.filter(startTime__gte=start_time,
                                                                            startTime__lt=end_time).values('uid')
            active_device_qs = UidSetModel.objects.filter(uid__in=video_play_back_time_qs).values('tb_country',
                                                                                                  'addTime',
                                                                                                  'device_type',
                                                                                                  'cloud_vod',
                                                                                                  'is_ai',
                                                                                                  'mobile_4g',
                                                                                                  'uid')
            increase_device_count = increase_device_qs.count()
            active_device_count = active_device_qs.count()
            # 国家表数据
            country_qs = CountryModel.objects.values('id', 'country_name', 'region__name')
            country_dict = {}
            continent_dict = {}
            for item in country_qs:
                country_dict[item['id']] = item['country_name']
                continent_dict[item['country_name']] = item['region__name']
            # 设备类型数据
            device_type_qs = DeviceTypeModel.objects.values('name', 'type')
            device_type_dict = {}
            for item in device_type_qs:
                device_type_dict[item['type']] = item['name']
            with transaction.atomic():
                if increase_device_qs.exists():
                    # 国家大洲设备数据
                    increase_device_country_list = increase_device_qs.values('tb_country').annotate(
                        count=Count('tb_country')).order_by('count')
                    increase_device_country_dict = {}
                    increase_device_continent_dict = {}
                    for item in increase_device_country_list:
                        country_name = country_dict.get(item['tb_country'], '未知国家')
                        continent_name = continent_dict.get(country_name, '未知大洲')
                        increase_device_country_dict[country_name] = item['count']
                        if continent_name not in increase_device_continent_dict:
                            increase_device_continent_dict[continent_name] = 0
                        increase_device_continent_dict[continent_name] += item['count']
                    # 设备类型数据
                    increase_device_type_list = increase_device_qs.values('device_type').annotate(
                        count=Count('device_type')).order_by('count')
                    increase_device_type_dict = {}
                    for item in increase_device_type_list:
                        type_name = device_type_dict.get(item['device_type'], '未知设备类型')
                        increase_device_type_dict[type_name] = item['count']
                    # 云存设备类型数据
                    increase_device_vod_list = increase_device_qs.filter(~Q(cloud_vod=2)).values(
                        'device_type').annotate(
                        count=Count('device_type')).order_by('count')
                    increase_device_vod_dict = {}
                    for item in increase_device_vod_list:
                        type_name = device_type_dict.get(item['device_type'], '未知设备类型')
                        increase_device_vod_dict[type_name] = item['count']
                    # AI设备类型数据
                    increase_device_ai_list = increase_device_qs.filter(~Q(is_ai=2)).values('device_type').annotate(
                        count=Count('device_type')).order_by('count')
                    increase_device_ai_dict = {}
                    for item in increase_device_ai_list:
                        type_name = device_type_dict.get(item['device_type'], '未知设备类型')
                        increase_device_ai_dict[type_name] = item['count']
                    # 联通设备类型数据
                    increase_device_unicom_list = increase_device_qs.filter(~Q(mobile_4g=2)).values(
                        'device_type').annotate(
                        count=Count('device_type')).order_by('count')
                    increase_device_unicom_dict = {}
                    for item in increase_device_unicom_list:
                        type_name = device_type_dict.get(item['device_type'], '未知设备类型')
                        increase_device_unicom_dict[type_name] = item['count']
                    DeviceInfoSummary.objects.create(time=start_time, count=increase_device_count,
                                                     query_type=0, created_time=created_time,
                                                     country=increase_device_country_dict,
                                                     continent=increase_device_continent_dict,
                                                     vod_service=increase_device_vod_dict,
                                                     ai_service=increase_device_ai_dict,
                                                     unicom_service=increase_device_unicom_dict,
                                                     device_type=increase_device_type_dict)
                if active_device_qs.exists():
                    # 国家大洲设备数据
                    active_device_country_list = active_device_qs.values('tb_country').annotate(
                        count=Count('tb_country')).order_by('count')
                    active_device_country_dict = {}
                    active_device_continent_dict = {}
                    for item in active_device_country_list:
                        country_name = country_dict.get(item['tb_country'], '未知国家')
                        continent_name = continent_dict.get(country_name, '未知大洲')
                        active_device_country_dict[country_name] = item['count']
                        if continent_name not in active_device_continent_dict:
                            active_device_continent_dict[continent_name] = 0
                        active_device_continent_dict[continent_name] += item['count']
                    # 设备类型数据
                    active_device_type_list = active_device_qs.values('device_type').annotate(
                        count=Count('device_type')).order_by('count')
                    active_device_type_dict = {}
                    for item in active_device_type_list:
                        type_name = device_type_dict.get(item['device_type'], '未知设备类型')
                        active_device_type_dict[type_name] = item['count']
                    # 云存设备类型数据
                    active_device_vod_list = active_device_qs.filter(~Q(cloud_vod=2)).values('device_type').annotate(
                        count=Count('device_type')).order_by('count')
                    active_device_vod_dict = {}
                    for item in active_device_vod_list:
                        type_name = device_type_dict.get(item['device_type'], '未知设备类型')
                        active_device_vod_dict[type_name] = item['count']
                    # AI设备类型数据
                    active_device_ai_list = active_device_qs.filter(~Q(is_ai=2)).values('device_type').annotate(
                        count=Count('device_type')).order_by('count')
                    active_device_ai_dict = {}
                    for item in active_device_ai_list:
                        type_name = device_type_dict.get(item['device_type'], '未知设备类型')
                        active_device_ai_dict[type_name] = item['count']
                    # 联通设备类型数据
                    active_device_unicom_list = active_device_qs.filter(~Q(mobile_4g=2)).values('device_type').annotate(
                        count=Count('device_type')).order_by('count')
                    active_device_unicom_dict = {}
                    for item in active_device_unicom_list:
                        type_name = device_type_dict.get(item['device_type'], '未知设备类型')
                        active_device_unicom_dict[type_name] = item['count']
                    DeviceInfoSummary.objects.create(time=start_time, count=active_device_count,
                                                     query_type=1, created_time=created_time,
                                                     country=active_device_country_dict,
                                                     continent=active_device_continent_dict,
                                                     vod_service=active_device_vod_dict,
                                                     ai_service=active_device_ai_dict,
                                                     unicom_service=active_device_unicom_dict,
                                                     device_type=active_device_type_dict)

            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def collect_activity_user(response):
        try:
            created_time = int(time.time())
            today = datetime.datetime.today()
            start_time = datetime.datetime(today.year, today.month, today.day)
            end_time = start_time + datetime.timedelta(days=1)
            start_time = CommonService.str_to_timestamp(start_time.strftime('%Y-%m-%d %H:%M:%S'))
            end_time = CommonService.str_to_timestamp(end_time.strftime('%Y-%m-%d %H:%M:%S'))
            thread = threading.Thread(target=CronCollectDataView.thread_collect_activity_user,
                                      args=(start_time, end_time, created_time))
            thread.start()  # 启动线程
            return response.json(0)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def thread_collect_activity_user(start_time, end_time, created_time):
        try:
            active_uid = UserExModel.objects.filter(updTime__gte=start_time, updTime__lt=end_time).values_list(
                'userID__device_info__UID', flat=True).distinct()
            active_device_qs = UidSetModel.objects.filter(uid__in=active_uid).values('addTime', 'device_type', 'ucode')
            # 设备类型数据
            device_type_qs = DeviceTypeModel.objects.values('name', 'type')
            device_type_dict = {}
            for item in device_type_qs:
                device_type_dict[item['type']] = item['name']
            with transaction.atomic():
                if active_device_qs.exists():
                    # 按设备设备类型
                    active_device_type_list = active_device_qs.values('device_type').annotate(
                        count=Count('device_type')).order_by('count')
                    active_device_type_dict = {}
                    for item in active_device_type_list:
                        type_name = device_type_dict.get(item['device_type'], '未知设备类型')
                        active_device_type_dict[type_name] = item['count']
                    # 按ucode分类
                    active_ucode_list = active_device_qs.values('ucode').annotate(count=Count('ucode')).order_by('count')
                    active_ucode_dict = {}
                    for item in active_ucode_list:
                        ucode = item['ucode']
                        if item['ucode'] == '':
                            ucode = '未知ucode'
                        active_ucode_dict[ucode] = item['count']
                    user_qs = DeviceUserSummary.objects.filter(time=start_time, query_type=1)
                    if user_qs.exists():
                        user_qs.update(device_type=active_device_type_dict, ucode=active_ucode_dict)
                    else:
                        DeviceUserSummary.objects.create(time=start_time, query_type=1, created_time=created_time,
                                                         device_type=active_device_type_dict, ucode=active_ucode_dict)
        except Exception as e:
            LOGGER.info(
                'thread_collect_activity_user接口异常：errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno,
                                                                                      repr(e)))
    @staticmethod
    def collect_flow_info(response):
        try:
            unicom_qs = UnicomDeviceInfo.objects.filter(card_type=0).values('iccid').distinct().order_by('iccid')
            asy = threading.Thread(target=CronCollectDataView.thread_collect_flow, args=(unicom_qs,))
            asy.start()
            return response.json(0)
        except Exception as e:
            return response.json(500, repr(e))

    @staticmethod
    def thread_collect_flow(qs):
        try:
            unicom_api = UnicomObjeect()
            redis_obj = RedisObject()
            for item in qs:
                res = unicom_api.query_device_usage_history(**item)
                if res.status_code == 200:
                    res_json = res.json()
                    if res_json['code'] == 0:
                        redis_dict = {}
                        for data in res_json['data']['deviceUsageHistory']:
                            year = data.get('year', None)
                            month = data.get('month', None)
                            flow = data.get('flowTotalUsage', None)
                            if not all([year, month, flow]):
                                continue
                            file = str(year) + '-' + str(month)
                            redis_dict[file] = flow
                        key = 'monthly_flow_' + item['iccid']
                        if redis_dict:
                            redis_obj.set_hash_data(key, redis_dict)
        except Exception as e:
            LOGGER.info('统计联通流量失败，时间为：{}'.format(int(time.time())))


class CronComparedDataView(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 == 'PaypalOrder':  # 定时对比paypal订单
            return self.compared_paypal_order(request_dict, response)
        elif operation == 'WechatOrder':  # 定时对比微信订单
            return self.compared_wechat_order(response)
        elif operation == 'AlipayOrder':  # 定时对比阿里订单
            return self.compared_alipay_order(response)
        elif operation == 'AnsjerOrder':  # 定时对比后台订单
            return self.compared_ansjer_order(request_dict, response)
        else:
            return response.json(404)

    @staticmethod
    def compared_paypal_order(request_dict, response):
        time_stamp = request_dict.get('time', None)
        if time_stamp:
            end_date = datetime.datetime.fromtimestamp(int(time_stamp))
            start_date = end_date - datetime.timedelta(days=1)
        else:
            today = datetime.datetime.today()
            start_date = today - datetime.timedelta(days=2)
            start_date = datetime.datetime(start_date.year, start_date.month, start_date.day)
            end_date = start_date + datetime.timedelta(days=1)
        try:
            zosi_paypal_api = paypalrestsdk.Api(PAYPAL_CRD['Zosi'])
            vsees_paypal_api = paypalrestsdk.Api(PAYPAL_CRD['Vsees'])
            paypal_url = 'v1/reporting/transactions?start_date={}-{}-{}T08:00:00-0800&end_date={}-{}-{}T08:00:00-0800&fields=all&page_size=500&page=1&transaction_status=S'.format(
                start_date.year, start_date.month, start_date.day, end_date.year, end_date.month, end_date.day)
            zosi_order_list = zosi_paypal_api.get(paypal_url)
            vsees_order_list = vsees_paypal_api.get(paypal_url)
            order_list = zosi_order_list['transaction_details'] + vsees_order_list['transaction_details']
            # data = (
            #     ('start_date', '{}-{}-{}T08:00:00-0800'.format(start_date.year, start_date.month, start_date.day)),
            #     ('end_date', '{}-{}-{}T08:00:00-0800'.format(end_date.year, end_date.month, end_date.day)),
            #     ('fields', 'all'),
            #     ('page_size', '500'),
            #     ('page', '1'),
            #     ('transaction_status', 'S')
            # )
            # order_list = PayPalService(PAYPAL_CRD['client_id'], PAYPAL_CRD['client_secret']).get_transactions(data)
            thread = threading.Thread(target=CronComparedDataView.thread_compared_paypal_order,
                                      args=(order_list, end_date))
            thread.start()  # 启动线程
            return response.json(0)
        except Exception as e:
            LOGGER.info('CronComparedDataView.compared_paypal_order, errLine:{}, errMsg:{}'.format(
                e.__traceback__.tb_lineno, repr(e)))
            return response.json(500)

    @staticmethod
    def thread_compared_paypal_order(order_list, start_time):
        try:
            now_time = int(time.time())
            timestamp = int(start_time.timestamp())
            count = 0
            total = 0
            more_order_list = []
            for item in order_list:
                if 'custom_field' in item['transaction_info'] and item['transaction_info']['custom_field'] == 'Shopify':
                    continue
                count += 1
                total += float(item['transaction_info']['transaction_amount']['value'])
                trade_no = item['transaction_info']['transaction_id']
                if item['transaction_info']['transaction_event_code'] in ['T1106', 'T1107', 'T1202']:  # 付款退款
                    trade_no = item['transaction_info']['paypal_reference_id']
                transaction_subject = item['transaction_info'].get('transaction_subject', '')
                agreement_id = item['transaction_info'].get('paypal_reference_id', '')
                refund_order = False
                if item['transaction_info']['transaction_event_code'] in ['T1106', 'T1107', 'T1201', 'T0114', 'T1108']:
                    agreement_id = ''
                    if item['transaction_info']['transaction_event_code'] in ['T0114']:
                        transaction_subject = '争议费'
                    elif item['transaction_info']['transaction_event_code'] in ['T1108']:
                        transaction_subject = 'Fee reversal'
                    else:
                        refund_order = True
                        transaction_subject = '退款费'
                    more_order_list.append(trade_no)
                pay_time = int(datetime.datetime.strptime(item['transaction_info']['transaction_updated_date'],
                                                          "%Y-%m-%dT%H:%M:%S%z").timestamp())
                order_qs = Order_Model.objects.filter(trade_no=trade_no, payType=1)
                if not order_qs.exists():
                    order_dict = {
                        'trade_no': trade_no,
                        'agreement_id': agreement_id,
                        'pay_time': pay_time,
                        'username': item['payer_info'].get('email_address', ''),
                        'price': item['transaction_info']['transaction_amount']['value'],
                        'pay_type': 1,
                        'upd_time': now_time,
                        'status': 0,
                        'meal_name': transaction_subject
                    }
                    if agreement_id:
                        order_dict['pay_type'] = 0
                        order_dict['meal_name'] = 'paypal_cycle'
                        order_dict['order_id'] = transaction_subject
                    params = {'trade_no': trade_no, 'pay_time': pay_time, 'refund_order': refund_order}
                    response = requests.get('https://www.zositeche.com/testApi/checkOrderExist', params=params)
                    if response.status_code != 200:
                        # 如果响应失败，记录在数据库
                        abnormal_qs = AbnormalOrder.objects.filter(trade_no=trade_no)
                        if not abnormal_qs.exists():
                            AbnormalOrder.objects.create(**order_dict)
                        continue
                    result = response.json()
                    if result['result_code'] != 0 or not result['result']['is_exist']:
                        # 如果响应结果为空，记录在数据库
                        abnormal_qs = AbnormalOrder.objects.filter(trade_no=trade_no)
                        if not abnormal_qs.exists():
                            AbnormalOrder.objects.create(**order_dict)
                        more_order_list.append(trade_no)
                else:
                    if not refund_order:
                        order_qs.update(payTime=pay_time)
            total = round(total, 2)
            daily_reconciliation = DailyReconciliation.objects.filter(time=timestamp)
            if daily_reconciliation.exists():
                if daily_reconciliation.first().order_ids:
                    old_order_list = daily_reconciliation.first().order_ids.split(',')
                    more_order_list = list(set(old_order_list) | set(more_order_list))
                order_ids = ','.join(set(more_order_list))
                daily_reconciliation.update(paypal_num=count, paypal_total=total, upd_time=now_time,
                                            order_ids=order_ids)
            else:
                order_ids = ','.join(set(more_order_list))
                DailyReconciliation.objects.create(paypal_num=count, paypal_total=total, time=timestamp,
                                                   order_ids=order_ids, creat_time=now_time, upd_time=now_time)
        except Exception as e:
            LOGGER.info('paypal每日对账异常：errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def compared_wechat_order(response):
        today = datetime.datetime.today()
        start_date = today - datetime.timedelta(days=1)
        start_date = start_date.strftime("%Y%m%d")
        try:
            order_list = WechatPayObject().download_bill(start_date)
            thread = threading.Thread(target=CronComparedDataView.thread_compared_wechat_order,
                                      args=(order_list,))
            thread.start()
            return response.json(0)
        except Exception as e:
            LOGGER.info('CronComparedDataView.compared_wechat_order, errLine:{}, errMsg:{}'.format(
                e.__traceback__.tb_lineno, repr(e)))
            return response.json(500)

    @staticmethod
    def thread_compared_wechat_order(order_list):
        now_time = int(time.time())
        for order in order_list:
            if order['交易类型'] != '`APP':
                continue
            order_id = order['商户订单号'].replace('`', '')
            order_qs = Order_Model.objects.filter(orderID=order_id)
            if not order_qs.exists():
                order_dict = {
                    'trade_no': order['微信订单号'].replace('`', ''),
                    'order_id': order_id,
                    'pay_type': 3,
                    'price': order['订单金额'].replace('`', ''),
                    'pay_time': int(datetime.datetime.strptime(order['\ufeff交易时间'], "`%Y-%m-%d %H:%M:%S").timestamp()),
                    'upd_time': now_time,
                    'meal_name': order['商品名称'].replace('`', ''),
                }
                AbnormalOrder.objects.create(**order_dict)

    @staticmethod
    def compared_alipay_order(response):
        today = datetime.datetime.today()
        start_date = today - datetime.timedelta(days=1)
        start_date = start_date.strftime("%Y-%m-%d")
        try:
            ali_pay_obj = AliPayObject()
            alipay = ali_pay_obj.conf()
            result = alipay.server_api(
                api_name='alipay.data.dataservice.bill.downloadurl.query',
                biz_content={'bill_type': 'trade',
                             'bill_date': start_date,
                             }
            )
            res = requests.get(result['bill_download_url'])
            zip_file = res.content
            zip_data = io.BytesIO(zip_file)
            data = []
            with zipfile.ZipFile(zip_data, 'r') as zip_ref:
                for file in zip_ref.namelist():
                    if '汇总' not in file.encode('cp437').decode('gbk'):
                        with zip_ref.open(file) as f:
                            reader = csv.reader(io.TextIOWrapper(f, 'gbk'))
                            for row in reader:
                                data.append(row)
            key_list = data[4]
            orders = data[5:-4]
            order_list = []
            for item in orders:
                order_list.append(dict(zip(key_list, item)))
            thread = threading.Thread(target=CronComparedDataView.thread_compared_alipay_order,
                                      args=(order_list,))
            thread.start()
            return response.json(0)
        except Exception as e:
            LOGGER.info('CronComparedDataView.compared_alipay_order, errLine:{}, errMsg:{}'.format(
                e.__traceback__.tb_lineno, repr(e)))
            return response.json(500)

    @staticmethod
    def thread_compared_alipay_order(order_list):
        now_time = int(time.time())
        for order in order_list:
            order_id = order['商户订单号'].replace('\t', '')
            if len(order_id) != 20:
                continue
            order_qs = Order_Model.objects.filter(orderID=order_id)
            if not order_qs.exists():
                order_dict = {
                    'trade_no': order['支付宝交易号'].replace('\t', ''),
                    'order_id': order_id,
                    'pay_type': 2,
                    'price': order['订单金额（元）'].replace('\t', ''),
                    'pay_time': int(datetime.datetime.strptime(order['完成时间'], "%Y-%m-%d %H:%M:%S").timestamp()),
                    'upd_time': now_time,
                    'meal_name': order['商品名称'].replace('\t', ''),
                    'username': order['对方账户'].replace('\t', ''),
                }
                AbnormalOrder.objects.create(**order_dict)

    @staticmethod
    def compared_ansjer_order(request_dict, response):
        start_date_stamp = request_dict.get('time', None)
        end_time = request_dict.get('end_time', None)
        if start_date_stamp:
            start_date = datetime.datetime.fromtimestamp(int(start_date_stamp))
            end_date = start_date + datetime.timedelta(days=1)
            end_date_stamp = int(end_date.timestamp())
        else:
            today = datetime.datetime.today()
            start_date = today - datetime.timedelta(days=1)
            start_date = datetime.datetime(start_date.year, start_date.month, start_date.day)
            end_date = datetime.datetime(today.year, today.month, today.day)
            start_date_stamp = int(start_date.timestamp())
            end_date_stamp = int(end_date.timestamp())
        try:
            if end_time:
                end_date_stamp = end_time
            order_qs = Order_Model.objects.filter(status__in=[1, 5, 6], payType=1, payTime__gte=start_date_stamp,
                                                  payTime__lt=end_date_stamp).values('trade_no', 'orderID', 'UID',
                                                                                     'userID__username',
                                                                                     'userID__NickName', 'channel',
                                                                                     'desc', 'payType',
                                                                                     'price', 'status',
                                                                                     'refunded_amount', 'addTime',
                                                                                     'updTime', 'app_type')
            if CONFIG_INFO == CONFIG_EUR:
                return response.json(0, list(order_qs))
            thread = threading.Thread(target=CronComparedDataView.thread_compared_ansjer_order,
                                      args=(list(order_qs), start_date))
            thread.start()  # 启动线程
            return response.json(0)
        except Exception as e:
            LOGGER.info('CronComparedDataView.compared_ansjer_order, errLine:{}, errMsg:{}'.format(
                e.__traceback__.tb_lineno, repr(e)))
            return response.json(500)

    @staticmethod
    def thread_compared_ansjer_order(order_list, start_time):
        while True:
            response = requests.get('https://www.zositeche.com/cron/compared/AnsjerOrder',
                                    params={'time': int(start_time.timestamp())})
            if response.status_code == 200:
                result = response.json()
                if result['result_code'] == 0:
                    eur_order_list = result['result']
                    break
        try:
            begin_date = start_time - datetime.timedelta(days=15)
            end_date = start_time + datetime.timedelta(days=15)
            start_timestamp = int(start_time.timestamp())
            now_time = int(time.time())
            more_order_list = []
            total = 0
            all_order_list = order_list + eur_order_list
            count = len(all_order_list)
            zosi_paypal_api = paypalrestsdk.Api(PAYPAL_CRD['Zosi'])
            vsees_paypal_api = paypalrestsdk.Api(PAYPAL_CRD['Vsees'])
            for index, order in enumerate(all_order_list):
                total += float(order['price'])
                if not order['trade_no']:
                    more_order_list.append(order['orderID'])
                    continue
                if all_order_list.index(order) != index:
                    more_order_list.append(order['orderID'])
                    continue
                paypal_url = 'v1/reporting/transactions?start_date={}-{}-{}T00:00:00-0000&end_date={}-{}-{}T00:00:00-0000&transaction_id={}&fields=all&page_size=100&page=1'.format(
                    begin_date.year, begin_date.month, begin_date.day, end_date.year, end_date.month, end_date.day,
                    order['trade_no'])
                if order['app_type'] == 1:
                    paypal_order_list = zosi_paypal_api.get(paypal_url)
                elif order['app_type'] == 2:
                    paypal_order_list = vsees_paypal_api.get(paypal_url)
                else:
                    continue
                if not paypal_order_list['transaction_details']:
                    more_order_list.append(order['orderID'])
            total = round(total, 2)
            daily_reconciliation = DailyReconciliation.objects.filter(time=start_timestamp)
            if daily_reconciliation.exists():
                if daily_reconciliation.first().order_ids:
                    old_order_list = daily_reconciliation.first().order_ids.split(',')
                    more_order_list = list(set(old_order_list) | set(more_order_list))
                order_ids = ','.join(set(more_order_list))
                daily_reconciliation.update(ansjer_total=total, ansjer_num=count, order_ids=order_ids,
                                            upd_time=now_time)
            else:
                order_ids = ','.join(more_order_list)
                DailyReconciliation.objects.create(order_ids=order_ids, ansjer_total=total, ansjer_num=count,
                                                   time=start_timestamp, creat_time=now_time, upd_time=now_time)
        except Exception as e:
            LOGGER.info('后台每日对账异常：errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))