修改数据定时收集任务

Controller/Cron/CronTaskController.py

@@ -112,7 +112,7 @@ class CronDelDataView(View):
         try:
             with transaction.atomic():
                 month_ago_time = nowTime - 30 * 24 * 60 * 60  # 删除1个月前的数据
-                vod_hls_qs = VodHlsModel.objects.filter(endTime__lte=month_ago_time)
+                vod_hls_qs = VodHlsModel.objects.filter(endTime__lte=month_ago_time).order_by('endTime')
                 for vod_hls in vod_hls_qs:
                     end_time = vod_hls.endTime
                     end_time_str = datetime.datetime.fromtimestamp(int(end_time))
@@ -428,58 +428,39 @@ class CronCollectDataView(View):
                 country_dict[item['id']] = item['country_name']
                 continent_dict[item['country_name']] = item['region__name']
             with transaction.atomic():
-                for item in increase_user_qs:
-                    device_user_summary_qs = DeviceUserSummary.objects.filter(time=start_time, query_type=0)
-                    country_name = country_dict.get(item['region_country'], '未知国家')
-                    continent_name = continent_dict.get(country_name, '未知大洲')
-                    if device_user_summary_qs.exists():
-                        device_user_summary = device_user_summary_qs.first()
-                        country_temp_dict = eval(device_user_summary.country)
-                        continent_temp_dict = eval(device_user_summary.continent)
-                        if country_name in country_temp_dict:
-                            country_temp_dict[country_name] += 1
-                        else:
-                            country_temp_dict[country_name] = 1
-                        if continent_name in continent_temp_dict:
-                            continent_temp_dict[continent_name] += 1
-                        else:
-                            continent_temp_dict[continent_name] = 1
-                        device_user_summary.country = country_temp_dict
-                        device_user_summary.continent = continent_temp_dict
-                        device_user_summary.count += 1
-                        device_user_summary.save()
-                    else:
-                        country_temp_dict = {country_name: 1}
-                        continent_temp_dict = {continent_name: 1}
-                        DeviceUserSummary.objects.create(time=start_time, count=1,
-                                                         country=country_temp_dict,
-                                                         continent=continent_temp_dict)
-                for item in active_user_qs:
-                    device_user_summary_qs = DeviceUserSummary.objects.filter(time=start_time, query_type=1)
-                    country_name = country_dict.get(item['region_country'], '未知国家')
-                    continent_name = continent_dict.get(country_name, '未知大洲')
-                    if device_user_summary_qs.exists():
-                        device_user_summary = device_user_summary_qs.first()
-                        country_temp_dict = eval(device_user_summary.country)
-                        continent_temp_dict = eval(device_user_summary.continent)
-                        if country_name in country_temp_dict:
-                            country_temp_dict[country_name] += 1
-                        else:
-                            country_temp_dict[country_name] = 1
-                        if continent_name in continent_temp_dict:
-                            continent_temp_dict[continent_name] += 1
-                        else:
-                            continent_temp_dict[continent_name] = 1
-                        device_user_summary.country = country_temp_dict
-                        device_user_summary.continent = continent_temp_dict
-                        device_user_summary.count += 1
-                        device_user_summary.save()
-                    else:
-                        country_temp_dict = {country_name: 1}
-                        continent_temp_dict = {continent_name: 1}
-                        DeviceUserSummary.objects.create(time=start_time, query_type=1, count=1,
-                                                         country=country_temp_dict,
-                                                         continent=continent_temp_dict)
+                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,
+                                                     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('region_country').annotate(
+                        count=Count('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['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']
+                    DeviceUserSummary.objects.create(time=start_time, query_type=1, count=active_user_count,
+                                                     country=active_user_country_dict,
+                                                     continent=active_user_continent_dict)
 
             return response.json(0)
         except Exception as e:
@@ -679,6 +660,8 @@ class CronCollectDataView(View):
                                                                                                   '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 = {}
@@ -692,74 +675,104 @@ class CronCollectDataView(View):
             for item in device_type_qs:
                 device_type_dict[item['type']] = item['name']
             with transaction.atomic():
-                for index, each in enumerate([increase_device_qs, active_device_qs]):
-                    for item in each:
-                        time_stamp = item['addTime']
-                        time_str = datetime.datetime.fromtimestamp(int(time_stamp))
-                        this_day_str = datetime.datetime(time_str.year, time_str.month, time_str.day)
-                        this_day_stamp = CommonService.str_to_timestamp(this_day_str.strftime('%Y-%m-%d %H:%M:%S'))
-                        device_info_summary_qs = DeviceInfoSummary.objects.filter(time=this_day_stamp, query_type=index)
+                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, '未知大洲')
-                        device_type_name = device_type_dict.get(item['device_type'], '未知设备类型')
-                        if device_info_summary_qs.exists():
-                            device_info_summary = device_info_summary_qs.first()
-                            country_temp_dict = eval(device_info_summary.country)
-                            continent_temp_dict = eval(device_info_summary.continent)
-                            vod_service_temp_dict = eval(device_info_summary.vod_service)
-                            device_type_temp_dict = eval(device_info_summary.device_type)
-                            ai_service_temp_dict = eval(device_info_summary.ai_service)
-                            unicom_service_temp_dict = eval(device_info_summary.unicom_service)
-                            if country_name in country_temp_dict:
-                                country_temp_dict[country_name] += 1
-                            else:
-                                country_temp_dict[country_name] = 1
-                            if continent_name in continent_temp_dict:
-                                continent_temp_dict[continent_name] += 1
-                            else:
-                                continent_temp_dict[continent_name] = 1
-                            if item['cloud_vod'] != 2:
-                                if device_type_name in vod_service_temp_dict:
-                                    vod_service_temp_dict[device_type_name] += 1
-                                else:
-                                    vod_service_temp_dict[device_type_name] = 1
-                            if item['is_ai'] != 2:
-                                if device_type_name in ai_service_temp_dict:
-                                    ai_service_temp_dict[device_type_name] += 1
-                                else:
-                                    ai_service_temp_dict[device_type_name] = 1
-                            if item['mobile_4g'] != 2:
-                                if device_type_name in unicom_service_temp_dict:
-                                    unicom_service_temp_dict[device_type_name] += 1
-                                else:
-                                    unicom_service_temp_dict[device_type_name] = 1
-                            if device_type_name in device_type_temp_dict:
-                                device_type_temp_dict[device_type_name] += 1
-                            else:
-                                device_type_temp_dict[device_type_name] = 1
-                            device_info_summary.country = country_temp_dict
-                            device_info_summary.continent = continent_temp_dict
-                            device_info_summary.vod_service = vod_service_temp_dict
-                            device_info_summary.ai_service = ai_service_temp_dict
-                            device_info_summary.unicom_service = unicom_service_temp_dict
-                            device_info_summary.device_type = device_type_temp_dict
-                            device_info_summary.count += 1
-                            device_info_summary.save()
-                        else:
-                            country_temp_dict = {country_name: 1}
-                            continent_temp_dict = {continent_name: 1}
-                            vod_service_temp_dict = {device_type_name: 1} if item['cloud_vod'] != 2 else {}
-                            ai_service_temp_dict = {device_type_name: 1} if item['is_ai'] != 2 else {}
-                            unicom_service_temp_dict = {device_type_name: 1} if item['mobile_4g'] != 2 else {}
-                            device_type_temp_dict = {device_type_name: 1}
-                            DeviceInfoSummary.objects.create(time=this_day_stamp, count=1,
-                                                             query_type=index,
-                                                             country=country_temp_dict,
-                                                             continent=continent_temp_dict,
-                                                             vod_service=vod_service_temp_dict,
-                                                             ai_service=ai_service_temp_dict,
-                                                             unicom_service=unicom_service_temp_dict,
-                                                             device_type=device_type_temp_dict)
+                        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,
+                                                     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,
+                                                     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:

Controller/UserController.py

@@ -1513,7 +1513,7 @@ class v2forgetPwdCodeView(TemplateView):
             if send_res is not True:
                 reds.del_data(key=email + '_forgetPwdResetCode')
                 res['Message'] = '发送邮件失败'
-                return response.json(44)
+                return response.json(44, res)
         else:
             number = int(number)
             if number != region_country and region_country != 0:
@@ -1526,15 +1526,9 @@ class v2forgetPwdCodeView(TemplateView):
                 if send_res is not True:
                     reds.del_data(key=email + '_forgetPwdResetCode')
                     res['Message'] = '发送邮件失败'
-                    return response.json(44)
+                    return response.json(44, res)
 
-        # send_res = ses.send_email(send_address_list=[email], subject=send_data['title'], body=send_body)
-        # 阿里云发送邮箱
-        send_res = ses.alyEmailCode(send_address_list=[email], subject=send_data['title'], body=send_body)
-        if send_res is not True:
-            reds.del_data(key=email + '_forgetPwdResetCode')
-            return response.json(44)
-        return response.json(0)
+        return response.json(0, res)
 
 
 # 忘记密码v2