Parcourir la source

Merge branch 'test' of http://192.168.136.99:3000/servers/ASJServer

peng il y a 3 ans
Parent
commit
0593aeb23e

+ 2 - 2
AdminController/AiServeController.py

@@ -234,11 +234,11 @@ class AiServeView(View):
         aiMealID = request_dict.get('aiMealID', None)
         aiMealID = request_dict.get('aiMealID', None)
         lang = request_dict.get('lang', None)
         lang = request_dict.get('lang', None)
         title = request_dict.get('title', None)
         title = request_dict.get('title', None)
-        content = request_dict.get('content', None)
+        content = request_dict.get('content', '')
         discount_content = request_dict.get('discountContent', '')
         discount_content = request_dict.get('discountContent', '')
         isEdit = request_dict.get('isEdit', None)
         isEdit = request_dict.get('isEdit', None)
 
 
-        if not all([aiMealID, lang, title, content]):
+        if not all([aiMealID, lang, title]):
             return response.json(444)
             return response.json(444)
 
 
         try:
         try:

+ 1 - 1
AdminController/dataSystemManagement/BusinessDataController.py

@@ -112,7 +112,7 @@ class BusinessDataView(View):
                     play_device_count += int(result['result']['playDeviceCount'])
                     play_device_count += int(result['result']['playDeviceCount'])
                     vod_list += result['result']['vodData']
                     vod_list += result['result']['vodData']
                 else:
                 else:
-                    return response.json(result['result_code'])
+                    return response.json(result['result_code'], result['result'])
             res = {
             res = {
                 'uploadDeviceCount': upload_device_count,
                 'uploadDeviceCount': upload_device_count,
                 'playDeviceCount': play_device_count,
                 'playDeviceCount': play_device_count,

+ 143 - 139
AdminController/dataSystemManagement/DeviceDataController.py

@@ -13,8 +13,7 @@ import requests
 from django.db.models import Count
 from django.db.models import Count
 from django.views.generic.base import View
 from django.views.generic.base import View
 
 
-from Ansjer.config import DEVICE_TYPE
-from Model.models import Device_Info, CountryModel, Order_Model, VodHlsModel
+from Model.models import Device_Info, CountryModel, UidSetModel, DeviceTypeModel, VideoPlaybackTimeModel
 from Service.CommonService import CommonService
 from Service.CommonService import CommonService
 
 
 
 
@@ -51,8 +50,6 @@ class DeviceDataView(View):
             return self.golbal_active(request, request_dict, response)
             return self.golbal_active(request, request_dict, response)
         if operation == 'global/addDevice':  # 全球新增设备数据
         if operation == 'global/addDevice':  # 全球新增设备数据
             return self.golbal_add_device(request, request_dict, response)
             return self.golbal_add_device(request, request_dict, response)
-        else:
-            return response.json(414)
 
 
     @classmethod
     @classmethod
     def golbal_add_device(cls, request, request_dict, response):
     def golbal_add_device(cls, request, request_dict, response):
@@ -327,18 +324,19 @@ class DeviceDataView(View):
         e_time = datetime.datetime.fromtimestamp(int(end_time))
         e_time = datetime.datetime.fromtimestamp(int(end_time))
         time_list = CommonService.cutting_time(s_time, e_time, unit_time)
         time_list = CommonService.cutting_time(s_time, e_time, unit_time)
         try:
         try:
-            vod_hls_model_qs = VodHlsModel.objects.filter(time__range=(start_time, end_time))
-            if not vod_hls_model_qs.exists():
-                return response.json(173)
-            device_info = list(vod_hls_model_qs.values('uid').order_by('uid').distinct())
+            video_playback_time_qs = VideoPlaybackTimeModel.objects.filter(startTime__range=(start_time, end_time))
+            null_list = []
+            if not video_playback_time_qs.exists():
+                return response.json(0, null_list)
+            device_info = list(video_playback_time_qs.values('uid').order_by('uid').distinct())
             device_info_list = [item[key] for item in device_info for key in item]
             device_info_list = [item[key] for item in device_info for key in item]
             count_all = len(device_info_list)
             count_all = len(device_info_list)
             res = {}
             res = {}
-            vod_list = []
+            video_list = []
             region_list = []
             region_list = []
             for item in time_list:
             for item in time_list:
-                vod_hls_qs = vod_hls_model_qs.filter(time__range=(item[0], item[1]))
-                uid_qs = vod_hls_qs.values('uid').order_by('uid').distinct()
+                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()
                 uid_list = [item[key] for item in uid_qs for key in item]
                 uid_list = [item[key] for item in uid_qs for key in item]
                 rate = round(uid_qs.count() / count_all * 100, 2)
                 rate = round(uid_qs.count() / count_all * 100, 2)
                 vod_dict = {
                 vod_dict = {
@@ -347,23 +345,22 @@ class DeviceDataView(View):
                     'startTime': item[0],
                     'startTime': item[0],
                     'endTime': item[1]
                     'endTime': item[1]
                 }
                 }
-                vod_list.append(vod_dict)
-                res['vodHls'] = vod_list
-                type_country_qs = Device_Info.objects.filter(UID__in=uid_list).values(
-                    'userID__region_country').annotate(count=Count('userID__region_country')).order_by('-count')
-                for item in type_country_qs:
-                    country_id = item['userID__region_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(item['count'] / count_all * 100, 2)
-                    country_dict = {
-                        'countryName': country_name,
-                        'count': item['count'],
-                        'rate': rate
-                    }
-                    region_list.append(country_dict)
-                    res['region'] = region_list
-
+                video_list.append(vod_dict)
+            res['vodHls'] = video_list
+            type_country_qs = UidSetModel.objects.filter(uid__in=device_info_list).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'] / count_all * 100, 2)
+                country_dict = {
+                    'countryName': country_name,
+                    'count': type_country['count'],
+                    'rate': rate
+                }
+                region_list.append(country_dict)
+            res['region'] = region_list
             return response.json(0, res)
             return response.json(0, res)
         except Exception as e:
         except Exception as e:
             print(e)
             print(e)
@@ -381,23 +378,16 @@ class DeviceDataView(View):
         start_time = request_dict.get('startTime', None)  # 时间戳
         start_time = request_dict.get('startTime', None)  # 时间戳
         end_time = request_dict.get('endTime', None)
         end_time = request_dict.get('endTime', None)
         unit_time = request_dict.get('timeUnit', None)
         unit_time = request_dict.get('timeUnit', None)
-        order_type = request_dict.get('orderType', None)
-        if not all([start_time, end_time, unit_time, order_type]):
-            return response.json(444, {'error param': 'startTime or endTime or timeUnit or order_type'})
-        order_type = int(order_type)
-        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)
+        if not all([start_time, end_time, unit_time]):
+            return response.json(444, {'error param': 'startTime or endTime or timeUnit'})
         try:
         try:
-            device_info_qs = Device_Info.objects.filter(data_joined__range=(start_time, end_time))
-            device_test_qs = Device_Info.objects.filter(data_joined__lt=start_time)
-            device_test = list(device_test_qs.values('UID').order_by('UID').distinct())
-            device_info = list(device_info_qs.values('UID').order_by('UID').distinct())
-            test_list = [item[key] for item in device_test for key in item]
-            device_info_list = [item[key] for item in device_info for key in item]
-            part_only_list = list(set(device_info_list) - set(test_list))
-            count_all = len(part_only_list)
-            count_all = int(count_all)
+            uid_set_qs = UidSetModel.objects.filter(addTime__range=(start_time, end_time))
+            null_list = []
+            if not uid_set_qs.exists():
+                return response.json(0, null_list)
+            uid_qs = uid_set_qs.values('uid')
+            uid_list = [item[key] for item in uid_qs for key in item]
+            count_all = uid_set_qs.count()
             # 统计该时间段的设备数量(已去重)
             # 统计该时间段的设备数量(已去重)
             res = {
             res = {
                 'addDevice': '',
                 'addDevice': '',
@@ -409,92 +399,90 @@ class DeviceDataView(View):
             region_list = []
             region_list = []
             type_list = []
             type_list = []
             version_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:
             for item in time_list:
-                start_time = datetime.datetime.fromtimestamp(int(item[0]))
-                end_time = datetime.datetime.fromtimestamp(int(item[1]))
-                device_qs = device_info_qs.filter(data_joined__range=(start_time, end_time))
-                device_test_qs = Device_Info.objects.filter(data_joined__lt=start_time)
-                device_test = list(device_test_qs.values('UID').order_by('UID').distinct())
-                device_info = list(device_qs.values('UID').order_by('UID').distinct())
-                test_list = [item[key] for item in device_test for key in item]
-                device_info_list = [item[key] for item in device_info for key in item]
-                part_only_list = list(set(device_info_list) - set(test_list))
-                count_part = len(part_only_list)
+                deivce_uid_qs = uid_set_qs.filter(addTime__range=(item[0], item[1]))
+                uid_qs = deivce_uid_qs.values('uid')
+                uid_list = [item[key] for item in uid_qs for key in item]
+                count_part = deivce_uid_qs.count()
                 rate = round(count_part / count_all * 100, 2)
                 rate = round(count_part / count_all * 100, 2)
                 info_dict = {
                 info_dict = {
                     'startTime': item[0],
                     'startTime': item[0],
                     'endTime': item[1],
                     'endTime': item[1],
-                    'count': len(part_only_list),
+                    'count': count_part,
                     'rate': rate
                     'rate': rate
                 }
                 }
                 info_list.append(info_dict)
                 info_list.append(info_dict)
-                res['addDevice'] = info_list
                 # 统计地区设备数量
                 # 统计地区设备数量
-                device_info_country_qs = device_info_qs.filter(UID__in=part_only_list).values(
-                    'userID__region_country').annotate(
-                    count=Count('userID__region_country')).order_by('-count')
-                for item in device_info_country_qs:
-                    country_id = item['userID__region_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_qs = device_info_qs.filter(UID__in=part_only_list).values('UID').order_by(
-                        'UID').distinct().values(
-                        'userID__region_country')
-                    total_list = [item[key] for item in country_qs for key in item]
-                    country_count = total_list.count(country_id)
-                    rate = round(country_count / count_part * 100, 2)
-                    country_dict = {
-                        'countryName': country_name,
-                        'count': country_count,
-                        'rate': rate
-                    }
-                    region_list.append(country_dict)
-                    res['region'] = CommonService.list_sort(region_list)
-                # 统计设备类型数量
-                device_info_type_qs = device_info_qs.filter(UID__in=part_only_list).values('Type').annotate(
-                    count=Count('Type', distinct=True)).order_by('-count').distinct()
-                count = device_info_type_qs.count()
-                for device_type in device_info_type_qs:
-                    type = device_type['Type']
-                    name = DEVICE_TYPE.get(type, '未知类型')
-                    name = name if name != 'UNKOWN' else '未知类型'
-                    type_qs = device_info_qs.filter(UID__in=part_only_list).values('UID').order_by(
-                        'UID').distinct().values(
-                        'Type')
-                    test_list = [item[key] for item in type_qs for key in item]
-                    type_count = test_list.count(type)
-                    rate = round(type_count / count_part * 100, 2)
-                    type_dict = {
-                        'type': name,
-                        'count': type_count,
-                        'rate': rate
-                    }
-                    type_list.append(type_dict)
-                    res['type'] = CommonService.list_sort(type_list)
-                # 统计设备版本数量
-                order_model_qs = Order_Model.objects.filter(UID__in=part_only_list).values('UID').annotate(
-                    count=Count('UID', distinct=True))
-                order_model_qs = order_model_qs.filter(order_type=order_type).values('order_type', 'UID').order_by(
-                    'UID')
-                order_type_list = []
-                for order_model in order_model_qs:
-                    orderType = order_model['UID']
-                    order_type_list.append(orderType)
-                res_part = {}
-                device_info_type_qs = device_info_qs.filter(UID__in=order_type_list).values('Type').annotate(
-                    count=Count('Type', distinct=True)).order_by('-count').distinct()
-                for device_type in device_info_type_qs:
-                    type = device_type['Type']
-                    name = DEVICE_TYPE.get(type, '未知类型')
-                    res_part['type'] = name if name != 'UNKOWN' else '未知类型'
-                    type_qs = device_info_qs.filter(UID__in=order_type_list).values('UID').order_by(
-                        'UID').distinct().values(
-                        'Type')
-                    test_list = [item[key] for item in type_qs for key in item]
-                    res_part['count'] = test_list.count(type)
-                    res_part['rate'] = round(res_part['count'] / count_part * 100, 2)
-                    version_list.append(res_part)
-                    res['version'] = version_list
+            device_info_country_qs = uid_set_qs.values('tb_country').annotate(
+                count=Count('tb_country')).order_by(
+                '-count')
+            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_qs = uid_set_qs.values('tb_country')
+                total_list = [item[key] for item in country_qs for key in item]
+                country_count = total_list.count(country_id)
+                rate = round(country_count / count_all * 100, 2)
+                country_dict = {
+                    'countryName': country_name,
+                    'count': country_count,
+                    'rate': rate
+                }
+                region_list.append(country_dict)
+            # 统计设备类型数量
+            device_info_type_qs = Device_Info.objects.filter(UID__in=uid_list)
+            device_type_qs = device_info_type_qs.values('Type').annotate(
+                count=Count('Type', distinct=True)).order_by('-count').distinct()
+            count = device_info_type_qs.count()
+            name = '未知类型'
+            count_remain = count_all - count
+            rate = round(count_remain / count_all * 100, 2)
+            type_list.append({
+                'type': name,
+                'count': count_remain,
+                'rate': rate
+            })
+            for device_type in device_type_qs:
+                Type = device_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_qs = device_info_type_qs.values('Type')
+                test_list = [item[key] for item in type_qs for key in item]
+                type_count = test_list.count(Type)
+                rate = round(type_count / count_all * 100, 2)
+                type_list.append({
+                    'type': name,
+                    'count': type_count,
+                    'rate': rate
+                })
+            # 云存版本数量
+            cloud_qs = uid_set_qs.exclude(cloud_vod=2).values('uid')
+            cloud_list = [item[key] for item in cloud_qs for key in item]
+            device_info_type_qs = Device_Info.objects.filter(UID__in=cloud_list).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]
+            for cloud_type in cloud_type_qs:
+                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)
+                version_list.append({
+                    'type': name,
+                    'count': 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)
             return response.json(0, res)
         except Exception as e:
         except Exception as e:
             print(e)
             print(e)
@@ -506,26 +494,27 @@ class DeviceDataView(View):
         统计地区设备数量
         统计地区设备数量
         @param response:响应对象
         @param response:响应对象
         """
         """
-        device_country_qs = Device_Info.objects.all().values('userID__region_country').annotate(
-            count=Count('userID__region_country')).order_by('-count')
-        device_info_qs = Device_Info.objects.values('UID').order_by('UID').distinct()
-        count_all = device_info_qs.count()
-        if not device_country_qs.exists():
+        uid_set_qs = UidSetModel.objects.all()
+        tb_country_qs = uid_set_qs.values('tb_country').annotate(
+            count=Count('tb_country')).order_by('-count')
+        uid_set = uid_set_qs.values('uid')
+        count_all = uid_set.count()
+        if not uid_set_qs.exists():
             return response.json(444)
             return response.json(444)
         res = {}
         res = {}
         try:
         try:
             device_country_list = []
             device_country_list = []
             continent_list = []
             continent_list = []
-            for device_country in device_country_qs:
-                country_id = device_country['userID__region_country']
+            for device_country in tb_country_qs:
+                country_id = device_country['tb_country']
                 country_qs = CountryModel.objects.filter(id=country_id).values('country_name', 'region__name')
                 country_qs = CountryModel.objects.filter(id=country_id).values('country_name', 'region__name')
                 if not country_qs.exists():
                 if not country_qs.exists():
                     name = '未知地区'
                     name = '未知地区'
                 else:
                 else:
                     name = country_qs[0]['country_name']
                     name = country_qs[0]['country_name']
-                count = Device_Info.objects.filter(
-                    userID__region_country=device_country['userID__region_country']).values('UID').annotate(
-                    count=Count('UID', distinct=True)).order_by('-count').count()
+                count = uid_set_qs.filter(
+                    tb_country=device_country['tb_country']).values('uid').annotate(
+                    count=Count('uid', distinct=True)).order_by('-count').count()
 
 
                 device_country_list.append({
                 device_country_list.append({
                     'countryName': name,
                     'countryName': name,
@@ -559,21 +548,36 @@ class DeviceDataView(View):
         @param response:响应对象
         @param response:响应对象
         @return:
         @return:
         """
         """
-        device_info_qs = Device_Info.objects.all().values('Type').annotate(count=Count('Type')).order_by('-count')
+        uid_set_qs = UidSetModel.objects.values('uid').order_by('uid')
+        uid_list = [item[key] for item in uid_set_qs for key in item]
+        device_info_qs = Device_Info.objects.filter(UID__in=uid_list)
+        device_type_qs = device_info_qs.values('Type').annotate(count=Count('Type')).order_by('-count')
+        count_all = len(uid_list)
+        device_info_count = device_info_qs.count()
+        # 查询不到(类型)的设备数量
         if not device_info_qs.exists():
         if not device_info_qs.exists():
             return response.json(444)
             return response.json(444)
         res = {}
         res = {}
         try:
         try:
             device_info_list = []
             device_info_list = []
-            for device_info in device_info_qs:
-                type = device_info['Type']
-                name = DEVICE_TYPE.get(type, '未知类型')
-                name = name if name != 'UNKOWN' else '未知类型'
-                count = Device_Info.objects.filter(Type=device_info['Type']).values('UID').annotate(
-                    count=Count('UID', distinct=True)).order_by('-count').count()
+            count = count_all - device_info_count
+            name = '未知类型'
+            rate = round(count / count_all * 100, 2)
+            device_info_list.append({
+                'type': name,
+                'count': count,
+                'rate': rate
+            })
+            for device_info in device_type_qs:
+                Type = device_info['Type']
+                device_type_qs = DeviceTypeModel.objects.filter(type=Type).values('name')
+                name = device_type_qs[0]['name'] if device_type_qs.exists() else '未知类型'
+                count = device_info['count']
+                rate = round(count / count_all * 100, 2)
                 device_info_list.append({
                 device_info_list.append({
                     'type': name,
                     'type': name,
-                    'count': count
+                    'count': count,
+                    'rate': rate
                 })
                 })
             res['type'] = device_info_list
             res['type'] = device_info_list
             return response.json(0, res)
             return response.json(0, res)

+ 74 - 68
AdminController/dataSystemManagement/HomeDataController.py

@@ -185,67 +185,70 @@ class HomeDataView(View):
                 url = url + request.path.replace('global/', '')
                 url = url + request.path.replace('global/', '')
                 res = requests.get(url=url, params=request_dict, headers=headers)
                 res = requests.get(url=url, params=request_dict, headers=headers)
                 result = res.json()
                 result = res.json()
-                user_increase_count += result['result']['userIncreaseCount']
-                user_active_count += result['result']['userActiveCount']
-                user_all_count += result['result']['userAllCount']
-                device_increase_count += result['result']['deviceIncreaseCount']
-                device_active_count += result['result']['deviceActiveCount']
-                device_all_count += result['result']['deviceAllCount']
-                order_total += result['result']['orderTotal']
-                vod_order_total += result['result']['vodOrderTotal']
-                ai_order_total += result['result']['aiOrderTotal']
-                unicom_order_total += result['result']['unicomOrderTotal']
-                order_all_total += result['result']['orderAllTotal']
-                vod_order_all_total += result['result']['vodOrderAllTotal']
-                ai_order_all_total += result['result']['aiOrderAllTotal']
-                unicom_order_all_total += result['result']['unicomOrderAllTotal']
-                for item in result['result']['userIncreaseRegion']:
-                    flag = 0
-                    for each in user_increase_temp_list:
-                        if item['countryName'] == each['countryName']:
-                            each['count'] += item['count']
-                            flag = 1
-                            break
-                    if flag == 0:
-                        user_increase_temp_list.append(item)
+                if result['result_code'] == 0:
+                    user_increase_count += result['result']['userIncreaseCount']
+                    user_active_count += result['result']['userActiveCount']
+                    user_all_count += result['result']['userAllCount']
+                    device_increase_count += result['result']['deviceIncreaseCount']
+                    device_active_count += result['result']['deviceActiveCount']
+                    device_all_count += result['result']['deviceAllCount']
+                    order_total += result['result']['orderTotal']
+                    vod_order_total += result['result']['vodOrderTotal']
+                    ai_order_total += result['result']['aiOrderTotal']
+                    unicom_order_total += result['result']['unicomOrderTotal']
+                    order_all_total += result['result']['orderAllTotal']
+                    vod_order_all_total += result['result']['vodOrderAllTotal']
+                    ai_order_all_total += result['result']['aiOrderAllTotal']
+                    unicom_order_all_total += result['result']['unicomOrderAllTotal']
+                    for item in result['result']['userIncreaseRegion']:
+                        flag = 0
+                        for each in user_increase_temp_list:
+                            if item['countryName'] == each['countryName']:
+                                each['count'] += item['count']
+                                flag = 1
+                                break
+                        if flag == 0:
+                            user_increase_temp_list.append(item)
 
 
-                for item in result['result']['userAllRegion']:
-                    flag = 0
-                    for each in user_all_temp_list:
-                        if item['countryName'] == each['countryName']:
-                            each['count'] += item['count']
-                            flag = 1
-                            break
-                    if flag == 0:
-                        user_all_temp_list.append(item)
-            if user_increase_temp_list:
-                for item in user_increase_temp_list:
-                    if user_increase_count:
-                        rate = round(item['count'] / user_increase_count * 100, 2)
-                    else:
-                        rate = 0
-                    if rate >= 10:
-                        item['rate'] = rate
-                        user_increase_list.append(item)
-                    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_list.append(user_increase_other_dict)
-            if user_all_temp_list:
-                for item in user_all_temp_list:
-                    if user_all_count:
-                        rate = round(item['count'] / user_all_count * 100, 2)
-                    else:
-                        rate = 0
-                    if rate >= 10:
-                        item['rate'] = rate
-                        user_all_list.append(item)
-                    else:
-                        user_all_other_dict['count'] += item['count']
-                if user_all_count:
-                    user_all_other_dict['rate'] = round(user_all_other_dict['count'] / user_all_count * 100, 2)
-                user_all_list.append(user_all_other_dict)
+                    for item in result['result']['userAllRegion']:
+                        flag = 0
+                        for each in user_all_temp_list:
+                            if item['countryName'] == each['countryName']:
+                                each['count'] += item['count']
+                                flag = 1
+                                break
+                        if flag == 0:
+                            user_all_temp_list.append(item)
+                    if user_increase_temp_list:
+                        for item in user_increase_temp_list:
+                            if user_increase_count:
+                                rate = round(item['count'] / user_increase_count * 100, 2)
+                            else:
+                                rate = 0
+                            if rate >= 10:
+                                item['rate'] = rate
+                                user_increase_list.append(item)
+                            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_list.append(user_increase_other_dict)
+                    if user_all_temp_list:
+                        for item in user_all_temp_list:
+                            if user_all_count:
+                                rate = round(item['count'] / user_all_count * 100, 2)
+                            else:
+                                rate = 0
+                            if rate >= 10:
+                                item['rate'] = rate
+                                user_all_list.append(item)
+                            else:
+                                user_all_other_dict['count'] += item['count']
+                        if user_all_count:
+                            user_all_other_dict['rate'] = round(user_all_other_dict['count'] / user_all_count * 100, 2)
+                        user_all_list.append(user_all_other_dict)
+                else:
+                    return response.json(result['result_code'], result['result'])
             res = {
             res = {
                 'userIncreaseCount': user_increase_count,
                 'userIncreaseCount': user_increase_count,
                 'userActiveCount': user_active_count,
                 'userActiveCount': user_active_count,
@@ -287,14 +290,17 @@ class HomeDataView(View):
                 url = url + request.path.replace('global/', '')
                 url = url + request.path.replace('global/', '')
                 res = requests.get(url=url, params=request_dict, headers=headers)
                 res = requests.get(url=url, params=request_dict, headers=headers)
                 result = res.json()
                 result = res.json()
-                for item in result['result']:
-                    flag = 0
-                    for each in order_list:
-                        if item['startTime'] == each['startTime'] and item['endTime'] == each['endTime']:
-                            each['total'] += item['total']
-                            break
-                    if flag == 0:
-                        order_list.append(item)
+                if result['result_code'] == 0:
+                    for item in result['result']:
+                        flag = 0
+                        for each in order_list:
+                            if item['startTime'] == each['startTime'] and item['endTime'] == each['endTime']:
+                                each['total'] += item['total']
+                                break
+                        if flag == 0:
+                            order_list.append(item)
+                else:
+                    return response.json(result['result_code'], result['result'])
             return response.json(0, order_list)
             return response.json(0, order_list)
         except Exception as e:
         except Exception as e:
             return response.json(500, repr(e))
             return response.json(500, repr(e))

+ 139 - 99
AdminController/dataSystemManagement/ServiceDataController.py

@@ -9,7 +9,6 @@
 
 
 from django.db.models import Q, Count, Sum
 from django.db.models import Q, Count, Sum
 from django.views.generic.base import View
 from django.views.generic.base import View
-from Ansjer.config import DEVICE_TYPE
 import datetime
 import datetime
 import requests
 import requests
 
 
@@ -93,24 +92,6 @@ class ServiceDataView(View):
                 }
                 }
                 order_list.append(order_dict)
                 order_list.append(order_dict)
 
 
-            # 区域订单统计
-            region_list = []
-            region_qs = order_qs.values('userID__region_country').annotate(count=Count('UID')).order_by('-count')
-            for item in region_qs:
-                country_id = item['userID__region_country']
-                country_qs = CountryModel.objects.filter(id=country_id).values('country_name')
-                country_name = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
-                if count:
-                    rate = round(item['count'] / count * 100, 2)
-                else:
-                    rate = 0
-                region_dict = {
-                    'countryName': country_name,
-                    'count': item['count'],
-                    'rate': rate
-                }
-                region_list.append(region_dict)
-
             # 设备类型订单统计
             # 设备类型订单统计
             device_type_list = []
             device_type_list = []
             device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
             device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
@@ -123,21 +104,16 @@ class ServiceDataView(View):
                     if device_temp_qs[0]['Type'] not in uid_type_dict:
                     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']] = []
                     uid_type_dict[device_temp_qs[0]['Type']].append(item['UID'])
                     uid_type_dict[device_temp_qs[0]['Type']].append(item['UID'])
-            # device_qs = Device_Info.objects.filter(UID__in=uid_list).values('Type').annotate(
-            #     count=Count('Type', distinct=True)).order_by('-count')
             for k, v in uid_type_dict.items():
             for k, v in uid_type_dict.items():
-                type_name = DEVICE_TYPE.get(k, '未知类型')
-                type_name = type_name if type_name != 'UNKOWN' else '未知类型'
+                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()
                 device_count = order_qs.filter(UID__in=v).count()
                 if count:
                 if count:
                     type_rate = round(device_count / count * 100, 2)
                     type_rate = round(device_count / count * 100, 2)
                 else:
                 else:
                     type_rate = 0
                     type_rate = 0
                 temp_total = order_qs.filter(UID__in=v).aggregate(total=Sum('price'))['total']
                 temp_total = order_qs.filter(UID__in=v).aggregate(total=Sum('price'))['total']
-                if total:
-                    total_rate = round(temp_total / total * 100, 2)
-                else:
-                    total_rate = 0
+                total_rate = round(temp_total / total * 100, 2)
                 device_temp_qs = {
                 device_temp_qs = {
                     'typeName': type_name,
                     'typeName': type_name,
                     'count': device_count,
                     'count': device_count,
@@ -147,6 +123,32 @@ class ServiceDataView(View):
                 }
                 }
                 device_type_list.append(device_temp_qs)
                 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
+                region_temp_dict = {
+                    'countryName': k,
+                    'count': region_order_count,
+                    'rate': rate
+                }
+                region_list.append(region_temp_dict)
+
             # 套餐订单统计
             # 套餐订单统计
             store_meal_list = []
             store_meal_list = []
             if store_meal_type == 0:
             if store_meal_type == 0:
@@ -163,6 +165,7 @@ class ServiceDataView(View):
                         'rank__lang__content')
                         'rank__lang__content')
                     store_meal_name = store_meal_content_qs[0][
                     store_meal_name = store_meal_content_qs[0][
                         'rank__lang__content'] if store_meal_content_qs.exists() else '未知套餐'
                         '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:
                 elif store_meal_type == 1:
                     store_meal_id = item['ai_rank']
                     store_meal_id = item['ai_rank']
                     store_meal_content_qs = store_meal_qs.filter(ai_rank=store_meal_id,
                     store_meal_content_qs = store_meal_qs.filter(ai_rank=store_meal_id,
@@ -170,12 +173,17 @@ class ServiceDataView(View):
                         'ai_rank__lang__content')
                         'ai_rank__lang__content')
                     store_meal_name = store_meal_content_qs[0][
                     store_meal_name = store_meal_content_qs[0][
                         'ai_rank__lang__content'] if store_meal_content_qs.exists() else '未知套餐'
                         '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:
                 else:
                     store_meal_id = item['unify_combo_id']
                     store_meal_id = item['unify_combo_id']
                     store_meal_content_qs = UnicomCombo.objects.filter(id=store_meal_id).values(
                     store_meal_content_qs = UnicomCombo.objects.filter(id=store_meal_id).values(
                         'combo_name')
                         'combo_name')
                     store_meal_name = store_meal_content_qs[0][
                     store_meal_name = store_meal_content_qs[0][
                         'combo_name'] if store_meal_content_qs.exists() else '未知套餐'
                         '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:
                 if count:
                     rate = round(item['count'] / count * 100, 2)
                     rate = round(item['count'] / count * 100, 2)
                 else:
                 else:
@@ -184,6 +192,8 @@ class ServiceDataView(View):
                     'storeMealId': store_meal_id,
                     'storeMealId': store_meal_id,
                     'count': item['count'],
                     'count': item['count'],
                     'storeMealName': store_meal_name,
                     'storeMealName': store_meal_name,
+                    'storeMealTotal': store_meal_total,
+                    'totalRate': total_rate,
                     'rate': rate
                     'rate': rate
                 }
                 }
                 store_meal_list.append(store_meal_dict)
                 store_meal_list.append(store_meal_dict)
@@ -227,7 +237,7 @@ class ServiceDataView(View):
             time_list = CommonService.cutting_time(start_time, end_time, time_unit)
             time_list = CommonService.cutting_time(start_time, end_time, time_unit)
             # 转化率
             # 转化率
             if store_meal_type == 0:
             if store_meal_type == 0:
-                uidset_count = uidset_qs.filter(is_vod=1).count()
+                uidset_count = uidset_qs.filter(~Q(cloud_vod=2)).count()
             elif store_meal_type == 1:
             elif store_meal_type == 1:
                 uidset_count = uidset_qs.filter(is_ai=1).count()
                 uidset_count = uidset_qs.filter(is_ai=1).count()
             else:
             else:
@@ -248,29 +258,13 @@ class ServiceDataView(View):
                 }
                 }
                 order_list.append(order_dict)
                 order_list.append(order_dict)
 
 
-            # 区域订单统计
-            region_list = []
-            region_qs = order_qs.values('userID__region_country').annotate(count=Count('UID')).order_by('-count')
-            for item in region_qs:
-                country_id = item['userID__region_country']
-                country_qs = CountryModel.objects.filter(id=country_id).values('country_name')
-                country_name = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
-                if count:
-                    rate = round(item['count'] / count * 100, 2)
-                else:
-                    rate = 0
-                region_dict = {
-                    'countryName': country_name,
-                    'count': item['count'],
-                    'rate': rate
-                }
-                region_list.append(region_dict)
-
             # 设备类型订单统计
             # 设备类型订单统计
             device_type_list = []
             device_type_list = []
             device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
             device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
             uid_dict = {}
             uid_dict = {}
+            uid_list = []
             for item in device_type_qs:
             for item in device_type_qs:
+                uid_list.append(item['UID'])
                 device_qs = Device_Info.objects.filter(UID=item['UID']).values('Type')
                 device_qs = Device_Info.objects.filter(UID=item['UID']).values('Type')
                 device_type = device_qs[0]['Type'] if device_qs.exists() else 0
                 device_type = device_qs[0]['Type'] if device_qs.exists() else 0
                 if device_type not in uid_dict:
                 if device_type not in uid_dict:
@@ -278,8 +272,8 @@ class ServiceDataView(View):
                 uid_dict[device_type].append(item['UID'])
                 uid_dict[device_type].append(item['UID'])
 
 
             for k, v in uid_dict.items():
             for k, v in uid_dict.items():
-                type_name = DEVICE_TYPE.get(k, '未知类型')
-                type_name = type_name if type_name != 'UNKOWN' else '未知类型'
+                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()
                 device_count = order_qs.filter(UID__in=v).count()
                 if count:
                 if count:
                     type_rate = round(device_count / count * 100, 2)
                     type_rate = round(device_count / count * 100, 2)
@@ -292,6 +286,32 @@ class ServiceDataView(View):
                 }
                 }
                 device_type_list.append(device_temp_qs)
                 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
+                region_temp_dict = {
+                    'countryName': k,
+                    'count': region_order_count,
+                    'rate': rate
+                }
+                region_list.append(region_temp_dict)
+
             res = {
             res = {
                 'orders': order_list,
                 'orders': order_list,
                 'regions': region_list,
                 'regions': region_list,
@@ -349,37 +369,21 @@ class ServiceDataView(View):
                 }
                 }
                 order_list.append(order_dict)
                 order_list.append(order_dict)
 
 
-            # 区域订单统计
-            region_list = []
-            region_qs = order_qs.values('userID__region_country').annotate(count=Count('UID')).order_by('-count')
-            for item in region_qs:
-                country_id = item['userID__region_country']
-                country_qs = CountryModel.objects.filter(id=country_id).values('country_name')
-                country_name = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
-                if count:
-                    rate = round(item['count'] / count * 100, 2)
-                else:
-                    rate = 0
-                region_dict = {
-                    'countryName': country_name,
-                    'count': item['count'],
-                    'rate': rate
-                }
-                region_list.append(region_dict)
-
             # 设备类型订单统计
             # 设备类型订单统计
             device_type_list = []
             device_type_list = []
             device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
             device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
             uid_dict = {}
             uid_dict = {}
+            uid_list = []
             for item in device_type_qs:
             for item in device_type_qs:
+                uid_list.append(item['UID'])
                 device_qs = Device_Info.objects.filter(UID=item['UID']).values('Type')
                 device_qs = Device_Info.objects.filter(UID=item['UID']).values('Type')
                 device_type = device_qs[0]['Type'] if device_qs.exists() else 0
                 device_type = device_qs[0]['Type'] if device_qs.exists() else 0
                 if device_type not in uid_dict:
                 if device_type not in uid_dict:
                     uid_dict[device_type] = []
                     uid_dict[device_type] = []
                 uid_dict[device_type].append(item['UID'])
                 uid_dict[device_type].append(item['UID'])
             for k, v in uid_dict.items():
             for k, v in uid_dict.items():
-                type_name = DEVICE_TYPE.get(k, '未知类型')
-                type_name = type_name if type_name != 'UNKOWN' else '未知类型'
+                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()
                 device_count = order_qs.filter(UID__in=v).count()
                 if count:
                 if count:
                     type_rate = round(device_count / count * 100, 2)
                     type_rate = round(device_count / count * 100, 2)
@@ -392,11 +396,38 @@ class ServiceDataView(View):
                 }
                 }
                 device_type_list.append(device_temp_qs)
                 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
+                region_temp_dict = {
+                    'countryName': k,
+                    'count': region_order_count,
+                    'rate': rate
+                }
+                region_list.append(region_temp_dict)
+
             res = {
             res = {
                 'orders': order_list,
                 'orders': order_list,
                 'regions': region_list,
                 'regions': region_list,
                 'deviceType': device_type_list,
                 'deviceType': device_type_list,
             }
             }
+
             return response.json(0, res)
             return response.json(0, res)
         except Exception as e:
         except Exception as e:
             return response.json(500, repr(e))
             return response.json(500, repr(e))
@@ -452,37 +483,21 @@ class ServiceDataView(View):
                 }
                 }
                 order_list.append(order_dict)
                 order_list.append(order_dict)
 
 
-            # 区域订单统计
-            region_list = []
-            region_qs = order_qs.values('userID__region_country').annotate(count=Count('UID')).order_by('-count')
-            for item in region_qs:
-                country_id = item['userID__region_country']
-                country_qs = CountryModel.objects.filter(id=country_id).values('country_name')
-                country_name = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
-                if count:
-                    rate = round(item['count'] / count * 100, 2)
-                else:
-                    rate = 0
-                region_dict = {
-                    'countryName': country_name,
-                    'count': item['count'],
-                    'rate': rate
-                }
-                region_list.append(region_dict)
-
             # 设备类型订单统计
             # 设备类型订单统计
             device_type_list = []
             device_type_list = []
             device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
             device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
             uid_dict = {}
             uid_dict = {}
+            uid_list = []
             for item in device_type_qs:
             for item in device_type_qs:
+                uid_list.append(item['UID'])
                 device_qs = Device_Info.objects.filter(UID=item['UID']).values('Type')
                 device_qs = Device_Info.objects.filter(UID=item['UID']).values('Type')
                 device_type = device_qs[0]['Type'] if device_qs.exists() else 0
                 device_type = device_qs[0]['Type'] if device_qs.exists() else 0
                 if device_type not in uid_dict:
                 if device_type not in uid_dict:
                     uid_dict[device_type] = []
                     uid_dict[device_type] = []
                 uid_dict[device_type].append(item['UID'])
                 uid_dict[device_type].append(item['UID'])
             for k, v in uid_dict.items():
             for k, v in uid_dict.items():
-                type_name = DEVICE_TYPE.get(k, '未知类型')
-                type_name = type_name if type_name != 'UNKOWN' else '未知类型'
+                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()
                 device_count = order_qs.filter(UID__in=v).count()
                 if count:
                 if count:
                     if count:
                     if count:
@@ -498,6 +513,31 @@ class ServiceDataView(View):
                 }
                 }
                 device_type_list.append(device_temp_qs)
                 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
+                region_temp_dict = {
+                    'countryName': k,
+                    'count': region_order_count,
+                    'rate': rate
+                }
+                region_list.append(region_temp_dict)
             res = {
             res = {
                 'orders': order_list,
                 'orders': order_list,
                 'regions': region_list,
                 'regions': region_list,
@@ -529,7 +569,7 @@ class ServiceDataView(View):
             region_count = 0
             region_count = 0
             device_type_list = []
             device_type_list = []
             device_type_count = 0
             device_type_count = 0
-            device_type_total = 0
+            total = 0
             store_meal_list = []
             store_meal_list = []
             store_meal_count = 0
             store_meal_count = 0
             for url in url_list:
             for url in url_list:
@@ -573,22 +613,19 @@ class ServiceDataView(View):
                                 each['count'] += int(item['count'])
                                 each['count'] += int(item['count'])
                                 item['totalMoney'] += item['totalMoney']
                                 item['totalMoney'] += item['totalMoney']
                                 device_type_count += int(item['count'])
                                 device_type_count += int(item['count'])
-                                device_type_total += item['totalMoney']
+                                total += item['totalMoney']
                                 flag = 1
                                 flag = 1
                                 break
                                 break
                         if flag == 0:
                         if flag == 0:
                             device_type_list.append(item)
                             device_type_list.append(item)
                             device_type_count += int(item['count'])
                             device_type_count += int(item['count'])
-                            device_type_total += item['totalMoney']
+                            total += item['totalMoney']
                     for item in device_type_list:
                     for item in device_type_list:
                         if device_type_count:
                         if device_type_count:
                             type_rate = round(item['count'] / device_type_count * 100, 2)
                             type_rate = round(item['count'] / device_type_count * 100, 2)
                         else:
                         else:
                             type_rate = 0
                             type_rate = 0
-                        if device_type_total:
-                            total_rate = round(item['totalMoney'] / device_type_total * 100, 2)
-                        else:
-                            total_rate = 0
+                        total_rate = round(item['totalMoney'] / total * 100, 2)
                         item['typeRate'] = type_rate
                         item['typeRate'] = type_rate
                         item['totalRate'] = total_rate
                         item['totalRate'] = total_rate
                     # 处理套餐
                     # 处理套餐
@@ -597,6 +634,7 @@ class ServiceDataView(View):
                         for each in store_meal_list:
                         for each in store_meal_list:
                             if each['storeMealId'] == item['storeMealId']:
                             if each['storeMealId'] == item['storeMealId']:
                                 each['count'] += int(item['count'])
                                 each['count'] += int(item['count'])
+                                each['storeMealTotal'] += item['storeMealTotal']
                                 store_meal_count += int(item['count'])
                                 store_meal_count += int(item['count'])
                                 flag = 1
                                 flag = 1
                                 break
                                 break
@@ -604,13 +642,15 @@ class ServiceDataView(View):
                             store_meal_list.append(item)
                             store_meal_list.append(item)
                             store_meal_count += int(item['count'])
                             store_meal_count += int(item['count'])
                     for item in store_meal_list:
                     for item in store_meal_list:
+                        total_rate = round(item['storeMealTotal'] / total * 100, 2)
                         if store_meal_count:
                         if store_meal_count:
                             rate = round(item['count'] / store_meal_count * 100, 2)
                             rate = round(item['count'] / store_meal_count * 100, 2)
                         else:
                         else:
                             rate = 0
                             rate = 0
                         item['rate'] = rate
                         item['rate'] = rate
+                        item['totalRate'] = total_rate
                 else:
                 else:
-                    return response.json(result['result_code'])
+                    return response.json(result['result_code'], result['result'])
             res = {
             res = {
                 'orders': order_list,
                 'orders': order_list,
                 'regions': CommonService.list_sort(region_list),
                 'regions': CommonService.list_sort(region_list),
@@ -697,7 +737,7 @@ class ServiceDataView(View):
                     new_device_count += int(result['result']['newDeviceCount'])
                     new_device_count += int(result['result']['newDeviceCount'])
                     order_device_count += int(result['result']['orderDeviceCount'])
                     order_device_count += int(result['result']['orderDeviceCount'])
                 else:
                 else:
-                    return response.json(result['result_code'])
+                    return response.json(result['result_code'], result['result'])
             if new_device_count:
             if new_device_count:
                 inversion_rate = round(order_device_count / new_device_count * 100, 2)
                 inversion_rate = round(order_device_count / new_device_count * 100, 2)
             else:
             else:
@@ -785,7 +825,7 @@ class ServiceDataView(View):
                             type_rate = 0
                             type_rate = 0
                         item['typeRate'] = type_rate
                         item['typeRate'] = type_rate
                 else:
                 else:
-                    return response.json(result['result_code'])
+                    return response.json(result['result_code'], result['result'])
             res = {
             res = {
                 'orders': order_list,
                 'orders': order_list,
                 'regions': CommonService.list_sort(region_list),
                 'regions': CommonService.list_sort(region_list),
@@ -871,7 +911,7 @@ class ServiceDataView(View):
                     repeat_count += result['result']['repeatCount']
                     repeat_count += result['result']['repeatCount']
                     order_count += result['result']['orderCount']
                     order_count += result['result']['orderCount']
                 else:
                 else:
-                    return response.json(result['result_code'])
+                    return response.json(result['result_code'], result['result'])
             if order_count:
             if order_count:
                 repeat_rate = round(repeat_count / order_count * 100, 2)
                 repeat_rate = round(repeat_count / order_count * 100, 2)
             else:
             else:

+ 3 - 3
AdminController/dataSystemManagement/UserDataController.py

@@ -276,7 +276,7 @@ class UserDataView(View):
                         else:
                         else:
                             item['rate'] = 0
                             item['rate'] = 0
                 else:
                 else:
-                    return response.json(result['result_code'])
+                    return response.json(result['result_code'], result['result'])
             res = {
             res = {
                 'user': user_list,
                 'user': user_list,
                 'region': CommonService.list_sort(region_list)
                 'region': CommonService.list_sort(region_list)
@@ -341,7 +341,7 @@ class UserDataView(View):
                         else:
                         else:
                             item['rate'] = 0
                             item['rate'] = 0
                 else:
                 else:
-                    return response.json(result['result_code'])
+                    return response.json(result['result_code'], result['result'])
             res = {
             res = {
                 'user': user_list,
                 'user': user_list,
                 'region': CommonService.list_sort(region_list)
                 'region': CommonService.list_sort(region_list)
@@ -403,7 +403,7 @@ class UserDataView(View):
                         else:
                         else:
                             item['rate'] = 0
                             item['rate'] = 0
                 else:
                 else:
-                    return response.json(result['result_code'])
+                    return response.json(result['result_code'], result['result'])
             res = {
             res = {
                 'countries': CommonService.list_sort(user_list[:20]),
                 'countries': CommonService.list_sort(user_list[:20]),
                 'continent': CommonService.list_sort(region_list)
                 'continent': CommonService.list_sort(region_list)

+ 0 - 21
Ansjer/urls.py

@@ -400,24 +400,3 @@ urlpatterns = [
     re_path('(?P<path>.*)', LogManager.errorPath),
     re_path('(?P<path>.*)', LogManager.errorPath),
 
 
 ]
 ]
-
-#                                _(\_/)
-#                              ,((((^`\
-#                             ((((  (6 \
-#                           ,((((( ,    \
-#       ,,,_              ,(((((  /"._  ,`,
-#      ((((\\ ,...       ,((((   /    `-.-'
-#      )))  ;'    `"'"'""((((   (
-#     (((  /            (((      \
-#      )) |                      |
-#     ((  |        .       '     |
-#     ))  \     _ '      `t   ,.')
-#     (   |   y;- -,-""'"-.\   \/
-#     )   / ./  ) /         `\  \
-#        |./   ( (           / /'
-#        ||     \\          //'|
-#        ||      \\       _//'||
-#        ||       ))     |_/  ||
-#        \_\     |_/          ||
-#        `'"                  \_\
-#                             `'"

+ 1 - 1
Controller/AiController.py

@@ -276,7 +276,7 @@ class AiView(View):
             ai_meal_qs = ai_meal_qs.filter(is_show=1, lang__lang=lang). \
             ai_meal_qs = ai_meal_qs.filter(is_show=1, lang__lang=lang). \
                 annotate(ai_meal_id=F('id'), title=F('lang__title'), content=F('lang__content')). \
                 annotate(ai_meal_id=F('id'), title=F('lang__title'), content=F('lang__content')). \
                 values("ai_meal_id", "title", "content", "price", "effective_day", "currency", "virtual_price",
                 values("ai_meal_id", "title", "content", "price", "effective_day", "currency", "virtual_price",
-                       "symbol")
+                       "symbol", "is_beta")
             if not ai_meal_qs.exists():
             if not ai_meal_qs.exists():
                 return response.json(0)
                 return response.json(0)
 
 

+ 1 - 1
Controller/AppSetController.py

@@ -171,7 +171,7 @@ class AppSetView(View):
         }
         }
         #弹窗
         #弹窗
         popups_obj = PopupsConfig.objects.filter(lang=lang).values('title','content','start_time','end_time','tag')
         popups_obj = PopupsConfig.objects.filter(lang=lang).values('title','content','start_time','end_time','tag')
-        if popups_obj.exists:
+        if popups_obj.exists():
             popups_status = 0
             popups_status = 0
             if now_time >= popups_obj[0]['start_time'] and now_time <= popups_obj[0]['end_time']:
             if now_time >= popups_obj[0]['start_time'] and now_time <= popups_obj[0]['end_time']:
                 popups_status = 1
                 popups_status = 1

+ 14 - 7
Controller/UnicomCombo/UnicomComboController.py

@@ -19,13 +19,13 @@ from django.views.generic.base import View
 
 
 from Model.models import UnicomDeviceInfo, UnicomCombo, Pay_Type, Order_Model, Store_Meal, AiStoreMeal, \
 from Model.models import UnicomDeviceInfo, UnicomCombo, Pay_Type, Order_Model, Store_Meal, AiStoreMeal, \
     UnicomComboOrderInfo, UnicomComboExperienceHistory, UnicomDeviceStatusChangePush, SysMsgModel, UnicomFlowPush
     UnicomComboOrderInfo, UnicomComboExperienceHistory, UnicomDeviceStatusChangePush, SysMsgModel, UnicomFlowPush
+from Object.RedisObject import RedisObject
 from Object.ResponseObject import ResponseObject
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
 from Object.TokenObject import TokenObject
 from Object.UnicomObject import UnicomObjeect
 from Object.UnicomObject import UnicomObjeect
 from Object.utils import LocalDateTimeUtil
 from Object.utils import LocalDateTimeUtil
 from Object.utils.PayUtil import PayService
 from Object.utils.PayUtil import PayService
 from Service.CommonService import CommonService
 from Service.CommonService import CommonService
-from Object.RedisObject import RedisObject
 
 
 
 
 class UnicomComboView(View):
 class UnicomComboView(View):
@@ -125,10 +125,11 @@ class UnicomComboView(View):
                 activate_flow = float(flow_details['flowTotalUsage'])
                 activate_flow = float(flow_details['flowTotalUsage'])
                 flow_total_usage = unicom_api.get_flow_usage_total(iccid)
                 flow_total_usage = unicom_api.get_flow_usage_total(iccid)
                 flow = 0 if flow_total_usage <= 0 else flow_total_usage - activate_flow
                 flow = 0 if flow_total_usage <= 0 else flow_total_usage - activate_flow
-                flow_details['usableFlow'] = flow_details['flowTotal'] - flow
-
+                # 因APP问题,usableFlow可用流量替换为,已用流量值
+                flow_details['usableFlow'] = 0 if flow == 0 else flow
                 flow_details['usableFlow'] = \
                 flow_details['usableFlow'] = \
-                    0.00 if flow_details['usableFlow'] <= 0 else flow_details['usableFlow']
+                    flow_details['flowTotal'] if flow_details['usableFlow'] > flow_details['flowTotal'] else \
+                    flow_details['usableFlow']
                 flow_details['usableFlow'] = Decimal(flow_details['usableFlow']).quantize(Decimal('0.00'))
                 flow_details['usableFlow'] = Decimal(flow_details['usableFlow']).quantize(Decimal('0.00'))
                 flow_details.pop('flowTotalUsage')
                 flow_details.pop('flowTotalUsage')
                 cls.update_combo_order_sort(iccid)
                 cls.update_combo_order_sort(iccid)
@@ -294,6 +295,7 @@ class UnicomComboView(View):
         serial_no = request_dict.get('serialNo', None)
         serial_no = request_dict.get('serialNo', None)
         time_stamp = request_dict.get('timeStamp', None)
         time_stamp = request_dict.get('timeStamp', None)
         sign = request_dict.get('sign', None)
         sign = request_dict.get('sign', None)
+        sim = int(request_dict.get('sim', 1))
         logger = logging.getLogger('info')
         logger = logging.getLogger('info')
         logger.info('--->设备调用4G注册接口')
         logger.info('--->设备调用4G注册接口')
         if not all([iccid, serial_no, sign, time_stamp]):
         if not all([iccid, serial_no, sign, time_stamp]):
@@ -307,9 +309,12 @@ class UnicomComboView(View):
             redis = RedisObject()
             redis = RedisObject()
             with transaction.atomic():
             with transaction.atomic():
                 # 待完善代码 根据uid与用户id验证系统设备
                 # 待完善代码 根据uid与用户id验证系统设备
-                unicom_device_qs = UnicomDeviceInfo.objects.filter(iccid=iccid)
+                unicom_device_qs = UnicomDeviceInfo.objects.filter(serial_no=serial_no)
                 if unicom_device_qs.exists():
                 if unicom_device_qs.exists():
-                    if unicom_device_qs.first().status == 1 and unicom_device_qs.first().serial_no == serial_no:
+                    if sim == 0:
+                        unicom_device_qs.update(main_card=sim, updated_time=n_time)
+                        return response.json(0, '切卡修改{}成功'.format(serial_no))
+                    if unicom_device_qs.first().status == 1:
                         key = 'ASJ:UNICOM:RESET:{}'.format(serial_no)
                         key = 'ASJ:UNICOM:RESET:{}'.format(serial_no)
                         reset_cache = redis.get_data(key)
                         reset_cache = redis.get_data(key)
                         if reset_cache:
                         if reset_cache:
@@ -317,6 +322,8 @@ class UnicomComboView(View):
                             return response.json(0, 'Thirty minutes later to visit again take effect')
                             return response.json(0, 'Thirty minutes later to visit again take effect')
                         cls.user_activate_flow(iccid)
                         cls.user_activate_flow(iccid)
                     return response.json(0)
                     return response.json(0)
+                if sim == 0:
+                    return response.json(0, '外置卡不保存相关信息{}'.format(serial_no))
                 unicom_obj = UnicomObjeect()
                 unicom_obj = UnicomObjeect()
                 result = unicom_obj.verify_device(iccid=iccid)
                 result = unicom_obj.verify_device(iccid=iccid)
                 if result.status_code == 200 and result.text:
                 if result.status_code == 200 and result.text:
@@ -326,7 +333,7 @@ class UnicomComboView(View):
                             logger.info('--->设备请求绑定{}验证不存在{}'.format(iccid, res_dict))
                             logger.info('--->设备请求绑定{}验证不存在{}'.format(iccid, res_dict))
                             return response.json(173)
                             return response.json(173)
                         params = {'iccid': iccid, 'serial_no': serial_no, 'updated_time': n_time,
                         params = {'iccid': iccid, 'serial_no': serial_no, 'updated_time': n_time,
-                                  'created_time': n_time}
+                                  'created_time': n_time, 'main_card': sim}
                         unicom_obj.change_device_to_activate(iccid)
                         unicom_obj.change_device_to_activate(iccid)
                         UnicomDeviceInfo.objects.create(**params)
                         UnicomDeviceInfo.objects.create(**params)
                     return response.json(0)
                     return response.json(0)

+ 2 - 2
Controller/UserController.py

@@ -690,7 +690,6 @@ class refreshTokenViewV3(TemplateView):
         lang = request_dict.get('lang', None)
         lang = request_dict.get('lang', None)
         language = request_dict.get('language', None)
         language = request_dict.get('language', None)
         password = request_dict.get('userPwd', None)
         password = request_dict.get('userPwd', None)
-
         response = ResponseObject(lang)
         response = ResponseObject(lang)
         if not token:
         if not token:
             return response.json(444, 'token')
             return response.json(444, 'token')
@@ -727,7 +726,8 @@ class refreshTokenViewV3(TemplateView):
                     return response.json(104)
                     return response.json(104)
                 if not check_password(password, list(user_qs)[0]['password']):
                 if not check_password(password, list(user_qs)[0]['password']):
                     return response.json(111)
                     return response.json(111)
-
+                now_time = datetime.datetime.utcnow().replace(tzinfo=utc).astimezone(utc)
+                user_qs.update(last_login=now_time)
             # 更新用户扩展信息语言
             # 更新用户扩展信息语言
             user_ex_qs = UserExModel.objects.filter(userID_id=userID)
             user_ex_qs = UserExModel.objects.filter(userID_id=userID)
             if user_ex_qs.exists():
             if user_ex_qs.exists():

+ 4 - 3
Model/models.py

@@ -744,6 +744,7 @@ class AiStoreMeal(models.Model):
     symbol = models.CharField(blank=True, default='$', max_length=32, verbose_name=u'符号')
     symbol = models.CharField(blank=True, default='$', max_length=32, verbose_name=u'符号')
     currency = models.CharField(blank=True, default='$', max_length=32, verbose_name=u'货币符号')
     currency = models.CharField(blank=True, default='$', max_length=32, verbose_name=u'货币符号')
     is_show = models.SmallIntegerField(default=0, verbose_name=u'是否显示')  # 0: 否, 1: 是
     is_show = models.SmallIntegerField(default=0, verbose_name=u'是否显示')  # 0: 否, 1: 是
+    is_beta = models.SmallIntegerField(default=0, verbose_name=u'是否显示beta')  # 0: 否, 1: 是
     is_discounts = models.SmallIntegerField(default=0, verbose_name=u'是否有优惠')  # 0: 没有, 1: 有
     is_discounts = models.SmallIntegerField(default=0, verbose_name=u'是否有优惠')  # 0: 没有, 1: 有
     discount_price = models.CharField(blank=True, max_length=32, verbose_name=u'第二年优惠价格')
     discount_price = models.CharField(blank=True, max_length=32, verbose_name=u'第二年优惠价格')
     effective_day = models.IntegerField(default=0, blank=True, verbose_name=u'有效天数')  # 7, 30
     effective_day = models.IntegerField(default=0, blank=True, verbose_name=u'有效天数')  # 7, 30
@@ -1159,13 +1160,11 @@ class UidSetModel(models.Model):
     ucode = models.CharField(max_length=32, verbose_name='设备产品码', default='')
     ucode = models.CharField(max_length=32, verbose_name='设备产品码', default='')
     version = models.CharField(max_length=32, verbose_name='设备版本', default='')
     version = models.CharField(max_length=32, verbose_name='设备版本', default='')
     p2p_region = models.CharField(max_length=16, verbose_name='设备p2p区域', default='ALL')  # ALL CN EU US
     p2p_region = models.CharField(max_length=16, verbose_name='设备p2p区域', default='ALL')  # ALL CN EU US
-    cloud_vod = models.SmallIntegerField(default=2, verbose_name='云存开关')  # 0,关闭,1开启,2,不支持
     tz = models.CharField(default='', max_length=16, verbose_name='设备时区')  # +8
     tz = models.CharField(default='', max_length=16, verbose_name='设备时区')  # +8
     video_code = models.SmallIntegerField(default=0, verbose_name='编码类型')  # 0:264,1:265
     video_code = models.SmallIntegerField(default=0, verbose_name='编码类型')  # 0:264,1:265
     nickname = models.CharField(default='', max_length=64, verbose_name='设备昵称')
     nickname = models.CharField(default='', max_length=64, verbose_name='设备昵称')
     ip = models.CharField(max_length=20, default='', verbose_name=u'设备ip')
     ip = models.CharField(max_length=20, default='', verbose_name=u'设备ip')
     # 设备重置后第一次启动时间
     # 设备重置后第一次启动时间
-    is_alexa = models.IntegerField(default=0, verbose_name='是否支持alexa')  # 0为不支持,1为支持,2为开启alexa发现
     detect_group = models.CharField(default='', max_length=32, verbose_name=u'检测类型')
     detect_group = models.CharField(default='', max_length=32, verbose_name=u'检测类型')
     pwd = models.CharField(max_length=32, default='', verbose_name=u'设备密码')  # 暂时是预留字段
     pwd = models.CharField(max_length=32, default='', verbose_name=u'设备密码')  # 暂时是预留字段
     resetTime = models.IntegerField(default=0, verbose_name='设备重置时间')
     resetTime = models.IntegerField(default=0, verbose_name='设备重置时间')
@@ -1187,10 +1186,12 @@ class UidSetModel(models.Model):
     isSupportFourPoint = models.SmallIntegerField(default=0, verbose_name='是否支持预置点')  # 0:不支持, 1:支持
     isSupportFourPoint = models.SmallIntegerField(default=0, verbose_name='是否支持预置点')  # 0:不支持, 1:支持
     mobile_4g = models.IntegerField(default=0, verbose_name='是否支持4g。0:不支持,1:支持')
     mobile_4g = models.IntegerField(default=0, verbose_name='是否支持4g。0:不支持,1:支持')
     is_ptz = models.IntegerField(default=0, verbose_name='是否支持云台。0:不支持,1:支持')
     is_ptz = models.IntegerField(default=0, verbose_name='是否支持云台。0:不支持,1:支持')
-    is_vod = models.IntegerField(default=0, verbose_name='是否支持云存储。0:不支持,1:支持')
     is_ai = models.IntegerField(default=2, verbose_name='是否支持ai')  # 0,关闭,1开启,2,不支持
     is_ai = models.IntegerField(default=2, verbose_name='是否支持ai')  # 0,关闭,1开启,2,不支持
+    cloud_vod = models.SmallIntegerField(default=2, verbose_name='云存开关')  # 0,关闭,1开启,2,不支持
+    is_alexa = models.IntegerField(default=0, verbose_name='是否支持alexa')  # 0为不支持,1为支持,2为开启alexa发现
     is_notification = models.IntegerField(blank=True, default=1, verbose_name='新加-消息提醒开关')  # 0:关闭,1:开启
     is_notification = models.IntegerField(blank=True, default=1, verbose_name='新加-消息提醒开关')  # 0:关闭,1:开启
     new_detect_interval = models.IntegerField(blank=True, verbose_name='新加-消息提醒间隔', default=60)  # 秒
     new_detect_interval = models.IntegerField(blank=True, verbose_name='新加-消息提醒间隔', default=60)  # 秒
+    tb_country = models.IntegerField(blank=True, default=0, verbose_name='国家')
 
 
     class Meta:
     class Meta:
         db_table = 'uid_set'
         db_table = 'uid_set'