订单数据汇总、设备数据汇总

AdminController/dataSystemManagement/DeviceDataController.py

@@ -419,26 +419,43 @@ 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 = DeviceInfoSummary.objects.filter(time__range=(start_time, end_time), query_type=0)
-            res = {}
-            if not uid_set_qs.exists():
-                return response.json(0, res)
-            count_all = uid_set_qs.aggregate(total=Sum('count'))['total']
+            device_info_qs = DeviceInfoSummary.objects.filter(time__gte=start_time, time__lt=end_time,
+                                                              query_type=0).values(
+                'count', 'country', 'device_type', 'vod_service')
+            count_all = device_info_qs.aggregate(total=Sum('count'))['total']
+            count_all = count_all if count_all else 0
+            region_dict = {}
+            type_dict = {}
+            vod_dict = {}
+            for item in device_info_qs:
+                region_temp_dict = eval(item['country'])
+                type_temp_dict = eval(item['device_type'])
+                vod_temp_dict = eval(item['vod_service'])
+                for k, v in region_temp_dict.items():
+                    if k in region_dict:
+                        region_dict[k] += v
+                    else:
+                        region_dict[k] = v
+                for k, v in type_temp_dict.items():
+                    if k in type_dict:
+                        type_dict[k] += v
+                    else:
+                        type_dict[k] = v
+                for k, v in vod_temp_dict.items():
+                    if k in vod_dict:
+                        vod_dict[k] += v
+                    else:
+                        vod_dict[k] = v
             # 统计该时间段的设备数量（已去重）
             info_list = []
-            region_list = []
-            type_list = []
-            version_list = []
             start_time = datetime.datetime.fromtimestamp(int(start_time))
             end_time = datetime.datetime.fromtimestamp(int(end_time))
             time_list = CommonService.cutting_time(start_time, end_time, unit_time)
             for item in time_list:
-                device_uid_qs = uid_set_qs.filter(time__range=(item[0], item[1]), query_type=0)
-                if device_uid_qs.exists():
-                    count = device_uid_qs.aggregate(total=Sum('count'))['total']
-                else:
-                    count = device_uid_qs.count()
-                rate = round(count / count_all * 100, 2)
+                device_uid_qs = device_info_qs.filter(time__gte=item[0], time__lt=item[1])
+                count = device_uid_qs.aggregate(total=Sum('count'))['total']
+                count = count if count else 0
+                rate = round(count / count_all * 100, 2) if count_all else 0
                 info_dict = {
                     'startTime': item[0],
                     'endTime': item[1],
@@ -446,65 +463,39 @@ class DeviceDataView(View):
                     'rate': rate
                 }
                 info_list.append(info_dict)
-            res['addDevice'] = info_list
             # 统计地区设备数量
-            device_info_country_qs = uid_set_qs.values('country')
-            for item in device_info_country_qs:
-                country_temp_dict = eval(item['country'])
-                for x, y in country_temp_dict.items():
-                    flag = 0
-                    for each in region_list:
-                        if x == each['countryName']:
-                            each['count'] += y
-                            flag = 1
-                            break
-                    if flag == 0:
-                        region_list.append({
-                            'countryName': x,
-                            'count': y
-                        })
-            for item in region_list:
-                item['rate'] = round(item['count'] / count_all * 100, 2) if count_all else 0
-            res['region'] = CommonService.list_sort(region_list)
+            region_list = []
+            for x, y in region_dict.items():
+                rate = round(y / count_all * 100, 2) if count_all else 0
+                region_list.append({
+                    'countryName': x,
+                    'count': y,
+                    'rate': rate
+                })
             # 统计设备类型数量
-            device_type_qs = uid_set_qs.values('device_type')
-            for item in device_type_qs:
-                country_temp_dict = eval(item['device_type'])
-                for x, y in country_temp_dict.items():
-                    flag = 0
-                    for each in type_list:
-                        if x == each['type']:
-                            each['count'] += y
-                            flag = 1
-                            break
-                    if flag == 0:
-                        type_list.append({
-                            'type': x,
-                            'count': y
-                        })
-            for item in type_list:
-                item['rate'] = round(item['count'] / count_all * 100, 2) if count_all else 0
-            res['type'] = CommonService.list_sort(type_list)
+            type_list = []
+            for x, y in type_dict.items():
+                rate = round(y / count_all * 100, 2) if count_all else 0
+                type_list.append({
+                    'type': x,
+                    'count': y,
+                    'rate': rate
+                })
             # 云存版本数量
-            cloud_type_qs = uid_set_qs.values('vod_service')
-            for cloud_type in cloud_type_qs:
-                country_temp_dict = eval(cloud_type['vod_service'])
-                for x, y in country_temp_dict.items():
-                    flag = 0
-                    for each in version_list:
-                        if x == each['type']:
-                            each['count'] += y
-                            flag = 1
-                            break
-                    if flag == 0:
-                        version_list.append({
-                            'type': x,
-                            'count': y
-                        })
-            for item in version_list:
-                item['rate'] = round(item['count'] / count_all * 100, 2) if count_all else 0
-            res['version'] = CommonService.list_sort(version_list)
-
+            vod_list = []
+            for x, y in vod_dict.items():
+                rate = round(y / count_all * 100, 2) if count_all else 0
+                vod_list.append({
+                    'type': x,
+                    'count': y,
+                    'rate': rate
+                })
+            res = {
+                'addDevice': info_list,
+                'region': region_list,
+                'type': type_list,
+                'version': vod_list
+            }
             return response.json(0, res)
         except Exception as e:
             print(e)
@@ -517,8 +508,7 @@ class DeviceDataView(View):
         @param response:响应对象
         """
         all_device_qs = DeviceInfoSummary.objects.filter(query_type=0).values('continent', 'count', 'country')
-        if not all_device_qs.exists():
-            return response.json(173)
+
         country_count = all_device_qs.aggregate(total=Sum('count'))['total']
         res = {}
         try:

AdminController/dataSystemManagement/HomeDataController.py

@@ -15,7 +15,7 @@ from django.http import HttpResponse
 from django.utils.encoding import escape_uri_path
 from django.views.generic.base import View
 
-from Model.models import VideoPlaybackTimeModel, Device_User, Device_Info, Order_Model, CountryModel
+from Model.models import DeviceUserSummary, OrdersSummary, DeviceInfoSummary
 from Service.CommonService import CommonService
 
 
@@ -61,36 +61,85 @@ class HomeDataView(View):
         end_time_stamp = CommonService.str_to_timestamp(end_time.strftime('%Y-%m-%d %H:%M:%S'))
         start_time_stamp = CommonService.str_to_timestamp(start_time.strftime('%Y-%m-%d %H:%M:%S'))
         try:
-            user_increase_qs = Device_User.objects.filter(data_joined__range=(start_time, end_time))
-            user_increase_list = user_increase_qs.values('region_country').annotate(
-                count=Count('region_country')).order_by('-count')
-            for item in user_increase_list:
-                country_qs = CountryModel.objects.filter(id=item['region_country']).values('country_name')
-                item['countryName'] = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
-            user_increase_count = user_increase_qs.count()
-            user_active_count = Device_User.objects.filter(last_login__range=(start_time, end_time)).count()
-            user_all_qs = Device_User.objects.filter(data_joined__lte=end_time)
-            user_all_list = user_all_qs.values('region_country').annotate(
-                count=Count('region_country')).order_by('-count')
-            for item in user_all_list:
-                country_qs = CountryModel.objects.filter(id=item['region_country']).values('country_name')
-                item['countryName'] = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
-            user_all_count = user_all_qs.count()
-            device_increase_count = Device_Info.objects.filter(data_joined__range=(start_time, end_time)).values(
-                'UID').distinct().count()
-            device_active_count = VideoPlaybackTimeModel.objects.filter(
-                startTime__range=(start_time_stamp, end_time_stamp)).values('uid').distinct().count()
-            device_all_count = Device_Info.objects.filter(data_joined__lte=end_time).values('UID').distinct().count()
-            order_qs = Order_Model.objects.filter(status=1, addTime__range=(start_time_stamp, end_time_stamp))
-            order_total = order_qs.aggregate(total=Sum('price'))['total']
-            vod_order_total = order_qs.filter(order_type=0).aggregate(total=Sum('price'))['total']
-            ai_order_total = order_qs.filter(order_type=1).aggregate(total=Sum('price'))['total']
-            unicom_order_total = order_qs.filter(order_type=2).aggregate(total=Sum('price'))['total']
-            order_all_qs = Order_Model.objects.filter(status=1, addTime__lte=end_time_stamp)
-            order_all_total = order_all_qs.aggregate(total=Sum('price'))['total']
-            vod_order_all_total = order_all_qs.filter(order_type=0).aggregate(total=Sum('price'))['total']
-            ai_order_all_total = order_all_qs.filter(order_type=1).aggregate(total=Sum('price'))['total']
-            unicom_order_all_total = order_all_qs.filter(order_type=2).aggregate(total=Sum('price'))['total']
+            # 昨日用户增长数据
+            user_increase_qs = DeviceUserSummary.objects.filter(time__gte=start_time_stamp, time__lt=end_time_stamp,
+                                                                query_type=0).values('count', 'country')
+            user_increase_count = user_increase_qs.aggregate(count=Sum('count'))['count']
+            user_increase_count = user_increase_count if user_increase_count else 0
+            user_increase_region_dict = {}
+            user_increase_region_list = []
+            for item in user_increase_qs:
+                user_increase_region_temp_dict = eval(item['country'])
+                for k, v in user_increase_region_temp_dict.items():
+                    if k in user_increase_region_dict:
+                        user_increase_region_dict[k] += v
+                    else:
+                        user_increase_region_dict[k] = v
+            for k, v in user_increase_region_dict.items():
+                user_increase_region_list.append({k: v})
+
+            # 所有用户数据
+            user_all_qs = DeviceUserSummary.objects.filter(time__lte=start_time_stamp, query_type=0).values('count',
+                                                                                                            'country')
+            user_all_region_dict = {}
+            user_all_region_list = []
+            for item in user_all_qs:
+                user_all_region_temp_dict = eval(item['country'])
+                for k, v in user_all_region_temp_dict.items():
+                    if k in user_all_region_dict:
+                        user_all_region_dict[k] += v
+                    else:
+                        user_all_region_dict[k] = v
+            for k, v in user_all_region_dict.items():
+                user_all_region_list.append({k: v})
+            user_all_count = user_all_qs.aggregate(count=Sum('count'))['count']
+            user_all_count = user_all_count if user_all_count else 0
+            # 活跃用户数据
+            user_active_count = DeviceUserSummary.objects.filter(time__gte=start_time_stamp, time__lt=end_time_stamp,
+                                                                 query_type=1).aggregate(count=Sum('count'))['count']
+            user_active_count = round(user_active_count, 2) if user_active_count else 0
+            # 新增设备数据
+            device_increase_count = DeviceInfoSummary.objects.filter(time__gte=start_time_stamp,
+                                                                     time__lt=end_time_stamp,
+                                                                     query_type=0).aggregate(count=Sum('count'))
+            device_increase_count = device_increase_count['count'] if device_increase_count['count'] else 0
+            # 活跃设备数据
+            device_active_count = DeviceInfoSummary.objects.filter(time__gte=start_time_stamp,
+                                                                   time__lt=end_time_stamp,
+                                                                   query_type=1).aggregate(count=Sum('count'))['count']
+            device_active_count = device_active_count if device_active_count else 0
+            # 所有设备数据
+            device_all_count = DeviceInfoSummary.objects.filter(time__lte=start_time_stamp,
+                                                                query_type=0).aggregate(count=Sum('count'))['count']
+            device_all_count = device_all_count if device_all_count else 0
+            # 昨日订单销售额
+            order_qs = OrdersSummary.objects.filter(time__gte=start_time_stamp,
+                                                    time__lt=end_time_stamp,
+                                                    query_type=0).values('total')
+            order_total = order_qs.aggregate(total=Sum('total'))['total']
+            order_total = round(order_total, 2) if order_total else 0
+            # 昨日云存订单销售额
+            vod_order_total = order_qs.filter(service_type=0).aggregate(total=Sum('total'))['total']
+            vod_order_total = round(vod_order_total, 2) if vod_order_total else 0
+            # 昨日AI订单销售额
+            ai_order_total = order_qs.filter(service_type=1).aggregate(total=Sum('total'))['total']
+            ai_order_total = round(ai_order_total, 2) if ai_order_total else 0
+            # 昨日联通订单销售额
+            unicom_order_total = order_qs.filter(service_type=2).aggregate(total=Sum('total'))['total']
+            unicom_order_total = round(unicom_order_total, 2) if unicom_order_total else 0
+            # 所有订单销售额
+            order_all_qs = OrdersSummary.objects.filter(time__lte=start_time_stamp, query_type=0).values('total')
+            order_all_total = order_all_qs.aggregate(total=Sum('total'))['total']
+            order_all_total = round(order_all_total, 2) if order_all_total else 0
+            # 所有云存订单销售额
+            vod_order_all_total = order_all_qs.filter(service_type=0).aggregate(total=Sum('total'))['total']
+            vod_order_all_total = round(vod_order_all_total, 2) if vod_order_all_total else 0
+            # 所有AI订单销售额
+            ai_order_all_total = order_all_qs.filter(service_type=1).aggregate(total=Sum('total'))['total']
+            ai_order_all_total = round(ai_order_all_total, 2) if ai_order_all_total else 0
+            # 所有联通订单销售额
+            unicom_order_all_total = order_all_qs.filter(service_type=2).aggregate(total=Sum('total'))['total']
+            unicom_order_all_total = round(unicom_order_all_total, 2) if unicom_order_all_total else 0
             res = {
                 'userIncreaseCount': user_increase_count,
                 'userActiveCount': user_active_count,
@@ -98,16 +147,16 @@ class HomeDataView(View):
                 'deviceIncreaseCount': device_increase_count,
                 'deviceActiveCount': device_active_count,
                 'deviceAllCount': device_all_count,
-                'orderTotal': round(order_total, 2) if order_total else 0,
-                'vodOrderTotal': round(vod_order_total, 2) if vod_order_total else 0,
-                'aiOrderTotal': round(ai_order_total, 2) if ai_order_total else 0,
-                'unicomOrderTotal': round(unicom_order_total, 2) if unicom_order_total else 0,
-                'orderAllTotal': round(order_all_total, 2) if order_all_total else 0,
-                'vodOrderAllTotal': round(vod_order_all_total, 2) if vod_order_all_total else 0,
-                'aiOrderAllTotal': round(ai_order_all_total, 2) if ai_order_all_total else 0,
-                'unicomOrderAllTotal': round(unicom_order_all_total, 2) if unicom_order_all_total else 0,
-                'userIncreaseRegion': list(user_increase_list),
-                'userAllRegion': list(user_all_list)
+                'orderTotal': order_total,
+                'vodOrderTotal': vod_order_total,
+                'aiOrderTotal': ai_order_total,
+                'unicomOrderTotal': unicom_order_total,
+                'orderAllTotal': order_all_total,
+                'vodOrderAllTotal': vod_order_all_total,
+                'aiOrderAllTotal': ai_order_all_total,
+                'unicomOrderAllTotal': unicom_order_all_total,
+                'userIncreaseRegion': user_increase_region_list,
+                'userAllRegion': user_all_region_list
             }
             return response.json(0, res)
         except Exception as e:
@@ -130,13 +179,14 @@ class HomeDataView(View):
         if not all([start_time, end_time, time_unit]):
             return response.json(444, {'error param': 'startTime or endTime or timeUnit'})
         try:
-            order_qs = Order_Model.objects.filter(addTime__range=(start_time, end_time))
+            order_qs = OrdersSummary.objects.filter(time__gte=start_time, time__lt=end_time, query_type=0).values(
+                'total')
             start_time = datetime.datetime.fromtimestamp(int(start_time))
             end_time = datetime.datetime.fromtimestamp(int(end_time))
             time_list = CommonService.cutting_time(start_time, end_time, time_unit)
             order_list = []
             for item in time_list:
-                total = order_qs.filter(addTime__range=item).aggregate(total=Sum('price'))['total']
+                total = order_qs.filter(time__gte=item[0], time__lt=item[1]).aggregate(total=Sum('total'))['total']
                 res = {
                     'total': round(total, 2) if total else 0,
                     'startTime': item[0],
@@ -231,7 +281,8 @@ class HomeDataView(View):
                             else:
                                 user_increase_other_dict['count'] += item['count']
                         if user_increase_count:
-                            user_increase_other_dict['rate'] = round(user_increase_other_dict['count'] / user_increase_count * 100, 2)
+                            user_increase_other_dict['rate'] = round(
+                                user_increase_other_dict['count'] / user_increase_count * 100, 2)
                         user_increase_list.append(user_increase_other_dict)
                     if user_all_temp_list:
                         for item in user_all_temp_list:

AdminController/dataSystemManagement/ServiceDataController.py

@@ -12,7 +12,8 @@ from django.views.generic.base import View
 import datetime
 import requests
 
-from Model.models import Order_Model, CountryModel, Device_Info, DeviceTypeModel, UidSetModel, UnicomCombo
+from Model.models import Order_Model, CountryModel, Device_Info, DeviceTypeModel, UidSetModel, UnicomCombo, \
+    OrdersSummary, DeviceInfoSummary
 from Service.CommonService import CommonService
 
 
@@ -72,11 +73,13 @@ class ServiceDataView(View):
             return response.json(444, {'error param': 'startTime or endTime or timeUnit or storeMealType'})
         try:
             store_meal_type = int(store_meal_type)
-            order_qs = Order_Model.objects.filter(order_type=store_meal_type, status=1,
-                                                  addTime__range=(start_time, end_time)).filter(
-                ~Q(price='0.00') & ~Q(price='0'))
-            count = order_qs.count()
-            total = order_qs.aggregate(total=Sum('price'))['total']
+            order_qs = OrdersSummary.objects.filter(time__gte=start_time, time__lt=end_time, query_type=0,
+                                                    service_type=store_meal_type).values('count', 'country', 'total',
+                                                                                         'device_type', 'store_meal')
+            all_order_qs = OrdersSummary.objects.filter(time__gte=start_time, time__lt=end_time).filter(
+                Q(query_type=0) | Q(query_type=1)).aggregate(total=Sum('total'), count=Sum('count'))
+            all_order_count = all_order_qs['count']
+            all_order_total = all_order_qs['total']
             start_time = datetime.datetime.fromtimestamp(int(start_time))
             end_time = datetime.datetime.fromtimestamp(int(end_time))
             time_list = CommonService.cutting_time(start_time, end_time, time_unit)
@@ -84,124 +87,86 @@ class ServiceDataView(View):
             # 订单数量统计
             order_list = []
             for item in time_list:
-                order_temp_qs = order_qs.filter(addTime__range=item)
+                order_temp_qs = order_qs.filter(time__gte=item[0], time__lt=item[1])
+                temp_count = order_temp_qs.aggregate(count=Sum('count'))['count']
+                temp_count = temp_count if temp_count else 0
                 order_dict = {
-                    'count': order_temp_qs.count(),
+                    'count': temp_count,
                     'startTime': item[0],
                     'endTime': item[1]
                 }
                 order_list.append(order_dict)
 
+            device_type_dict = {}
+            country_dict = {}
+            store_meal_dict = {}
+            for each in order_qs:
+                device_type_temp_dict = eval(each['device_type'])
+                country_temp_dict = eval(each['country'])
+                store_meal_temp_dict = eval(each['store_meal'])
+                for k, v in device_type_temp_dict.items():
+                    if k in device_type_dict:
+                        device_type_dict[k]['数量'] += v['数量']
+                        device_type_dict[k]['销售额'] = str(round(float(device_type_dict[k]['销售额']) + float(v['销售额']), 2))
+                    else:
+                        device_type_dict[k] = v
+                for k, v in country_temp_dict.items():
+                    if k in country_dict:
+                        country_dict[k] += v
+                    else:
+                        country_dict[k] = v
+                for k, v in store_meal_temp_dict.items():
+                    if k in store_meal_dict:
+                        store_meal_dict[k]['数量'] += v['数量']
+                        store_meal_dict[k]['销售额'] = str(
+                            round(float(store_meal_dict[k]['销售额']) + float(v['销售额']), 2))
+                    else:
+                        store_meal_dict[k] = v
             # 设备类型订单统计
             device_type_list = []
-            device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
-            uid_list = []
-            uid_type_dict = {}
-            for item in device_type_qs:
-                uid_list.append(item['UID'])
-                device_temp_qs = Device_Info.objects.filter(UID=item['UID']).values('Type')
-                if device_temp_qs.exists():
-                    if device_temp_qs[0]['Type'] not in uid_type_dict:
-                        uid_type_dict[device_temp_qs[0]['Type']] = []
-                    uid_type_dict[device_temp_qs[0]['Type']].append(item['UID'])
-            for k, v in uid_type_dict.items():
-                type_qs = DeviceTypeModel.objects.filter(type=k).values('name')
-                type_name = type_qs[0]['name'] if type_qs.exists() else '未知类型'
-                device_count = order_qs.filter(UID__in=v).count()
-                if count:
-                    type_rate = round(device_count / count * 100, 2)
-                else:
-                    type_rate = 0
-                temp_total = order_qs.filter(UID__in=v).aggregate(total=Sum('price'))['total']
-                total_rate = round(temp_total / total * 100, 2)
-                device_temp_qs = {
-                    'typeName': type_name,
-                    'count': device_count,
+            for k, v in device_type_dict.items():
+                type_rate = round(v['数量'] / all_order_count * 100, 2) if all_order_count else 0
+                total_rate = round(float(v['销售额']) / all_order_total * 100, 2) if all_order_total else 0
+                device_temp_dict = {
+                    'typeName': k,
+                    'count': v['数量'],
                     'typeRate': type_rate,
-                    'totalMoney': temp_total,
+                    'totalMoney': v['销售额'],
                     'totalRate': total_rate
                 }
-                device_type_list.append(device_temp_qs)
+                device_type_list.append(device_temp_dict)
 
             # 区域订单统计
             region_list = []
-            region_dict = {}
-            for item in uid_list:
-                uidset_qs = UidSetModel.objects.filter(uid=item).values('tb_country')
-                if uidset_qs.exists():
-                    country_qs = CountryModel.objects.filter(id=uidset_qs[0]['tb_country']).values('country_name')
-                    country_name = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
-                else:
-                    country_name = '未知区域'
-                if country_name not in region_dict:
-                    region_dict[country_name] = []
-                region_dict[country_name].append(item)
-            for k, v in region_dict.items():
-                region_order_count = order_qs.filter(UID__in=v).count()
-                if count:
-                    rate = round(region_order_count / count * 100, 2)
-                else:
-                    rate = 0
+            for k, v in country_dict.items():
+                rate = round(v / all_order_count * 100, 2) if all_order_count else 0
                 region_temp_dict = {
                     'countryName': k,
-                    'count': region_order_count,
+                    'count': v,
                     'rate': rate
                 }
                 region_list.append(region_temp_dict)
 
             # 套餐订单统计
             store_meal_list = []
-            if store_meal_type == 0:
-                store_meal_qs = order_qs.values('rank').annotate(count=Count('rank')).order_by('-count')
-            elif store_meal_type == 1:
-                store_meal_qs = order_qs.values('ai_rank').annotate(count=Count('ai_rank')).order_by('-count')
-            else:
-                store_meal_qs = order_qs.values('unify_combo_id').annotate(count=Count('unify_combo_id')).order_by(
-                    '-count')
-            for item in store_meal_qs:
-                if store_meal_type == 0:
-                    store_meal_id = item['rank']
-                    store_meal_content_qs = store_meal_qs.filter(rank=store_meal_id, rank__lang__lang='cn').values(
-                        'rank__lang__content')
-                    store_meal_name = store_meal_content_qs[0][
-                        'rank__lang__content'] if store_meal_content_qs.exists() else '未知套餐'
-                    store_meal_total = order_qs.filter(rank=store_meal_id).aggregate(total=Sum('price'))['total']
-                elif store_meal_type == 1:
-                    store_meal_id = item['ai_rank']
-                    store_meal_content_qs = store_meal_qs.filter(ai_rank=store_meal_id,
-                                                                 ai_rank__lang__lang='cn').values(
-                        'ai_rank__lang__content')
-                    store_meal_name = store_meal_content_qs[0][
-                        'ai_rank__lang__content'] if store_meal_content_qs.exists() else '未知套餐'
-                    store_meal_total = order_qs.filter(ai_rank=store_meal_id).aggregate(total=Sum('price'))[
-                        'total']
-                else:
-                    store_meal_id = item['unify_combo_id']
-                    store_meal_content_qs = UnicomCombo.objects.filter(id=store_meal_id).values(
-                        'combo_name')
-                    store_meal_name = store_meal_content_qs[0][
-                        'combo_name'] if store_meal_content_qs.exists() else '未知套餐'
-                    store_meal_total = order_qs.filter(unify_combo_id=store_meal_id).aggregate(total=Sum('price'))[
-                        'total']
-                total_rate = round(store_meal_total / total * 100, 2)
-                if count:
-                    rate = round(item['count'] / count * 100, 2)
-                else:
-                    rate = 0
-                store_meal_dict = {
-                    'storeMealId': store_meal_id,
-                    'count': item['count'],
-                    'storeMealName': store_meal_name,
-                    'storeMealTotal': store_meal_total,
+            for k, v in store_meal_dict.items():
+                total_rate = round(float(v['销售额']) / all_order_total * 100, 2) if all_order_total else 0
+                count_rate = round(v['数量'] / all_order_count * 100, 2) if all_order_count else 0
+                store_temp_dict = {
+                    'count': v['数量'],
+                    'storeMealName': k,
+                    'storeMealTotal': v['销售额'],
                     'totalRate': total_rate,
-                    'rate': rate
+                    'rate': count_rate
                 }
-                store_meal_list.append(store_meal_dict)
+                store_meal_list.append(store_temp_dict)
             res = {
                 'orders': order_list,
                 'regions': region_list,
                 'deviceType': device_type_list,
                 'storeMeal': store_meal_list,
+                'allOrderCount': all_order_count,
+                'allOrderTotal': all_order_total
             }
             return response.json(0, res)
         except Exception as e:
@@ -227,87 +192,79 @@ class ServiceDataView(View):
             return response.json(444, {'error param': 'startTime or endTime or timeUnit or storeMealType'})
         try:
             store_meal_type = int(store_meal_type)
-            order_qs = Order_Model.objects.filter(order_type=store_meal_type, status=1,
-                                                  addTime__range=(start_time, end_time)).filter(
-                Q(price='0.00') | Q(price='0'))
-            count = order_qs.count()
-            uidset_qs = UidSetModel.objects.filter(addTime__range=(start_time, end_time))
+            order_qs = OrdersSummary.objects.filter(time__gte=start_time, time__lt=end_time, query_type=1,
+                                                    service_type=store_meal_type).values('count', 'country',
+                                                                                         'device_type')
+            free_order_count = order_qs.aggregate(count=Sum('count'))['count']
+            free_order_count = free_order_count if free_order_count else 0  # 免费订单数量
+            all_order_qs = OrdersSummary.objects.filter(time__gte=start_time, time__lt=end_time).filter(
+                Q(query_type=0) | Q(query_type=1)).aggregate(count=Sum('count'))
+            all_order_count = all_order_qs['count']  # 所有订单数量
+            device_qs = DeviceInfoSummary.objects.filter(time__gte=start_time, time__lt=end_time, query_type=0).values(
+                'vod_service', 'ai_service', 'unicom_service')
+            new_device_count = 0  # 销售设备数量
             start_time = datetime.datetime.fromtimestamp(int(start_time))
             end_time = datetime.datetime.fromtimestamp(int(end_time))
             time_list = CommonService.cutting_time(start_time, end_time, time_unit)
             # 转化率
-            if store_meal_type == 0:
-                uidset_count = uidset_qs.filter(~Q(cloud_vod=2)).count()
-            elif store_meal_type == 1:
-                uidset_count = uidset_qs.filter(is_ai=1).count()
-            else:
-                uidset_count = uidset_qs.filter(mobile_4g=1).count()
-            order_device_count = order_qs.values('UID').distinct().order_by('UID').count()
-            if uidset_count:
-                inversion_rate = round(order_device_count / uidset_count * 100, 2)
-            else:
-                inversion_rate = 0
+            for item in device_qs:
+                if store_meal_type == 0:
+                    service = eval(item['vod_service'])
+                elif store_meal_type == 1:
+                    service = eval(item['ai_service'])
+                else:
+                    service = eval(item['unicom_service'])
+                for each in service.values():
+                    new_device_count += each
+            inversion_rate = round(free_order_count / new_device_count * 100, 2) if new_device_count else 0
             # 订单数量统计
             order_list = []
+
             for item in time_list:
-                order_temp_qs = order_qs.filter(addTime__range=item)
+                order_temp_qs = order_qs.filter(time__gte=item[0], time__lt=item[1])
+                temp_count = order_temp_qs.aggregate(count=Sum('count'))['count']
+                temp_count = temp_count if temp_count else 0
                 order_dict = {
-                    'count': order_temp_qs.count(),
+                    'count': temp_count,
                     'startTime': item[0],
                     'endTime': item[1]
                 }
                 order_list.append(order_dict)
 
+            device_type_dict = {}
+            country_dict = {}
+            for each in order_qs:
+                device_type_temp_dict = eval(each['device_type'])
+                for k, v in device_type_temp_dict.items():
+                    if k in device_type_dict:
+                        device_type_dict[k] += v
+                    else:
+                        device_type_dict[k] = v
+                country_temp_dict = eval(each['country'])
+                for k, v in country_temp_dict.items():
+                    if k in country_dict:
+                        country_dict[k] += v
+                    else:
+                        country_dict[k] = v
+
             # 设备类型订单统计
             device_type_list = []
-            device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
-            uid_dict = {}
-            uid_list = []
-            for item in device_type_qs:
-                uid_list.append(item['UID'])
-                device_qs = Device_Info.objects.filter(UID=item['UID']).values('Type')
-                device_type = device_qs[0]['Type'] if device_qs.exists() else 0
-                if device_type not in uid_dict:
-                    uid_dict[device_type] = []
-                uid_dict[device_type].append(item['UID'])
-
-            for k, v in uid_dict.items():
-                type_qs = DeviceTypeModel.objects.filter(type=k).values('name')
-                type_name = type_qs[0]['name'] if type_qs.exists() else '未知类型'
-                device_count = order_qs.filter(UID__in=v).count()
-                if count:
-                    type_rate = round(device_count / count * 100, 2)
-                else:
-                    type_rate = 0
+            for k, v in device_type_dict.items():
+                type_rate = round(v / all_order_count * 100, 2) if all_order_count else 0
                 device_temp_qs = {
-                    'typeName': type_name,
-                    'count': device_count,
+                    'typeName': k,
+                    'count': v,
                     'typeRate': type_rate,
                 }
                 device_type_list.append(device_temp_qs)
 
             # 区域订单统计
             region_list = []
-            region_dict = {}
-            for item in uid_list:
-                uidset_qs = UidSetModel.objects.filter(uid=item).values('tb_country')
-                if uidset_qs.exists():
-                    country_qs = CountryModel.objects.filter(id=uidset_qs[0]['tb_country']).values('country_name')
-                    country_name = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
-                else:
-                    country_name = '未知区域'
-                if country_name not in region_dict:
-                    region_dict[country_name] = []
-                region_dict[country_name].append(item)
-            for k, v in region_dict.items():
-                region_order_count = order_qs.filter(UID__in=v).count()
-                if count:
-                    rate = round(region_order_count / count * 100, 2)
-                else:
-                    rate = 0
+            for k, v in country_dict.items():
+                rate = round(v / all_order_count * 100, 2) if all_order_count else 0
                 region_temp_dict = {
                     'countryName': k,
-                    'count': region_order_count,
+                    'count': v,
                     'rate': rate
                 }
                 region_list.append(region_temp_dict)
@@ -317,8 +274,8 @@ class ServiceDataView(View):
                 'regions': region_list,
                 'deviceType': device_type_list,
                 'inversionRate': inversion_rate,
-                'newDeviceCount': uidset_count,
-                'orderDeviceCount': order_device_count
+                'newDeviceCount': new_device_count,
+                'allOrderCount': all_order_count
             }
             return response.json(0, res)
         except Exception as e:
@@ -343,17 +300,12 @@ class ServiceDataView(View):
         if not all([start_time, end_time, time_unit, store_meal_type]):
             return response.json(444, {'error param': 'startTime or endTime or timeUnit or storeMealType'})
         try:
-            order_gte_start_time_qs = Order_Model.objects.filter(order_type=store_meal_type, status=1,
-                                                                 addTime__lte=start_time).filter(
-                ~Q(price='0.00') & ~Q(price='0'))
-            uid_list = []
-            for item in order_gte_start_time_qs:
-                uid_list.append(item.UID)
-            order_qs = Order_Model.objects.filter(order_type=store_meal_type, status=1,
-                                                  addTime__range=(start_time, end_time)).filter(~Q(price='0.00'),
-                                                                                                ~Q(UID__in=uid_list),
-                                                                                                ~Q(price='0'))
-            count = order_qs.count()
+            order_qs = OrdersSummary.objects.filter(time__gte=start_time, time__lt=end_time, query_type=2,
+                                                    service_type=store_meal_type).values('count', 'country',
+                                                                                         'device_type')
+            all_order_qs = OrdersSummary.objects.filter(time__gte=start_time, time__lt=end_time).filter(
+                Q(query_type=0) | Q(query_type=1)).aggregate(count=Sum('count'))
+            all_order_count = all_order_qs['count']  # 所有订单数量
             start_time = datetime.datetime.fromtimestamp(int(start_time))
             end_time = datetime.datetime.fromtimestamp(int(end_time))
             time_list = CommonService.cutting_time(start_time, end_time, time_unit)
@@ -361,63 +313,50 @@ class ServiceDataView(View):
             # 订单数量统计
             order_list = []
             for item in time_list:
-                order_temp_qs = order_qs.filter(addTime__range=item)
+                order_temp_qs = order_qs.filter(time__gte=item[0], time__lt=item[1])
+                temp_count = order_temp_qs.aggregate(count=Sum('count'))['count']
+                temp_count = temp_count if temp_count else 0
                 order_dict = {
-                    'count': order_temp_qs.count(),
+                    'count': temp_count,
                     'startTime': item[0],
                     'endTime': item[1]
                 }
                 order_list.append(order_dict)
 
+            country_dict = {}
+            device_type_dict = {}
+            for each in order_qs:
+                country_temp_dict = eval(each['country'])
+                device_type_temp_dict = eval(each['device_type'])
+                for k, v in country_temp_dict.items():
+                    if k in country_dict:
+                        country_dict[k] += v
+                    else:
+                        country_dict[k] = v
+                for k, v in device_type_temp_dict.items():
+                    if k in device_type_dict:
+                        device_type_dict[k] += v
+                    else:
+                        device_type_dict[k] = v
+
             # 设备类型订单统计
             device_type_list = []
-            device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
-            uid_dict = {}
-            uid_list = []
-            for item in device_type_qs:
-                uid_list.append(item['UID'])
-                device_qs = Device_Info.objects.filter(UID=item['UID']).values('Type')
-                device_type = device_qs[0]['Type'] if device_qs.exists() else 0
-                if device_type not in uid_dict:
-                    uid_dict[device_type] = []
-                uid_dict[device_type].append(item['UID'])
-            for k, v in uid_dict.items():
-                type_qs = DeviceTypeModel.objects.filter(type=k).values('name')
-                type_name = type_qs[0]['name'] if type_qs.exists() else '未知类型'
-                device_count = order_qs.filter(UID__in=v).count()
-                if count:
-                    type_rate = round(device_count / count * 100, 2)
-                else:
-                    type_rate = 0
+            for k, v in device_type_dict.items():
+                type_rate = round(v / all_order_count * 100, 2) if all_order_count else 0
                 device_temp_qs = {
-                    'typeName': type_name,
-                    'count': device_count,
+                    'typeName': k,
+                    'count': v,
                     'typeRate': type_rate,
                 }
                 device_type_list.append(device_temp_qs)
 
             # 区域订单统计
             region_list = []
-            region_dict = {}
-            for item in uid_list:
-                uidset_qs = UidSetModel.objects.filter(uid=item).values('tb_country')
-                if uidset_qs.exists():
-                    country_qs = CountryModel.objects.filter(id=uidset_qs[0]['tb_country']).values('country_name')
-                    country_name = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
-                else:
-                    country_name = '未知区域'
-                if country_name not in region_dict:
-                    region_dict[country_name] = []
-                region_dict[country_name].append(item)
-            for k, v in region_dict.items():
-                region_order_count = order_qs.filter(UID__in=v).count()
-                if count:
-                    rate = round(region_order_count / count * 100, 2)
-                else:
-                    rate = 0
+            for k, v in country_dict.items():
+                rate = round(v / all_order_count * 100, 2) if all_order_count else 0
                 region_temp_dict = {
                     'countryName': k,
-                    'count': region_order_count,
+                    'count': v,
                     'rate': rate
                 }
                 region_list.append(region_temp_dict)
@@ -426,8 +365,8 @@ class ServiceDataView(View):
                 'orders': order_list,
                 'regions': region_list,
                 'deviceType': device_type_list,
+                'allOrderCount': all_order_count
             }
-
             return response.json(0, res)
         except Exception as e:
             return response.json(500, repr(e))
@@ -451,90 +390,66 @@ class ServiceDataView(View):
         if not all([start_time, end_time, time_unit, store_meal_type]):
             return response.json(444, {'error param': 'startTime or endTime or timeUnit or storeMealType'})
         try:
-            order_gte_start_time_qs = Order_Model.objects.filter(order_type=store_meal_type, status=1,
-                                                                 addTime__lte=start_time).filter(
-                ~Q(price='0.00') & ~Q(price='0'))
-            uid_list = []
-            for item in order_gte_start_time_qs:
-                uid_list.append(item.UID)
-            order_qs = Order_Model.objects.filter(order_type=store_meal_type, status=1,
-                                                  addTime__range=(start_time, end_time)).filter(
-                ~Q(price='0.00'), ~Q(price='0'), Q(UID__in=uid_list))
-            total = order_gte_start_time_qs.count()
+            order_qs = OrdersSummary.objects.filter(time__gte=start_time, time__lt=end_time, query_type=3,
+                                                    service_type=store_meal_type).values('count', 'country',
+                                                                                         'device_type')
+            repeat_pay_order_count = order_qs.aggregate(count=Sum('count'))['count']
+            repeat_pay_order_count = repeat_pay_order_count if repeat_pay_order_count else 0
+            all_order_qs = OrdersSummary.objects.filter(time__gte=start_time, time__lt=end_time).filter(
+                Q(query_type=0) | Q(query_type=1)).aggregate(count=Sum('count'))
+            all_order_count = all_order_qs['count']  # 所有订单数量
 
             # 订单复购率
-            count = order_qs.count()
-            if total:
-                repeat_rate = round(count / total * 100, 2)
-            else:
-                repeat_rate = 0
-
+            repeat_rate = round(repeat_pay_order_count / all_order_count * 100, 2) if all_order_count else 0
             start_time = datetime.datetime.fromtimestamp(int(start_time))
             end_time = datetime.datetime.fromtimestamp(int(end_time))
             time_list = CommonService.cutting_time(start_time, end_time, time_unit)
             # 订单数量统计
             order_list = []
             for item in time_list:
-                order_temp_qs = order_qs.filter(addTime__range=item)
+                order_temp_qs = order_qs.filter(time__gte=item[0], time__lt=item[1])
+                temp_count = order_temp_qs.aggregate(count=Sum('count'))['count']
+                temp_count = temp_count if temp_count else 0
                 order_dict = {
-                    'count': order_temp_qs.count(),
+                    'count': temp_count,
                     'startTime': item[0],
                     'endTime': item[1]
                 }
                 order_list.append(order_dict)
+            device_type_dict = {}
+            country_dict = {}
+            for each in order_qs:
+                country_temp_dict = eval(each['country'])
+                device_type_temp_dict = eval(each['device_type'])
+                for k, v in country_temp_dict.items():
+                    if k in country_dict:
+                        country_dict[k] += v
+                    else:
+                        country_dict[k] = v
+                for k, v in device_type_temp_dict.items():
+                    if k in device_type_dict:
+                        device_type_dict[k] += v
+                    else:
+                        device_type_dict[k] = v
 
             # 设备类型订单统计
             device_type_list = []
-            device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
-            uid_dict = {}
-            uid_list = []
-            for item in device_type_qs:
-                uid_list.append(item['UID'])
-                device_qs = Device_Info.objects.filter(UID=item['UID']).values('Type')
-                device_type = device_qs[0]['Type'] if device_qs.exists() else 0
-                if device_type not in uid_dict:
-                    uid_dict[device_type] = []
-                uid_dict[device_type].append(item['UID'])
-            for k, v in uid_dict.items():
-                type_qs = DeviceTypeModel.objects.filter(type=k).values('name')
-                type_name = type_qs[0]['name'] if type_qs.exists() else '未知类型'
-                device_count = order_qs.filter(UID__in=v).count()
-                if count:
-                    if count:
-                        type_rate = round(device_count / count * 100, 2)
-                    else:
-                        type_rate = 0
-                else:
-                    type_rate = 0
+            for k, v in device_type_dict.items():
+                type_rate = round(v / all_order_count * 100, 2) if all_order_count else 0
                 device_temp_qs = {
-                    'typeName': type_name,
-                    'count': device_count,
+                    'typeName': k,
+                    'count': v,
                     'typeRate': type_rate,
                 }
                 device_type_list.append(device_temp_qs)
 
             # 区域订单统计
             region_list = []
-            region_dict = {}
-            for item in uid_list:
-                uidset_qs = UidSetModel.objects.filter(uid=item).values('tb_country')
-                if uidset_qs.exists():
-                    country_qs = CountryModel.objects.filter(id=uidset_qs[0]['tb_country']).values('country_name')
-                    country_name = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
-                else:
-                    country_name = '未知区域'
-                if country_name not in region_dict:
-                    region_dict[country_name] = []
-                region_dict[country_name].append(item)
-            for k, v in region_dict.items():
-                region_order_count = order_qs.filter(UID__in=v).count()
-                if count:
-                    rate = round(region_order_count / count * 100, 2)
-                else:
-                    rate = 0
+            for k, v in country_dict.items():
+                rate = round(v / all_order_count * 100, 2) if all_order_count else 0
                 region_temp_dict = {
                     'countryName': k,
-                    'count': region_order_count,
+                    'count': v,
                     'rate': rate
                 }
                 region_list.append(region_temp_dict)
@@ -543,8 +458,8 @@ class ServiceDataView(View):
                 'regions': region_list,
                 'deviceType': device_type_list,
                 'repeatRate': repeat_rate,
-                'repeatCount': count,
-                'orderCount': total
+                'repeatOrderCount': repeat_pay_order_count,
+                'allOrderCount': all_order_count
             }
             return response.json(0, res)
         except Exception as e:
@@ -566,12 +481,10 @@ class ServiceDataView(View):
             }
             order_list = []
             region_list = []
-            region_count = 0
             device_type_list = []
-            device_type_count = 0
-            total = 0
+            all_order_count = 0
+            all_order_total = 0
             store_meal_list = []
-            store_meal_count = 0
             for url in url_list:
                 url = url + request.path.replace('global/', '')
                 res = requests.get(url=url, params=request_dict, headers=headers)
@@ -593,18 +506,11 @@ class ServiceDataView(View):
                         for each in region_list:
                             if each['countryName'] == item['countryName']:
                                 each['count'] += int(item['count'])
-                                region_count += int(item['count'])
                                 flag = 1
                                 break
                         if flag == 0:
                             region_list.append(item)
-                            region_count += int(item['count'])
-                    for item in region_list:
-                        if region_count:
-                            rate = round(item['count'] / region_count * 100, 2)
-                        else:
-                            rate = 0
-                        item['rate'] = rate
+
                     # 处理设备类型
                     for item in result['result']['deviceType']:
                         flag = 0
@@ -612,45 +518,35 @@ class ServiceDataView(View):
                             if each['typeName'] == item['typeName']:
                                 each['count'] += int(item['count'])
                                 item['totalMoney'] += item['totalMoney']
-                                device_type_count += int(item['count'])
-                                total += item['totalMoney']
                                 flag = 1
                                 break
                         if flag == 0:
                             device_type_list.append(item)
-                            device_type_count += int(item['count'])
-                            total += item['totalMoney']
-                    for item in device_type_list:
-                        if device_type_count:
-                            type_rate = round(item['count'] / device_type_count * 100, 2)
-                        else:
-                            type_rate = 0
-                        total_rate = round(item['totalMoney'] / total * 100, 2)
-                        item['typeRate'] = type_rate
-                        item['totalRate'] = total_rate
+
                     # 处理套餐
                     for item in result['result']['storeMeal']:
                         flag = 0
                         for each in store_meal_list:
-                            if each['storeMealId'] == item['storeMealId']:
+                            if each['storeMealName'] == item['storeMealName']:
                                 each['count'] += int(item['count'])
                                 each['storeMealTotal'] += item['storeMealTotal']
-                                store_meal_count += int(item['count'])
                                 flag = 1
                                 break
                         if flag == 0:
                             store_meal_list.append(item)
-                            store_meal_count += int(item['count'])
-                    for item in store_meal_list:
-                        total_rate = round(item['storeMealTotal'] / total * 100, 2)
-                        if store_meal_count:
-                            rate = round(item['count'] / store_meal_count * 100, 2)
-                        else:
-                            rate = 0
-                        item['rate'] = rate
-                        item['totalRate'] = total_rate
+
+                    all_order_total += result['result']['allOrderTotal']
+                    all_order_count += result['result']['allOrderCount']
                 else:
                     return response.json(result['result_code'], result['result'])
+            for item in region_list:
+                item['rate'] = round(item['count'] / all_order_count * 100, 2) if all_order_count else 0
+            for item in device_type_list:
+                item['typeRate'] = round(item['count'] / all_order_count * 100, 2) if all_order_count else 0
+                item['totalRate'] = round(item['totalMoney'] / all_order_total * 100, 2) if all_order_total else 0
+            for item in store_meal_list:
+                item['totalRate'] = round(item['storeMealTotal'] / all_order_total * 100, 2) if all_order_total else 0
+                item['rate'] = round(item['count'] / all_order_count * 100, 2) if all_order_count else 0
             res = {
                 'orders': order_list,
                 'regions': CommonService.list_sort(region_list),
@@ -677,11 +573,10 @@ class ServiceDataView(View):
             }
             order_list = []
             region_list = []
-            region_count = 0
+            free_order_count = 0
             device_type_list = []
-            device_type_count = 0
             new_device_count = 0
-            order_device_count = 0
+            all_order_count = 0
             for url in url_list:
                 url = url + request.path.replace('global/', '')
                 res = requests.get(url=url, params=request_dict, headers=headers)
@@ -703,51 +598,40 @@ class ServiceDataView(View):
                         for each in region_list:
                             if each['countryName'] == item['countryName']:
                                 each['count'] += int(item['count'])
-                                region_count += int(item['count'])
+                                free_order_count += int(item['count'])
                                 flag = 1
                                 break
                         if flag == 0:
                             region_list.append(item)
-                            region_count += int(item['count'])
-                    for item in region_list:
-                        if region_count:
-                            rate = round(item['count'] / region_count * 100, 2)
-                        else:
-                            rate = 0
-                        item['rate'] = rate
+                            free_order_count += int(item['count'])
+
                     # 处理设备类型
                     for item in result['result']['deviceType']:
                         flag = 0
                         for each in device_type_list:
                             if each['typeName'] == item['typeName']:
                                 each['count'] += int(item['count'])
-                                device_type_count += int(item['count'])
                                 flag = 1
                                 break
                         if flag == 0:
                             device_type_list.append(item)
-                            device_type_count += int(item['count'])
-                    for item in device_type_list:
-                        if device_type_count:
-                            type_rate = round(item['count'] / device_type_count * 100, 2)
-                        else:
-                            type_rate = 0
-                        item['typeRate'] = type_rate
+
                     # 处理转化率
                     new_device_count += int(result['result']['newDeviceCount'])
-                    order_device_count += int(result['result']['orderDeviceCount'])
+                    all_order_count += int(result['result']['allOrderCount'])
                 else:
                     return response.json(result['result_code'], result['result'])
-            if new_device_count:
-                inversion_rate = round(order_device_count / new_device_count * 100, 2)
-            else:
-                inversion_rate = 0
+            inversion_rate = round(free_order_count / new_device_count * 100, 2) if new_device_count else 0
+            for item in region_list:
+                item['rate'] = round(item['count'] / all_order_count * 100, 2) if all_order_count else 0
+            for item in device_type_list:
+                item['typeRate'] = round(item['count'] / all_order_count * 100, 2) if all_order_count else 0
             res = {
                 'orders': order_list,
                 'regions': CommonService.list_sort(region_list),
                 'deviceType': CommonService.list_sort(device_type_list),
                 'newDeviceCount': new_device_count,
-                'orderDeviceCount': order_device_count,
+                'allOrderCount': all_order_count,
                 'inversionRate': inversion_rate
             }
             return response.json(0, res)
@@ -770,9 +654,8 @@ class ServiceDataView(View):
             }
             order_list = []
             region_list = []
-            region_count = 0
             device_type_list = []
-            device_type_count = 0
+            all_order_count = 0
             for url in url_list:
                 url = url + request.path.replace('global/', '')
                 res = requests.get(url=url, params=request_dict, headers=headers)
@@ -794,38 +677,28 @@ class ServiceDataView(View):
                         for each in region_list:
                             if each['countryName'] == item['countryName']:
                                 each['count'] += int(item['count'])
-                                region_count += int(item['count'])
                                 flag = 1
                                 break
                         if flag == 0:
                             region_list.append(item)
-                            region_count += int(item['count'])
-                    for item in region_list:
-                        if region_count:
-                            rate = round(item['count'] / region_count * 100, 2)
-                        else:
-                            rate = 0
-                        item['rate'] = rate
+
                     # 处理设备类型
                     for item in result['result']['deviceType']:
                         flag = 0
                         for each in device_type_list:
                             if each['typeName'] == item['typeName']:
                                 each['count'] += int(item['count'])
-                                device_type_count += int(item['count'])
                                 flag = 1
                                 break
                         if flag == 0:
                             device_type_list.append(item)
-                            device_type_count += int(item['count'])
-                    for item in device_type_list:
-                        if device_type_count:
-                            type_rate = round(item['count'] / device_type_count * 100, 2)
-                        else:
-                            type_rate = 0
-                        item['typeRate'] = type_rate
+                    all_order_count += result['result']['allOrderCount']
                 else:
                     return response.json(result['result_code'], result['result'])
+            for item in region_list:
+                item['rate'] = round(item['count'] / all_order_count * 100, 2) if all_order_count else 0
+            for item in device_type_list:
+                item['typeRate'] = round(item['count'] / all_order_count * 100, 2) if all_order_count else 0
             res = {
                 'orders': order_list,
                 'regions': CommonService.list_sort(region_list),
@@ -851,11 +724,9 @@ class ServiceDataView(View):
             }
             order_list = []
             region_list = []
-            region_count = 0
+            repeat_order_count = 0
             device_type_list = []
-            device_type_count = 0
-            repeat_count = 0
-            order_count = 0
+            all_order_count = 0
             for url in url_list:
                 url = url + request.path.replace('global/', '')
                 res = requests.get(url=url, params=request_dict, headers=headers)
@@ -877,52 +748,39 @@ class ServiceDataView(View):
                         for each in region_list:
                             if each['countryName'] == item['countryName']:
                                 each['count'] += int(item['count'])
-                                region_count += int(item['count'])
                                 flag = 1
                                 break
                         if flag == 0:
                             region_list.append(item)
-                            region_count += int(item['count'])
-                    for item in region_list:
-                        if region_count:
-                            rate = round(item['count'] / region_count * 100, 2)
-                        else:
-                            rate = 0
-                        item['rate'] = rate
+
                     # 处理设备类型
                     for item in result['result']['deviceType']:
                         flag = 0
                         for each in device_type_list:
                             if each['typeName'] == item['typeName']:
                                 each['count'] += int(item['count'])
-                                device_type_count += int(item['count'])
                                 flag = 1
                                 break
                         if flag == 0:
                             device_type_list.append(item)
-                            device_type_count += int(item['count'])
-                    for item in device_type_list:
-                        if device_type_count:
-                            type_rate = round(item['count'] / device_type_count * 100, 2)
-                        else:
-                            type_rate = 0
-                        item['typeRate'] = type_rate
+
                     # 处理订单复购率
-                    repeat_count += result['result']['repeatCount']
-                    order_count += result['result']['orderCount']
+                    repeat_order_count += result['result']['repeatOrderCount']
+                    all_order_count += result['result']['allOrderCount']
                 else:
                     return response.json(result['result_code'], result['result'])
-            if order_count:
-                repeat_rate = round(repeat_count / order_count * 100, 2)
-            else:
-                repeat_rate = 0
+            repeat_rate = round(repeat_order_count / all_order_count * 100, 2) if all_order_count else 0
+            for item in device_type_list:
+                item['typeRate'] = round(item['count'] / all_order_count * 100, 2) if all_order_count else 0
+            for item in region_list:
+                item['rate'] = round(item['count'] / all_order_count * 100, 2) if all_order_count else 0
             res = {
                 'orders': order_list,
                 'regions': CommonService.list_sort(region_list),
                 'deviceType': CommonService.list_sort(device_type_list),
                 'repeatRate': repeat_rate,
-                'repeatCount': repeat_count,
-                'orderCount': order_count
+                'repeatOrderCount': repeat_order_count,
+                'allOrderCount': all_order_count
             }
             return response.json(0, res)
         except Exception as e:

AdminController/dataSystemManagement/UserDataController.py

@@ -68,24 +68,24 @@ class UserDataView(View):
             all_user_qs = DeviceUserSummary.objects.filter(time__gte=start_time, time__lt=end_time,
                                                            query_type=0).values('count', 'country')
             count = all_user_qs.aggregate(total=Sum('count'))['total']
+            count = count if count else 0
             # 处理用户地区
+            region_dict = {}
             region_list = []
             for item in all_user_qs:
                 country_temp_dict = eval(item['country'])
                 for k, v in country_temp_dict.items():
-                    flag = 0
-                    for each in region_list:
-                        if k == each['countryName']:
-                            each['count'] += v
-                            flag = 1
-                            break
-                    if flag == 0:
-                        region_list.append({
-                            'countryName': k,
-                            'count': v
-                        })
-            for item in region_list:
-                item['rate'] = round(item['count'] / count * 100, 2) if count else 0
+                    if k in region_dict:
+                        region_dict[k] += v
+                    else:
+                        region_dict[k] = v
+            for k, v in region_dict.items():
+                rate = round(v / count * 100, 2) if count else 0
+                region_list.append({
+                    'countryName': k,
+                    'count': v,
+                    'rate': rate
+                })
             # 处理时间段用户
             start_time = datetime.datetime.fromtimestamp(int(start_time))
             end_time = datetime.datetime.fromtimestamp(int(end_time))
@@ -132,24 +132,24 @@ class UserDataView(View):
             all_user_qs = DeviceUserSummary.objects.filter(time__gte=start_time, time__lt=end_time,
                                                            query_type=1).values('count', 'country')
             count = all_user_qs.aggregate(total=Sum('count'))['total']
+            count = count if count else 0
             # 处理用户地区
+            region_dict = {}
             region_list = []
             for item in all_user_qs:
                 country_temp_dict = eval(item['country'])
                 for k, v in country_temp_dict.items():
-                    flag = 0
-                    for each in region_list:
-                        if k == each['countryName']:
-                            each['count'] += v
-                            flag = 1
-                            break
-                    if flag == 0:
-                        region_list.append({
-                            'countryName': k,
-                            'count': v
-                        })
-            for item in region_list:
-                item['rate'] = round(item['count'] / count * 100, 2) if count else 0
+                    if k in region_dict:
+                        region_dict[k] += v
+                    else:
+                        region_dict[k] = v
+            for k, v in region_dict.items():
+                rate = round(v / count * 100, 2) if count else 0
+                region_list.append({
+                    'countryName': k,
+                    'count': v,
+                    'rate': rate
+                })
             # 处理时间段用户
             start_time = datetime.datetime.fromtimestamp(int(start_time))
             end_time = datetime.datetime.fromtimestamp(int(end_time))
@@ -182,54 +182,48 @@ class UserDataView(View):
         @param response:响应对象
         @return:
         """
-        res = {
-            'countries': [],
-        }
+
         try:
             user_qs = DeviceUserSummary.objects.filter(query_type=0).values('count', 'country', 'continent')
             count = user_qs.aggregate(total=Sum('count'))['total']
+            count = count if count else 0
+            continent_dict = {}
+            country_dict = {}
             continent_list = []
             country_list = []
             for item in user_qs:
                 country_temp_dict = eval(item['country'])
                 continent_temp_dict = eval(item['continent'])
-                # 处理用户国家
                 for k, v in country_temp_dict.items():
-                    flag = 0
-                    for each in country_list:
-                        if k == each['countryName']:
-                            each['count'] += v
-                            flag = 1
-                            break
-                    if flag == 0:
-                        country_list.append({
-                            'countryName': k,
-                            'count': v
-                        })
-                # 处理用户大洲
+                    if k in country_dict:
+                        country_dict[k] += v
+                    else:
+                        country_dict[k] = v
                 for k, v in continent_temp_dict.items():
-                    flag = 0
-                    for each in continent_list:
-                        if k == each['continentName']:
-                            each['count'] += v
-                            flag = 1
-                            break
-                    if flag == 0:
-                        continent_list.append({
-                            'continentName': k,
-                            'count': v
-                        })
-                if count:
-                    item['rate'] = round(item['count'] / count * 100, 2)
-                else:
-                    item['rate'] = 0
-
-            for item in country_list:
-                item['rate'] = round(item['count'] / count * 100, 2) if count else 0
-            for item in continent_list:
-                item['rate'] = round(item['count'] / count * 100, 2) if count else 0
-            res['countries'] = country_list
-            res['continent'] = continent_list
+                    if k in continent_dict:
+                        continent_dict[k] += v
+                    else:
+                        continent_dict[k] = v
+            # 处理用户国家
+            for k, v in country_dict.items():
+                rate = round(v / count * 100, 2) if count else 0
+                country_list.append({
+                    'countryName': k,
+                    'count': v,
+                    'rate': rate
+                })
+            # 处理用户大洲
+            for k, v in continent_dict.items():
+                rate = round(v / count * 100, 2) if count else 0
+                continent_list.append({
+                    'continentName': k,
+                    'count': v,
+                    'rate': rate
+                })
+            res = {
+                'countries': country_list,
+                'continent': continent_list
+            }
             return response.json(0, res)
         except Exception as e:
             return response.json(500, repr(e))
@@ -251,7 +245,6 @@ class UserDataView(View):
             user_list = []
             user_count = 0
             region_list = []
-            region_count = 0
             for url in url_list:
                 url = url + request.path.replace('global/', '')
                 res = requests.get(url=url, params=request_dict, headers=headers)
@@ -268,29 +261,22 @@ class UserDataView(View):
                         if flag == 0:
                             user_list.append(item)
                             user_count += item['count']
-                    for item in user_list:
-                        if user_count:
-                            item['rate'] = round(item['count'] / user_count * 100, 2)
-                        else:
-                            item['rate'] = 0
+
                     for item in result['result']['region']:
                         flag = 0
                         for each in region_list:
                             if item['countryName'] == each['countryName']:
                                 each['count'] += item['count']
-                                region_count += item['count']
                                 flag = 1
                                 break
                         if flag == 0:
                             region_list.append(item)
-                            region_count += item['count']
-                    for item in region_list:
-                        if region_count:
-                            item['rate'] = round(item['count'] / region_count * 100, 2)
-                        else:
-                            item['rate'] = 0
                 else:
                     return response.json(result['result_code'], result['result'])
+            for item in user_list:
+                item['rate'] = round(item['count'] / user_count * 100, 2) if user_count else 0
+            for item in region_list:
+                item['rate'] = round(item['count'] / user_count * 100, 2) if user_count else 0
             res = {
                 'user': user_list,
                 'region': CommonService.list_sort(region_list)
@@ -316,7 +302,6 @@ class UserDataView(View):
             user_list = []
             user_count = 0
             region_list = []
-            region_count = 0
             for url in url_list:
                 url = url + request.path.replace('global/', '')
                 res = requests.get(url=url, params=request_dict, headers=headers)
@@ -333,29 +318,23 @@ class UserDataView(View):
                         if flag == 0:
                             user_list.append(item)
                             user_count += item['count']
-                    for item in user_list:
-                        if user_count:
-                            item['rate'] = round(item['count'] / user_count * 100, 2)
-                        else:
-                            item['rate'] = 0
+
                     for item in result['result']['region']:
                         flag = 0
                         for each in region_list:
                             if item['countryName'] == each['countryName']:
                                 each['count'] += item['count']
-                                region_count += item['count']
                                 flag = 1
                                 break
                         if flag == 0:
                             region_list.append(item)
-                            region_count += item['count']
-                    for item in region_list:
-                        if region_count:
-                            item['rate'] = round(item['count'] / region_count * 100, 2)
-                        else:
-                            item['rate'] = 0
+
                 else:
                     return response.json(result['result_code'], result['result'])
+            for item in user_list:
+                item['rate'] = round(item['count'] / user_count * 100, 2) if user_count else 0
+            for item in region_list:
+                item['rate'] = round(item['count'] / user_count * 100, 2) if user_count else 0
             res = {
                 'user': user_list,
                 'region': CommonService.list_sort(region_list)
@@ -377,8 +356,8 @@ class UserDataView(View):
             headers = {
                 'Authorization': request.META.get('HTTP_AUTHORIZATION')
             }
-            user_list = []
-            region_list = []
+            country_list = []
+            continent_list = []
             user_count = 0
             for url in url_list:
                 url = url + request.path.replace('global/', '')
@@ -388,39 +367,33 @@ class UserDataView(View):
                     # 处理地区
                     for item in result['result']['countries']:
                         flag = 0
-                        for each in user_list:
+                        for each in country_list:
                             if each['countryName'] == item['countryName']:
                                 each['count'] += int(item['count'])
                                 user_count += int(item['count'])
                                 flag = 1
                                 break
                         if flag == 0:
-                            user_list.append(item)
+                            country_list.append(item)
                             user_count += int(item['count'])
-                    for item in user_list:
-                        if user_count:
-                            item['rate'] = round(item['count'] / user_count * 100, 2)
-                        else:
-                            item['rate'] = 0
                     for item in result['result']['continent']:
                         flag = 0
-                        for each in region_list:
+                        for each in continent_list:
                             if each['continentName'] == item['continentName']:
                                 each['count'] += item['count']
                                 flag = 1
                                 break
                         if flag == 0:
-                            region_list.append(item)
-                    for item in region_list:
-                        if user_count:
-                            item['rate'] = round(item['count'] / user_count * 100, 2)
-                        else:
-                            item['rate'] = 0
+                            continent_list.append(item)
                 else:
                     return response.json(result['result_code'], result['result'])
+            for item in country_list:
+                item['rate'] = round(item['count'] / user_count * 100, 2) if user_count else 0
+            for item in continent_list:
+                item['rate'] = round(item['count'] / user_count * 100, 2) if user_count else 0
             res = {
-                'countries': CommonService.list_sort(user_list[:20]),
-                'continent': CommonService.list_sort(region_list)
+                'countries': CommonService.list_sort(country_list[:20]),
+                'continent': CommonService.list_sort(continent_list)
             }
             return response.json(0, res)
         except Exception as e:

Controller/Cron/CronTaskController.py

@@ -564,16 +564,9 @@ class CronCollectDataView(View):
                                 device_type_temp_dict[device_type_name] += 1
                         else:
                             if is_pay == 0:
-                                device_type_temp_dict = {
-                                    device_type_name: {
-                                        '数量': 1,
-                                        '销售额': price
-                                    }
-                                }
+                                device_type_temp_dict[device_type_name] = {'数量': 1, '销售额': price}
                             else:
-                                device_type_temp_dict = {
-                                    device_type_name: 1
-                                }
+                                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:
@@ -585,16 +578,9 @@ class CronCollectDataView(View):
                                 store_meal_temp_dict[store_meal_name] += 1
                         else:
                             if is_pay == 0:
-                                store_meal_temp_dict = {
-                                    store_meal_name: {
-                                        '数量': 1,
-                                        '销售额': price
-                                    }
-                                }
+                                store_meal_temp_dict[store_meal_name] = {'数量': 1, '销售额': price}
                             else:
-                                store_meal_temp_dict = {
-                                    store_meal_name: 1
-                                }
+                                store_meal_temp_dict[store_meal_name] = 1
                         order_summary.store_meal = store_meal_temp_dict
                         order_summary.save()
                     else:
@@ -641,12 +627,14 @@ class CronCollectDataView(View):
                 'tb_country',
                 'cloud_vod',
                 'uid',
+                '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',
                                                                                                   'cloud_vod',
+                                                                                                  'is_ai', 'mobile_4g',
                                                                                                   'uid')
             # 国家表数据
             country_qs = CountryModel.objects.values('id', 'country_name', 'region__name')
@@ -679,6 +667,8 @@ class CronCollectDataView(View):
                             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:
@@ -692,6 +682,16 @@ class CronCollectDataView(View):
                                     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:
@@ -699,20 +699,25 @@ class CronCollectDataView(View):
                             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 {
-                                device_type_name: 0}
+                            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)
 
             return response.json(0)