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

AdminController/AiServeController.py

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

AdminController/dataSystemManagement/BusinessDataController.py

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

AdminController/dataSystemManagement/DeviceDataController.py

@@ -13,8 +13,7 @@ import requests
 from django.db.models import Count
 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
 
 
@@ -51,8 +50,6 @@ class DeviceDataView(View):
             return self.golbal_active(request, request_dict, response)
         if operation == 'global/addDevice':  # 全球新增设备数据
             return self.golbal_add_device(request, request_dict, response)
-        else:
-            return response.json(414)
 
     @classmethod
     def golbal_add_device(cls, request, request_dict, response):
@@ -327,18 +324,19 @@ class DeviceDataView(View):
         e_time = datetime.datetime.fromtimestamp(int(end_time))
         time_list = CommonService.cutting_time(s_time, e_time, unit_time)
         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]
             count_all = len(device_info_list)
             res = {}
-            vod_list = []
+            video_list = []
             region_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]
                 rate = round(uid_qs.count() / count_all * 100, 2)
                 vod_dict = {
@@ -347,23 +345,22 @@ class DeviceDataView(View):
                     'startTime': item[0],
                     '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)
         except Exception as e:
             print(e)
@@ -381,23 +378,16 @@ class DeviceDataView(View):
         start_time = request_dict.get('startTime', None)  # 时间戳
         end_time = request_dict.get('endTime', 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:
-            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 = {
                 'addDevice': '',
@@ -409,92 +399,90 @@ class DeviceDataView(View):
             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:
-                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)
                 info_dict = {
                     'startTime': item[0],
                     'endTime': item[1],
-                    'count': len(part_only_list),
+                    'count': count_part,
                     'rate': rate
                 }
                 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)
         except Exception as e:
             print(e)
@@ -506,26 +494,27 @@ class DeviceDataView(View):
         统计地区设备数量
         @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)
         res = {}
         try:
             device_country_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')
                 if not country_qs.exists():
                     name = '未知地区'
                 else:
                     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({
                     'countryName': name,
@@ -559,21 +548,36 @@ class DeviceDataView(View):
         @param response:响应对象
         @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():
             return response.json(444)
         res = {}
         try:
             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({
                     'type': name,
-                    'count': count
+                    'count': count,
+                    'rate': rate
                 })
             res['type'] = device_info_list
             return response.json(0, res)

AdminController/dataSystemManagement/HomeDataController.py

@@ -185,67 +185,70 @@ class HomeDataView(View):
                 url = url + request.path.replace('global/', '')
                 res = requests.get(url=url, params=request_dict, headers=headers)
                 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 = {
                 'userIncreaseCount': user_increase_count,
                 'userActiveCount': user_active_count,
@@ -287,14 +290,17 @@ class HomeDataView(View):
                 url = url + request.path.replace('global/', '')
                 res = requests.get(url=url, params=request_dict, headers=headers)
                 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)
         except Exception as e:
             return response.json(500, repr(e))

AdminController/dataSystemManagement/ServiceDataController.py

@@ -9,7 +9,6 @@
 
 from django.db.models import Q, Count, Sum
 from django.views.generic.base import View
-from Ansjer.config import DEVICE_TYPE
 import datetime
 import requests
 
@@ -93,24 +92,6 @@ class ServiceDataView(View):
                 }
                 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_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:
                         uid_type_dict[device_temp_qs[0]['Type']] = []
                     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():
-                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()
                 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']
-                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 = {
                     'typeName': type_name,
                     'count': device_count,
@@ -147,6 +123,32 @@ class ServiceDataView(View):
                 }
                 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 = []
             if store_meal_type == 0:
@@ -163,6 +165,7 @@ class ServiceDataView(View):
                         '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,
@@ -170,12 +173,17 @@ class ServiceDataView(View):
                         '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:
@@ -184,6 +192,8 @@ class ServiceDataView(View):
                     'storeMealId': store_meal_id,
                     'count': item['count'],
                     'storeMealName': store_meal_name,
+                    'storeMealTotal': store_meal_total,
+                    'totalRate': total_rate,
                     'rate': rate
                 }
                 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)
             # 转化率
             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:
                 uidset_count = uidset_qs.filter(is_ai=1).count()
             else:
@@ -248,29 +258,13 @@ class ServiceDataView(View):
                 }
                 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_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:
@@ -278,8 +272,8 @@ class ServiceDataView(View):
                 uid_dict[device_type].append(item['UID'])
 
             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()
                 if count:
                     type_rate = round(device_count / count * 100, 2)
@@ -292,6 +286,32 @@ class ServiceDataView(View):
                 }
                 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 = {
                 'orders': order_list,
                 'regions': region_list,
@@ -349,37 +369,21 @@ class ServiceDataView(View):
                 }
                 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_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_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()
                 if count:
                     type_rate = round(device_count / count * 100, 2)
@@ -392,11 +396,38 @@ class ServiceDataView(View):
                 }
                 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 = {
                 'orders': order_list,
                 'regions': region_list,
                 'deviceType': device_type_list,
             }
+
             return response.json(0, res)
         except Exception as e:
             return response.json(500, repr(e))
@@ -452,37 +483,21 @@ class ServiceDataView(View):
                 }
                 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_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_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()
                 if count:
                     if count:
@@ -498,6 +513,31 @@ class ServiceDataView(View):
                 }
                 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 = {
                 'orders': order_list,
                 'regions': region_list,
@@ -529,7 +569,7 @@ class ServiceDataView(View):
             region_count = 0
             device_type_list = []
             device_type_count = 0
-            device_type_total = 0
+            total = 0
             store_meal_list = []
             store_meal_count = 0
             for url in url_list:
@@ -573,22 +613,19 @@ class ServiceDataView(View):
                                 each['count'] += int(item['count'])
                                 item['totalMoney'] += item['totalMoney']
                                 device_type_count += int(item['count'])
-                                device_type_total += item['totalMoney']
+                                total += item['totalMoney']
                                 flag = 1
                                 break
                         if flag == 0:
                             device_type_list.append(item)
                             device_type_count += int(item['count'])
-                            device_type_total += item['totalMoney']
+                            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
-                        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['totalRate'] = total_rate
                     # 处理套餐
@@ -597,6 +634,7 @@ class ServiceDataView(View):
                         for each in store_meal_list:
                             if each['storeMealId'] == item['storeMealId']:
                                 each['count'] += int(item['count'])
+                                each['storeMealTotal'] += item['storeMealTotal']
                                 store_meal_count += int(item['count'])
                                 flag = 1
                                 break
@@ -604,13 +642,15 @@ class ServiceDataView(View):
                             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
                 else:
-                    return response.json(result['result_code'])
+                    return response.json(result['result_code'], result['result'])
             res = {
                 'orders': order_list,
                 'regions': CommonService.list_sort(region_list),
@@ -697,7 +737,7 @@ class ServiceDataView(View):
                     new_device_count += int(result['result']['newDeviceCount'])
                     order_device_count += int(result['result']['orderDeviceCount'])
                 else:
-                    return response.json(result['result_code'])
+                    return response.json(result['result_code'], result['result'])
             if new_device_count:
                 inversion_rate = round(order_device_count / new_device_count * 100, 2)
             else:
@@ -785,7 +825,7 @@ class ServiceDataView(View):
                             type_rate = 0
                         item['typeRate'] = type_rate
                 else:
-                    return response.json(result['result_code'])
+                    return response.json(result['result_code'], result['result'])
             res = {
                 'orders': order_list,
                 'regions': CommonService.list_sort(region_list),
@@ -871,7 +911,7 @@ class ServiceDataView(View):
                     repeat_count += result['result']['repeatCount']
                     order_count += result['result']['orderCount']
                 else:
-                    return response.json(result['result_code'])
+                    return response.json(result['result_code'], result['result'])
             if order_count:
                 repeat_rate = round(repeat_count / order_count * 100, 2)
             else:

AdminController/dataSystemManagement/UserDataController.py

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

Ansjer/urls.py

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

Controller/AiController.py

@@ -276,7 +276,7 @@ class AiView(View):
             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')). \
                 values("ai_meal_id", "title", "content", "price", "effective_day", "currency", "virtual_price",
-                       "symbol")
+                       "symbol", "is_beta")
             if not ai_meal_qs.exists():
                 return response.json(0)
 

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')
-        if popups_obj.exists:
+        if popups_obj.exists():
             popups_status = 0
             if now_time >= popups_obj[0]['start_time'] and now_time <= popups_obj[0]['end_time']:
                 popups_status = 1

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, \
     UnicomComboOrderInfo, UnicomComboExperienceHistory, UnicomDeviceStatusChangePush, SysMsgModel, UnicomFlowPush
+from Object.RedisObject import RedisObject
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
 from Object.UnicomObject import UnicomObjeect
 from Object.utils import LocalDateTimeUtil
 from Object.utils.PayUtil import PayService
 from Service.CommonService import CommonService
-from Object.RedisObject import RedisObject
 
 
 class UnicomComboView(View):
@@ -125,10 +125,11 @@ class UnicomComboView(View):
                 activate_flow = float(flow_details['flowTotalUsage'])
                 flow_total_usage = unicom_api.get_flow_usage_total(iccid)
                 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'] = \
-                    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.pop('flowTotalUsage')
                 cls.update_combo_order_sort(iccid)
@@ -294,6 +295,7 @@ class UnicomComboView(View):
         serial_no = request_dict.get('serialNo', None)
         time_stamp = request_dict.get('timeStamp', None)
         sign = request_dict.get('sign', None)
+        sim = int(request_dict.get('sim', 1))
         logger = logging.getLogger('info')
         logger.info('--->设备调用4G注册接口')
         if not all([iccid, serial_no, sign, time_stamp]):
@@ -307,9 +309,12 @@ class UnicomComboView(View):
             redis = RedisObject()
             with transaction.atomic():
                 # 待完善代码 根据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.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)
                         reset_cache = redis.get_data(key)
                         if reset_cache:
@@ -317,6 +322,8 @@ class UnicomComboView(View):
                             return response.json(0, 'Thirty minutes later to visit again take effect')
                         cls.user_activate_flow(iccid)
                     return response.json(0)
+                if sim == 0:
+                    return response.json(0, '外置卡不保存相关信息{}'.format(serial_no))
                 unicom_obj = UnicomObjeect()
                 result = unicom_obj.verify_device(iccid=iccid)
                 if result.status_code == 200 and result.text:
@@ -326,7 +333,7 @@ class UnicomComboView(View):
                             logger.info('--->设备请求绑定{}验证不存在{}'.format(iccid, res_dict))
                             return response.json(173)
                         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)
                         UnicomDeviceInfo.objects.create(**params)
                     return response.json(0)

Controller/UserController.py

@@ -690,7 +690,6 @@ class refreshTokenViewV3(TemplateView):
         lang = request_dict.get('lang', None)
         language = request_dict.get('language', None)
         password = request_dict.get('userPwd', None)
-
         response = ResponseObject(lang)
         if not token:
             return response.json(444, 'token')
@@ -727,7 +726,8 @@ class refreshTokenViewV3(TemplateView):
                     return response.json(104)
                 if not check_password(password, list(user_qs)[0]['password']):
                     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)
             if user_ex_qs.exists():

Model/models.py

@@ -744,6 +744,7 @@ class AiStoreMeal(models.Model):
     symbol = 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_beta = models.SmallIntegerField(default=0, verbose_name=u'是否显示beta')  # 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'第二年优惠价格')
     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='')
     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
-    cloud_vod = models.SmallIntegerField(default=2, verbose_name='云存开关')  # 0,关闭，1开启，2,不支持
     tz = models.CharField(default='', max_length=16, verbose_name='设备时区')  # +8
     video_code = models.SmallIntegerField(default=0, verbose_name='编码类型')  # 0:264,1:265
     nickname = models.CharField(default='', max_length=64, verbose_name='设备昵称')
     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'检测类型')
     pwd = models.CharField(max_length=32, default='', verbose_name=u'设备密码')  # 暂时是预留字段
     resetTime = models.IntegerField(default=0, verbose_name='设备重置时间')
@@ -1187,10 +1186,12 @@ class UidSetModel(models.Model):
     isSupportFourPoint = models.SmallIntegerField(default=0, verbose_name='是否支持预置点')  # 0:不支持, 1:支持
     mobile_4g = models.IntegerField(default=0, verbose_name='是否支持4g。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,不支持
+    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：开启
     new_detect_interval = models.IntegerField(blank=True, verbose_name='新加-消息提醒间隔', default=60)  # 秒
+    tb_country = models.IntegerField(blank=True, default=0, verbose_name='国家')
 
     class Meta:
         db_table = 'uid_set'