优化内部数据（设备数据统计）接口

AdminController/dataSystemManagement/DeviceDataController.py

@@ -324,33 +324,38 @@ class DeviceDataView(View):
         e_time = datetime.datetime.fromtimestamp(int(end_time))
         time_list = CommonService.cutting_time(s_time, e_time, unit_time)
         try:
-            video_playback_time_qs = VideoPlaybackTimeModel.objects.filter(startTime__range=(start_time, end_time))
+            # video_playback_time_qs = VideoPlaybackTimeModel.objects.filter(
+            #     startTime__range=(start_time, end_time)).values('uid', 'startTime')
+            video_playback_time_qs = VideoPlaybackTimeModel.objects.filter(
+                     startTime__range=(start_time, end_time)).values('uid').order_by('uid').distinct()
             null_list = []
             if not video_playback_time_qs.exists():
                 return response.json(0, null_list)
-            video_playback_uid_qs = video_playback_time_qs.values('uid').order_by('uid').distinct()
+            count_all = video_playback_time_qs.count()
+            # video_playback_uid_qs = video_playback_time_qs.values('uid').order_by('uid').distinct()
             res = {}
             video_list = []
             region_list = []
             for item in time_list:
-                video_playback_qs = video_playback_time_qs.filter(startTime__range=(item[0], item[1]))
-                uid_qs = video_playback_qs.values('uid').order_by('uid').distinct()
-                rate = round(uid_qs.count() / video_playback_uid_qs.count() * 100, 2)
+                video_playback_qs = video_playback_time_qs.filter(startTime__range=(item[0], item[1])).values(
+                    'uid').order_by('uid').distinct()
+                # uid_qs = video_playback_qs.values('uid').order_by('uid').distinct()
+                rate = round(video_playback_qs.count() / count_all * 100, 2)
                 vod_dict = {
-                    'count': uid_qs.count(),
+                    'count': video_playback_qs.count(),
                     'rate': rate,
                     'startTime': item[0],
                     'endTime': item[1]
                 }
                 video_list.append(vod_dict)
             res['vodHls'] = video_list
-            type_country_qs = UidSetModel.objects.filter(uid__in=video_playback_uid_qs.values('uid')).values(
+            type_country_qs = UidSetModel.objects.filter(uid__in=video_playback_time_qs.values('uid')).values(
                 'tb_country').annotate(count=Count('tb_country')).order_by('-count')
             for type_country in type_country_qs:
                 country_id = type_country['tb_country']
                 country_name_qs = CountryModel.objects.filter(id=country_id).values('country_name')
                 country_name = country_name_qs[0]['country_name'] if country_name_qs.exists() else '未知区域'
-                rate = round(type_country['count'] / video_playback_uid_qs.count() * 100, 2)
+                rate = round(type_country['count'] / count_all * 100, 2)
                 country_dict = {
                     'countryName': country_name,
                     'count': type_country['count'],
@@ -378,7 +383,7 @@ class DeviceDataView(View):
         if not all([start_time, end_time, unit_time]):
             return response.json(444, {'error param': 'startTime or endTime or timeUnit'})
         try:
-            uid_set_qs = UidSetModel.objects.filter(addTime__range=(start_time, end_time))
+            uid_set_qs = UidSetModel.objects.filter(addTime__range=(start_time, end_time)).values('uid','tb_country')
             null_list = []
             if not uid_set_qs.exists():
                 return response.json(0, null_list)
@@ -399,38 +404,36 @@ class DeviceDataView(View):
             end_time = datetime.datetime.fromtimestamp(int(end_time))
             time_list = CommonService.cutting_time(start_time, end_time, unit_time)
             for item in time_list:
-                deivce_uid_qs = uid_set_qs.filter(addTime__range=(item[0], item[1]))
-                count_part = deivce_uid_qs.count()
-                rate = round(count_part / count_all * 100, 2)
+                deivce_uid_qs = uid_set_qs.filter(addTime__range=(item[0], item[1])).count()
+                rate = round(deivce_uid_qs / count_all * 100, 2)
                 info_dict = {
                     'startTime': item[0],
                     'endTime': item[1],
-                    'count': count_part,
+                    'count': deivce_uid_qs,
                     'rate': rate
                 }
                 info_list.append(info_dict)
-                # 统计地区设备数量
+            res['addDevice'] = info_list
+            # 统计地区设备数量
             device_info_country_qs = uid_set_qs.values('tb_country').annotate(
                 count=Count('tb_country')).order_by(
                 '-count')
-            country_qs = uid_set_qs.values('tb_country')
-            country_list = [item[key] for item in country_qs for key in item]
             for item in device_info_country_qs:
                 country_id = item['tb_country']
                 country_qs = CountryModel.objects.filter(id=country_id).values('country_name', 'id')
                 country_name = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
-                country_count = country_list.count(country_id)
-                rate = round(country_count / count_all * 100, 2)
+                rate = round(item['count'] / count_all * 100, 2)
                 country_dict = {
                     'countryName': country_name,
-                    'count': country_count,
+                    'count': item['count'],
                     'rate': rate
                 }
                 region_list.append(country_dict)
+            res['region'] = CommonService.list_sort(region_list)
             # 统计设备类型数量
             device_info_type_qs = Device_Info.objects.filter(UID__in=uid_qs.values('uid'))
             device_type_qs = device_info_type_qs.values('Type').annotate(
-                count=Count('Type', distinct=True)).order_by('-count').distinct()
+                count=Count('Type')).order_by('-count').distinct()
             name = '未知类型'
             count_remain = count_all - device_info_type_qs.count()
             rate = round(count_remain / count_all * 100, 2)
@@ -439,26 +442,22 @@ class DeviceDataView(View):
                 'count': count_remain,
                 'rate': rate
             })
-            type_qs = device_info_type_qs.values('Type')
-            device_type_list = [item[key] for item in type_qs for key in item]
             for device_type in device_type_qs:
                 Type = device_type['Type']
                 device_type_name_qs = DeviceTypeModel.objects.filter(type=Type).values('name')
                 name = device_type_name_qs[0]['name'] if device_type_name_qs.exists() else '未知类型'
-                type_count = device_type_list.count(Type)
-                rate = round(type_count / count_all * 100, 2)
+                rate = round(device_type['count'] / count_all * 100, 2)
                 type_list.append({
                     'type': name,
-                    'count': type_count,
+                    'count': device_type['count'],
                     'rate': rate
                 })
+            res['type'] = CommonService.list_sort(type_list)
             # 云存版本数量
             uid_cloud_qs = uid_set_qs.exclude(cloud_vod=2).values('uid')
             device_info_type_qs = Device_Info.objects.filter(UID__in=uid_cloud_qs.values('uid')).distinct()
             cloud_type_qs = device_info_type_qs.values('Type').annotate(
-                count=Count('Type', distinct=True)).order_by('-count').distinct()
-            type_qs = device_info_type_qs.values('Type')
-            test_list = [item[key] for item in type_qs for key in item]
+                count=Count('Type')).order_by('-count').distinct()
             count = uid_cloud_qs.count() - device_info_type_qs.count()
             name = '未知类型'
             rate = round(count / count_all * 100, 2)
@@ -471,16 +470,12 @@ class DeviceDataView(View):
                 Type = cloud_type['Type']
                 device_type_qs = DeviceTypeModel.objects.filter(type=Type).values('name')
                 name = device_type_qs[0]['name'] if device_type_qs.exists() else '未知类型'
-                type_count = test_list.count(Type)
-                rate = round(type_count / count_all * 100, 2)
+                rate = round(cloud_type['count'] / count_all * 100, 2)
                 version_list.append({
                     'type': name,
-                    'count': type_count,
+                    'count': cloud_type['count'],
                     'rate': rate
                 })
-            res['addDevice'] = info_list
-            res['region'] = CommonService.list_sort(region_list)
-            res['type'] = CommonService.list_sort(type_list)
             res['version'] = CommonService.list_sort(version_list)
 
             return response.json(0, res)
@@ -494,7 +489,7 @@ class DeviceDataView(View):
         统计地区设备数量
         @param response:响应对象
         """
-        uid_set_qs = UidSetModel.objects.all()
+        uid_set_qs = UidSetModel.objects.values('tb_country')
         if not uid_set_qs.exists():
             return response.json(444)
         tb_country_qs = uid_set_qs.values('tb_country').annotate(
@@ -510,25 +505,22 @@ class DeviceDataView(View):
                     name = country_qs[0]['country_name']
                 else:
                     name = '未知地区'
-                count = uid_set_qs.filter(
-                    tb_country=country_id).values('uid').annotate(
-                    count=Count('uid', distinct=True)).order_by('-count').count()
 
                 device_country_list.append({
                     'countryName': name,
-                    'count': count
+                    'count': device_country['count']
                 })
                 if country_qs.exists():
                     flag = 0
                     for each in continent_list:
                         if country_qs[0]['region__name'] == each['continentName']:
-                            each['count'] += count
+                            each['count'] += device_country['count']
                             flag = 1
                             break
                     if flag == 0:
                         continent_list.append({
                             'continentName': country_qs[0]['region__name'],
-                            'count': count
+                            'count': device_country['count']
                         })
             for item in continent_list:
                 item['rate'] = round(item['count'] / uid_set_qs.count() * 100, 2)