合并test分支代码

AdminController/AiServeController.py

@@ -3,7 +3,7 @@
 import time
 
 from django.views.generic.base import View
-from Model.models import Lang, AiStoreMeal, AiService, Order_Model
+from Model.models import Lang, AiStoreMeal, AiService, Order_Model, Device_User, CountryModel, UidSetModel
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
 from Service.CommonService import CommonService
@@ -392,7 +392,7 @@ class AiServeView(View):
                 'status',
                 'refunded_amount',
                 'addTime',
-                'updTime',
+                'updTime', 'userID_id',
             )[(page - 1) * line:page * line]
             data_list = []
             for order in order_qs:
@@ -410,6 +410,17 @@ class AiServeView(View):
                     'addTime': order['addTime'],
                     'updTime': order['updTime'],
                 }
+                dev_user_qs = Device_User.objects.filter(userID=order['userID_id']).values('region_country')
+                region_country = dev_user_qs.first()['region_country']
+                country = '未知国家'
+                if region_country > 0:
+                    country = '未知国家'
+                country_qs = CountryModel.objects.filter(id=region_country).values('country_name')
+                if country_qs.exists():
+                    country = country_qs.first()['country_name']
+                data_dict['country'] = country
+                uid_set_qs = UidSetModel.objects.filter(uid=order['UID']).values('version')
+                data_dict['version'] = uid_set_qs.first()['version'] if uid_set_qs.exists() else ''
                 ai_service_qs = AiService.objects.filter(
                     orders_id=order['orderID']).values(
                     'endTime', 'use_status')

AdminController/DeviceManagementController.py

@@ -216,15 +216,23 @@ class DeviceManagement(View):
                         device_info_list["datas"][k]['fields']['username'] = username
                         device_info_list["datas"][k]['fields']['vodPrimaryMaster'] = \
                             device_info_list["datas"][k]['fields']['vodPrimaryMaster']
+                        # 是否支持移动侦测
+                        iSNotification = '开' if device_info_list["datas"][k]['fields']['iSNotification'] == 1  else '关'
+                        device_info_list["datas"][k]['fields']['iSNotification'] = iSNotification
                         # 设备类型,是否支持Alexa和ip
                         type = device_info_list["datas"][k]['fields']['Type']
                         device_type_qs = DeviceTypeModel.objects.filter(type=type).values('name')
                         if device_type_qs.exists():
                             device_info_list["datas"][k]['fields']['Type'] = device_type_qs[0]['name']
                         uid_set_qs = UidSetModel.objects.filter(
-                            uid=device_info_list["datas"][k]['fields']['UID']).values('is_alexa', 'ip', 'version')
+                            uid=device_info_list["datas"][k]['fields']['UID']).values('is_alexa', 'ip', 'version',
+                                                                                      'is_ai', 'is_human')
                         if uid_set_qs.exists():
                             isAlexa = '是' if uid_set_qs[0]['is_alexa'] else '否'
+                            isAI = '否' if uid_set_qs[0]['is_ai']==2 else '是'
+                            isHuman = '是' if uid_set_qs[0]['is_human'] else '否'
+                            device_info_list["datas"][k]['fields']['isHuman'] = isHuman
+                            device_info_list["datas"][k]['fields']['isAI'] = isAI
                             device_info_list["datas"][k]['fields']['isAlexa'] = isAlexa
                             device_info_list["datas"][k]['fields']['ip'] = uid_set_qs[0]['ip']
                             device_info_list["datas"][k]['fields']['version'] = uid_set_qs[0]['version']
@@ -449,9 +457,10 @@ class DeviceManagement(View):
 
     @staticmethod
     def get_device_icon(request_dict, response):
-        lang = request_dict.get('lang', None)
+        # lang = request_dict.get('lang', None)
         app_bundle_id = request_dict.get('appBundleId', None)
         version_number = request_dict.get('versionNumber', None)
+        lang = 'en'
         if not all([lang, app_bundle_id, version_number]):
             return response.json(444)
         version_number_qs = AppVersionNumber.objects.filter(app_bundle__app_bundle_id=app_bundle_id,

AdminController/dataSystemManagement/BusinessDataController.py

@@ -8,10 +8,10 @@
 """
 
 import requests
-from django.db.models import Q, Count, Sum
+from django.db.models import Count, Sum
 from django.views.generic.base import View
 
-from Model.models import VodHlsModel, VideoPlaybackTimeModel
+from Model.models import VodHlsModel, VodHlsSummary
 from Service.CommonService import CommonService
 
 
@@ -54,33 +54,40 @@ class BusinessDataView(View):
         if not all([start_time, end_time]):
             return response.json(444, {'error param': 'startTime or endTime'})
         try:
-            vod_hls_qs = VodHlsModel.objects.filter(time__range=(start_time, end_time))
-            video_play_qs = VideoPlaybackTimeModel.objects.filter(startTime__range=(start_time, end_time),
-                                                                  playMode='could')
-            upload_duration_qs = vod_hls_qs.values('uid').annotate(uploadFrequency=Count('uid')).order_by(
-                'uploadFrequency')
-            upload_device_count = len(upload_duration_qs)  # 上传设备数量
-            uid_list = []
-            for item in upload_duration_qs:
-                item['uploadDuration'] = vod_hls_qs.filter(uid=item['uid']).aggregate(total=Sum('sec'))['total']
-                item['playDuration'] = video_play_qs.filter(uid=item['uid']).aggregate(total=Sum('duration'))['total']
-                item['playDuration'] = item['playDuration'] if item['playDuration'] else 0
-                item['playFrequency'] = video_play_qs.filter(uid=item['uid'], playMode='cloud').count()
-                uid_list.append(item['uid'])
+            vod_hls_summary_qs = VodHlsSummary.objects.filter(time__gte=start_time, time__lt=end_time).values()
+            vod_hls_qs = VodHlsModel.objects.filter(endTime__gte=start_time, endTime__lt=end_time).values(
+                'uid').annotate(uploadFrequency=Count('uid'), uploadDuration=Sum('sec')).order_by('uploadFrequency')
+            vod_hls_summary_list = list(vod_hls_summary_qs)
+
+            for item in vod_hls_qs:
+                flag = 0
+                for each in vod_hls_summary_list:
+                    if each['uid'] == item['uid']:
+                        each['upload_duration'] += item['uploadDuration']
+                        each['upload_frequency'] += item['uploadFrequency']
+                        flag = 1
+                if flag == 0:
+                    vod_hls_summary_list.append({
+                        'uid': item['uid'],
+                        'upload_duration': item['uploadDuration'],
+                        'upload_frequency': item['uploadFrequency'],
+                        'play_frequency': 0,
+                        'play_duration': 0
+                    })
+            vod_hls_result = []
+            for item in vod_hls_summary_list:
+                vod_hls_result.append({
+                    'uid': item['uid'],
+                    'uploadDuration': item['upload_duration'],
+                    'uploadFrequency': item['upload_frequency'],
+                    'playFrequency': item['play_frequency'],
+                    'playDuration': item['play_duration']
+                })
+            upload_device_count = len(vod_hls_result)  # 上传设备数量
 
-            video_play_qs = video_play_qs.filter(~Q(uid__in=uid_list))
-            play_duration_qs = video_play_qs.values('uid').annotate(playFrequency=Count('uid')).order_by(
-                'playFrequency')
-            play_device_count = play_duration_qs.count()
-            for item in play_duration_qs:
-                item['uploadFrequency'] = 0
-                item['uploadDuration'] = 0
-                item['playDuration'] = video_play_qs.filter(uid=item['uid']).aggregate(total=Sum('duration'))['total']
-                item['playDuration'] = item['playDuration'] if item['playDuration'] else 0
             res = {
                 'uploadDeviceCount': upload_device_count,
-                'playDeviceCount': play_device_count,
-                'vodData': list(upload_duration_qs) + list(play_duration_qs)
+                'vodData': vod_hls_result
             }
             return response.json(0, res)
         except Exception as e:
@@ -101,7 +108,6 @@ class BusinessDataView(View):
                 'Authorization': request.META.get('HTTP_AUTHORIZATION')
             }
             upload_device_count = 0
-            play_device_count = 0
             vod_list = []
             for url in url_list:
                 url = url + request.path.replace('global/', '')
@@ -109,13 +115,11 @@ class BusinessDataView(View):
                 result = res.json()
                 if result['result_code'] == 0:
                     upload_device_count += int(result['result']['uploadDeviceCount'])
-                    play_device_count += int(result['result']['playDeviceCount'])
                     vod_list += result['result']['vodData']
                 else:
                     return response.json(result['result_code'], result['result'])
             res = {
                 'uploadDeviceCount': upload_device_count,
-                'playDeviceCount': play_device_count,
                 'vodData': vod_list
             }
             return response.json(0, res)

AdminController/dataSystemManagement/DeviceDataController.py

@@ -10,10 +10,10 @@
 import datetime
 
 import requests
-from django.db.models import Count
+from django.db.models import Q, Sum
 from django.views.generic.base import View
 
-from Model.models import Device_Info, CountryModel, UidSetModel, DeviceTypeModel, VideoPlaybackTimeModel
+from Model.models import CountryModel, UidSetModel, DeviceInfoSummary
 from Service.CommonService import CommonService
 
 
@@ -50,6 +50,8 @@ 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):
@@ -89,7 +91,10 @@ class DeviceDataView(View):
                             device_list.append(item)
                             device_count += item['count']
                     for item in device_list:
-                        item['rate'] = round(item['count'] / device_count * 100, 2)
+                        if device_count != 0:
+                            item['rate'] = round(item['count'] / device_count * 100, 2)
+                        else:
+                            break
                     for item in result['result']['region']:
                         flag = 0
                         for each in region_list:
@@ -102,7 +107,10 @@ class DeviceDataView(View):
                             region_list.append(item)
                             region_count += item['count']
                     for item in region_list:
-                        item['rate'] = round(item['count'] / region_count * 100, 2)
+                        if region_count != 0:
+                            item['rate'] = round(item['count'] / region_count * 100, 2)
+                        else:
+                            break
                     for item in result['result']['type']:
                         flag = 0
                         for each in type_list:
@@ -115,7 +123,10 @@ class DeviceDataView(View):
                             type_list.append(item)
                             type_count += item['count']
                     for item in type_list:
-                        item['rate'] = round(item['count'] / type_count * 100, 2)
+                        if type_count != 0:
+                            item['rate'] = round(item['count'] / type_count * 100, 2)
+                        else:
+                            break
                     for item in result['result']['version']:
                         flag = 0
                         for each in order_list:
@@ -128,14 +139,17 @@ class DeviceDataView(View):
                             order_list.append(item)
                             order_count += item['count']
                     for item in order_list:
-                        item['rate'] = round(item['count'] / order_count * 100, 2)
+                        if order_count != 0:
+                            item['rate'] = round(item['count'] / order_count * 100, 2)
+                        else:
+                            break
                 else:
                     return response.json(result['result_code'])
             res = {
                 'device': device_list,
-                'type': type_list,
+                'type': CommonService.list_sort(type_list),
                 'region': CommonService.list_sort(region_list),
-                'version': order_list
+                'version': CommonService.list_sort(order_list)
             }
             return response.json(0, res)
         except Exception as e:
@@ -176,7 +190,10 @@ class DeviceDataView(View):
                             type_list.append(item)
                             type_count += item['count']
                     for item in type_list:
-                        item['rate'] = round(item['count'] / type_count * 100, 2)
+                        if type_count != 0:
+                            item['rate'] = round(item['count'] / type_count * 100, 2)
+                        else:
+                            break
                     for item in result['result']['region']:
                         flag = 0
                         for each in region_list:
@@ -189,7 +206,10 @@ class DeviceDataView(View):
                             region_list.append(item)
                             region_count += item['count']
                     for item in region_list:
-                        item['rate'] = round(item['count'] / region_count * 100, 2)
+                        if region_count != 0:
+                            item['rate'] = round(item['count'] / region_count * 100, 2)
+                        else:
+                            break
                 else:
                     return response.json(result['result_code'])
 
@@ -324,40 +344,44 @@ class DeviceDataView(View):
         e_time = datetime.datetime.fromtimestamp(int(end_time))
         time_list = CommonService.cutting_time(s_time, e_time, unit_time)
         try:
-            video_playback_time_qs = VideoPlaybackTimeModel.objects.filter(startTime__range=(start_time, end_time))
-            null_list = []
-            if not video_playback_time_qs.exists():
-                return response.json(0, null_list)
-            video_playback_uid_qs = video_playback_time_qs.values('uid').order_by('uid').distinct()
-            res = {}
+            device_info_summary_qs = DeviceInfoSummary.objects.filter(
+                time__gte=start_time, time__lt=end_time, query_type=1).values('country', 'count')
+            count_all = device_info_summary_qs.aggregate(total=Sum('count'))['total']
+            count_all = count_all if count_all else 0
             video_list = []
             region_list = []
+            region_dict = {}
+            for item in device_info_summary_qs:
+                region_temp_dict = eval(item['country'])
+                for country, count in region_temp_dict.items():
+                    if country in region_dict:
+                        region_dict[country] += count
+                    else:
+                        region_dict[country] = count
             for item in time_list:
-                video_playback_qs = video_playback_time_qs.filter(startTime__range=(item[0], item[1]))
-                uid_qs = video_playback_qs.values('uid').order_by('uid').distinct()
-                rate = round(uid_qs.count() / video_playback_uid_qs.count() * 100, 2)
+                deivce_type_qs = device_info_summary_qs.filter(time__gte=item[0], time__lt=item[1]).values('count')
+                count = deivce_type_qs.aggregate(total=Sum('count'))['total']
+                count = count if count else 0
+                rate = round(count / count_all * 100, 2) if count_all else 0
                 vod_dict = {
-                    'count': uid_qs.count(),
+                    'count': count,
                     'rate': rate,
                     'startTime': item[0],
                     'endTime': item[1]
                 }
                 video_list.append(vod_dict)
-            res['vodHls'] = video_list
-            type_country_qs = UidSetModel.objects.filter(uid__in=video_playback_uid_qs.values('uid')).values(
-                'tb_country').annotate(count=Count('tb_country')).order_by('-count')
-            for type_country in type_country_qs:
-                country_id = type_country['tb_country']
-                country_name_qs = CountryModel.objects.filter(id=country_id).values('country_name')
-                country_name = country_name_qs[0]['country_name'] if country_name_qs.exists() else '未知区域'
-                rate = round(type_country['count'] / video_playback_uid_qs.count() * 100, 2)
-                country_dict = {
-                    'countryName': country_name,
-                    'count': type_country['count'],
+            for country, count in region_dict.items():
+                rate = round(count / count_all * 100, 2) if count_all else 0
+                region_list.append({
+                    'countryName': country,
+                    'count': count,
                     'rate': rate
-                }
-                region_list.append(country_dict)
-            res['region'] = region_list
+                })
+            res = {
+                'vodHls': video_list,
+                'region': CommonService.list_sort(region_list)
+
+            }
             return response.json(0, res)
         except Exception as e:
             print(e)
@@ -378,111 +402,83 @@ class DeviceDataView(View):
         if not all([start_time, end_time, unit_time]):
             return response.json(444, {'error param': 'startTime or endTime or timeUnit'})
         try:
-            uid_set_qs = UidSetModel.objects.filter(addTime__range=(start_time, end_time))
-            null_list = []
-            if not uid_set_qs.exists():
-                return response.json(0, null_list)
-            uid_qs = uid_set_qs.values('uid')
-            count_all = uid_set_qs.count()
+            device_info_qs = DeviceInfoSummary.objects.filter(time__gte=start_time, time__lt=end_time,
+                                                              query_type=0).values(
+                'count', 'country', 'device_type', 'vod_service')
+            count_all = device_info_qs.aggregate(total=Sum('count'))['total']
+            count_all = count_all if count_all else 0
+            region_dict = {}
+            type_dict = {}
+            vod_dict = {}
+            for item in device_info_qs:
+                region_temp_dict = eval(item['country'])
+                type_temp_dict = eval(item['device_type'])
+                vod_temp_dict = eval(item['vod_service'])
+                for k, v in region_temp_dict.items():
+                    if k in region_dict:
+                        region_dict[k] += v
+                    else:
+                        region_dict[k] = v
+                for k, v in type_temp_dict.items():
+                    if k in type_dict:
+                        type_dict[k] += v
+                    else:
+                        type_dict[k] = v
+                for k, v in vod_temp_dict.items():
+                    if k in vod_dict:
+                        vod_dict[k] += v
+                    else:
+                        vod_dict[k] = v
             # 统计该时间段的设备数量（已去重）
-            res = {
-                'addDevice': '',
-                'region': '',
-                'type': '',
-                'version': '',
-            }
             info_list = []
-            region_list = []
-            type_list = []
-            version_list = []
             start_time = datetime.datetime.fromtimestamp(int(start_time))
             end_time = datetime.datetime.fromtimestamp(int(end_time))
             time_list = CommonService.cutting_time(start_time, end_time, unit_time)
             for item in time_list:
-                deivce_uid_qs = uid_set_qs.filter(addTime__range=(item[0], item[1]))
-                count_part = deivce_uid_qs.count()
-                rate = round(count_part / count_all * 100, 2)
+                device_uid_qs = device_info_qs.filter(time__gte=item[0], time__lt=item[1])
+                count = device_uid_qs.aggregate(total=Sum('count'))['total']
+                count = count if count else 0
+                rate = round(count / count_all * 100, 2) if count_all else 0
                 info_dict = {
                     'startTime': item[0],
                     'endTime': item[1],
-                    'count': count_part,
+                    'count': count,
                     'rate': rate
                 }
                 info_list.append(info_dict)
-                # 统计地区设备数量
-            device_info_country_qs = uid_set_qs.values('tb_country').annotate(
-                count=Count('tb_country')).order_by(
-                '-count')
-            country_qs = uid_set_qs.values('tb_country')
-            country_list = [item[key] for item in country_qs for key in item]
-            for item in device_info_country_qs:
-                country_id = item['tb_country']
-                country_qs = CountryModel.objects.filter(id=country_id).values('country_name', 'id')
-                country_name = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
-                country_count = country_list.count(country_id)
-                rate = round(country_count / count_all * 100, 2)
-                country_dict = {
-                    'countryName': country_name,
-                    'count': country_count,
+            # 统计地区设备数量
+            region_list = []
+            for x, y in region_dict.items():
+                rate = round(y / count_all * 100, 2) if count_all else 0
+                region_list.append({
+                    'countryName': x,
+                    'count': y,
                     'rate': rate
-                }
-                region_list.append(country_dict)
+                })
             # 统计设备类型数量
-            device_info_type_qs = Device_Info.objects.filter(UID__in=uid_qs.values('uid'))
-            device_type_qs = device_info_type_qs.values('Type').annotate(
-                count=Count('Type', distinct=True)).order_by('-count').distinct()
-            name = '未知类型'
-            count_remain = count_all - device_info_type_qs.count()
-            rate = round(count_remain / count_all * 100, 2)
-            type_list.append({
-                'type': name,
-                'count': count_remain,
-                'rate': rate
-            })
-            type_qs = device_info_type_qs.values('Type')
-            device_type_list = [item[key] for item in type_qs for key in item]
-            for device_type in device_type_qs:
-                Type = device_type['Type']
-                device_type_name_qs = DeviceTypeModel.objects.filter(type=Type).values('name')
-                name = device_type_name_qs[0]['name'] if device_type_name_qs.exists() else '未知类型'
-                type_count = device_type_list.count(Type)
-                rate = round(type_count / count_all * 100, 2)
+            type_list = []
+            for x, y in type_dict.items():
+                rate = round(y / count_all * 100, 2) if count_all else 0
                 type_list.append({
-                    'type': name,
-                    'count': type_count,
+                    'type': x,
+                    'count': y,
                     'rate': rate
                 })
             # 云存版本数量
-            uid_cloud_qs = uid_set_qs.exclude(cloud_vod=2).values('uid')
-            device_info_type_qs = Device_Info.objects.filter(UID__in=uid_cloud_qs.values('uid')).distinct()
-            cloud_type_qs = device_info_type_qs.values('Type').annotate(
-                count=Count('Type', distinct=True)).order_by('-count').distinct()
-            type_qs = device_info_type_qs.values('Type')
-            test_list = [item[key] for item in type_qs for key in item]
-            count = uid_cloud_qs.count() - device_info_type_qs.count()
-            name = '未知类型'
-            rate = round(count / count_all * 100, 2)
-            version_list.append({
-                'type': name,
-                'count': count,
-                'rate': rate
-            })
-            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,
+            vod_list = []
+            for x, y in vod_dict.items():
+                rate = round(y / count_all * 100, 2) if count_all else 0
+                vod_list.append({
+                    'type': x,
+                    'count': y,
                     'rate': rate
                 })
-            res['addDevice'] = info_list
-            res['region'] = CommonService.list_sort(region_list)
-            res['type'] = CommonService.list_sort(type_list)
-            res['version'] = CommonService.list_sort(version_list)
-
+            res = {
+                'addDevice': info_list,
+                'region': CommonService.list_sort(region_list),
+                'type': CommonService.list_sort(type_list),
+                'version': CommonService.list_sort(vod_list)
+            }
             return response.json(0, res)
         except Exception as e:
             print(e)
@@ -494,46 +490,46 @@ class DeviceDataView(View):
         统计地区设备数量
         @param response:响应对象
         """
-        uid_set_qs = UidSetModel.objects.all()
-        if not uid_set_qs.exists():
-            return response.json(444)
-        tb_country_qs = uid_set_qs.values('tb_country').annotate(
-            count=Count('tb_country')).order_by('-count')
-        res = {}
+        all_device_qs = DeviceInfoSummary.objects.filter(query_type=0).values('continent', 'count', 'country')
+        country_count = all_device_qs.aggregate(total=Sum('count'))['total']
         try:
-            device_country_list = []
             continent_list = []
-            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 country_qs.exists():
-                    name = country_qs[0]['country_name']
-                else:
-                    name = '未知地区'
-                count = uid_set_qs.filter(
-                    tb_country=country_id).values('uid').annotate(
-                    count=Count('uid', distinct=True)).order_by('-count').count()
-
-                device_country_list.append({
-                    'countryName': name,
-                    'count': count
+            country_list = []
+            continent_dict = {}
+            country_dict = {}
+            for item in all_device_qs:
+                country_temp_dict = eval(item['country'])
+                continent_temp_dict = eval(item['continent'])
+                for x, y in country_temp_dict.items():
+                    if x in country_dict:
+                        country_dict[x] += y
+                    else:
+                        country_dict[x] = y
+                for x, y in continent_temp_dict.items():
+                    if x in continent_dict:
+                        continent_dict[x] += y
+                    else:
+                        continent_dict[x] = y
+            # 地区设备量前30
+            for country, count in country_dict.items():
+                rate = round(count / country_count * 100, 2) if country_count else 0
+                country_list.append({
+                    'countryName': country,
+                    'count': count,
+                    'rate': rate
                 })
-                if country_qs.exists():
-                    flag = 0
-                    for each in continent_list:
-                        if country_qs[0]['region__name'] == each['continentName']:
-                            each['count'] += count
-                            flag = 1
-                            break
-                    if flag == 0:
-                        continent_list.append({
-                            'continentName': country_qs[0]['region__name'],
-                            'count': count
-                        })
-            for item in continent_list:
-                item['rate'] = round(item['count'] / uid_set_qs.count() * 100, 2)
-            res['countries'] = CommonService.list_sort(device_country_list)
-            res['continent'] = CommonService.list_sort(continent_list)
+            for continent, count in continent_dict.items():
+                rate = round(count / country_count * 100, 2) if country_count else 0
+                continent_list.append({
+                    'continentName': continent,
+                    'count': count,
+                    'rate': rate
+                })
+            res = {
+                'countries': CommonService.list_sort(country_list),
+                'continent': CommonService.list_sort(continent_list)
+            }
+
             return response.json(0, res)
         except Exception as e:
             print(e)
@@ -546,37 +542,30 @@ class DeviceDataView(View):
         @param response:响应对象
         @return:
         """
-        uid_set_qs = UidSetModel.objects.values('uid').order_by('uid')
-        count_all = uid_set_qs.count()
-        device_info_qs = Device_Info.objects.filter(UID__in=uid_set_qs.values('uid'))
-        device_info_count = device_info_qs.count()
-        device_info_type_qs = device_info_qs.values('Type').annotate(count=Count('Type')).order_by('-count')
-        # 查询不到（类型）的设备数量
-        if not device_info_qs.exists():
-            return response.json(444)
-        res = {}
+        all_device_qs = DeviceInfoSummary.objects.filter(query_type=0).values('device_type', 'count')
+        if not all_device_qs.exists():
+            return response.json(173)
+        count_all = all_device_qs.aggregate(total=Sum('count'))['total']
         try:
-            device_info_list = []
-            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_info_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,
+            device_type_list = []
+            device_type_dict = {}
+            for item in all_device_qs:
+                country_temp_dict = eval(item['device_type'])
+                for k, v in country_temp_dict.items():
+                    if k in device_type_dict:
+                        device_type_dict[k] += v
+                    else:
+                        device_type_dict[k] = v
+            for x, y in device_type_dict.items():
+                rate = round(y / count_all * 100, 2) if count_all else 0
+                device_type_list.append({
+                    'type': x,
+                    'count': y,
                     'rate': rate
                 })
-            res['type'] = device_info_list
+            res = {
+                'type': CommonService.list_sort(device_type_list)
+            }
             return response.json(0, res)
         except Exception as e:
             print(e)

AdminController/dataSystemManagement/HomeDataController.py

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

AdminController/dataSystemManagement/ServiceDataController.py

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

AdminController/dataSystemManagement/UserDataController.py

@@ -7,12 +7,12 @@
 @Software: PyCharm
 """
 
-from django.db.models import Count
+from django.db.models import Count, Sum
 from django.views.generic.base import View
 import datetime
 import requests
 
-from Model.models import Device_User, CountryModel
+from Model.models import Device_User, CountryModel, DeviceUserSummary
 from Service.CommonService import CommonService
 
 
@@ -64,45 +64,46 @@ class UserDataView(View):
         time_unit = request_dict.get('timeUnit', None)
         if not all([start_time, end_time, time_unit]):
             return response.json(444, {'error param': 'startTime or endTime or timeUnit'})
-        start_time = datetime.datetime.fromtimestamp(int(start_time))
-        end_time = datetime.datetime.fromtimestamp(int(end_time))
-        time_list = CommonService.cutting_time(start_time, end_time, time_unit)
         try:
-            user_qs = Device_User.objects.filter(data_joined__range=(start_time, end_time))
+            all_user_qs = DeviceUserSummary.objects.filter(time__gte=start_time, time__lt=end_time,
+                                                           query_type=0).values('count', 'country')
+            count = all_user_qs.aggregate(total=Sum('count'))['total']
+            count = count if count else 0
+            # 处理用户地区
+            region_dict = {}
+            region_list = []
+            for item in all_user_qs:
+                country_temp_dict = eval(item['country'])
+                for k, v in country_temp_dict.items():
+                    if k in region_dict:
+                        region_dict[k] += v
+                    else:
+                        region_dict[k] = v
+            for k, v in region_dict.items():
+                rate = round(v / count * 100, 2) if count else 0
+                region_list.append({
+                    'countryName': k,
+                    'count': v,
+                    'rate': rate
+                })
+            # 处理时间段用户
+            start_time = datetime.datetime.fromtimestamp(int(start_time))
+            end_time = datetime.datetime.fromtimestamp(int(end_time))
+            time_list = CommonService.cutting_time(start_time, end_time, time_unit)
             user_list = []
-            count = user_qs.count()
             for item in time_list:
-                s_time = datetime.datetime.fromtimestamp(int(item[0]))
-                e_time = datetime.datetime.fromtimestamp(int(item[1]))
-                user_date_qs = user_qs.filter(last_login__range=(s_time, e_time))
-                if count:
-                    rate = round(user_date_qs.count() / count * 100, 2)
-                else:
-                    rate = 0
+                user_qs = all_user_qs.filter(time__gte=item[0], time__lt=item[1]).values('count')
+                temp_count = user_qs.aggregate(total=Sum('count'))['total']
+                temp_count = temp_count if temp_count else 0
+                rate = round(temp_count / count * 100, 2) if count else 0
                 user_dict = {
-                    'count': user_date_qs.count(),
+                    'count': temp_count,
                     'rate': rate,
                     'startTime': item[0],
                     'endTime': item[1]
                 }
                 user_list.append(user_dict)
-            user_country_qs = user_qs.values('region_country').annotate(count=Count('region_country')).order_by(
-                '-count')
-            region_list = []
-            for item in user_country_qs:
-                country_id = item['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
-                country_dict = {
-                    'countryName': country_name,
-                    'count': item['count'],
-                    'rate': rate
-                }
-                region_list.append(country_dict)
+
             res = {
                 'user': user_list,
                 'region': region_list
@@ -127,45 +128,45 @@ class UserDataView(View):
         time_unit = request_dict.get('timeUnit', None)
         if not all([start_time, end_time, time_unit]):
             return response.json(444, {'error param': 'startTime or endTime or timeUnit'})
-        start_time = datetime.datetime.fromtimestamp(int(start_time))
-        end_time = datetime.datetime.fromtimestamp(int(end_time))
-        time_list = CommonService.cutting_time(start_time, end_time, time_unit)
         try:
-            user_qs = Device_User.objects.filter(last_login__range=(start_time, end_time))
+            all_user_qs = DeviceUserSummary.objects.filter(time__gte=start_time, time__lt=end_time,
+                                                           query_type=1).values('count', 'country')
+            count = all_user_qs.aggregate(total=Sum('count'))['total']
+            count = count if count else 0
+            # 处理用户地区
+            region_dict = {}
+            region_list = []
+            for item in all_user_qs:
+                country_temp_dict = eval(item['country'])
+                for k, v in country_temp_dict.items():
+                    if k in region_dict:
+                        region_dict[k] += v
+                    else:
+                        region_dict[k] = v
+            for k, v in region_dict.items():
+                rate = round(v / count * 100, 2) if count else 0
+                region_list.append({
+                    'countryName': k,
+                    'count': v,
+                    'rate': rate
+                })
+            # 处理时间段用户
+            start_time = datetime.datetime.fromtimestamp(int(start_time))
+            end_time = datetime.datetime.fromtimestamp(int(end_time))
+            time_list = CommonService.cutting_time(start_time, end_time, time_unit)
             user_list = []
-            count = user_qs.count()
             for item in time_list:
-                s_time = datetime.datetime.fromtimestamp(int(item[0]))
-                e_time = datetime.datetime.fromtimestamp(int(item[1]))
-                user_date_qs = user_qs.filter(last_login__range=(s_time, e_time))
-                if count:
-                    rate = round(user_date_qs.count() / count * 100, 2)
-                else:
-                    rate = 0
+                user_qs = all_user_qs.filter(time__gte=item[0], time__lt=item[1]).values('count')
+                temp_count = user_qs.aggregate(total=Sum('count'))['total']
+                temp_count = temp_count if temp_count else 0
+                rate = round(temp_count / count * 100, 2) if count else 0
                 user_dict = {
-                    'count': user_date_qs.count(),
+                    'count': temp_count,
                     'rate': rate,
                     'startTime': item[0],
                     'endTime': item[1]
                 }
                 user_list.append(user_dict)
-            user_country_qs = user_qs.values('region_country').annotate(count=Count('region_country')).order_by(
-                '-count')
-            region_list = []
-            for item in user_country_qs:
-                country_id = item['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
-                country_dict = {
-                    'countryName': country_name,
-                    'count': item['count'],
-                    'rate': rate
-                }
-                region_list.append(country_dict)
             res = {
                 'user': user_list,
                 'region': region_list
@@ -181,41 +182,48 @@ class UserDataView(View):
         @param response:响应对象
         @return:
         """
-        res = {
-            'countries': [],
-        }
+
         try:
-            user_qs = Device_User.objects.all()
-            count = user_qs.count()
-            user_qs = user_qs.values('region_country').annotate(count=Count('region_country')).order_by('-count')
+            user_qs = DeviceUserSummary.objects.filter(query_type=0).values('count', 'country', 'continent')
+            count = user_qs.aggregate(total=Sum('count'))['total']
+            count = count if count else 0
+            continent_dict = {}
+            country_dict = {}
             continent_list = []
+            country_list = []
             for item in user_qs:
-                country_id = item['region_country']
-                country_qs = CountryModel.objects.filter(id=country_id).values('country_name', 'region__name')
-                item['countryName'] = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
-                if count:
-                    item['rate'] = round(item['count'] / count * 100, 2)
-                else:
-                    item['rate'] = 0
-                if country_qs.exists():
-                    flag = 0
-                    for each in continent_list:
-                        if country_qs[0]['region__name'] == each['continentName']:
-                            each['count'] += item['count']
-                            flag = 1
-                            break
-                    if flag == 0:
-                        continent_list.append({
-                            'continentName': country_qs[0]['region__name'],
-                            'count': item['count']
-                        })
-            for item in continent_list:
-                if count:
-                    item['rate'] = round(item['count'] / count * 100, 2)
-                else:
-                    item['rate'] = 0
-            res['countries'] = list(user_qs)
-            res['continent'] = continent_list
+                country_temp_dict = eval(item['country'])
+                continent_temp_dict = eval(item['continent'])
+                for k, v in country_temp_dict.items():
+                    if k in country_dict:
+                        country_dict[k] += v
+                    else:
+                        country_dict[k] = v
+                for k, v in continent_temp_dict.items():
+                    if k in continent_dict:
+                        continent_dict[k] += v
+                    else:
+                        continent_dict[k] = v
+            # 处理用户国家
+            for k, v in country_dict.items():
+                rate = round(v / count * 100, 2) if count else 0
+                country_list.append({
+                    'countryName': k,
+                    'count': v,
+                    'rate': rate
+                })
+            # 处理用户大洲
+            for k, v in continent_dict.items():
+                rate = round(v / count * 100, 2) if count else 0
+                continent_list.append({
+                    'continentName': k,
+                    'count': v,
+                    'rate': rate
+                })
+            res = {
+                'countries': country_list,
+                'continent': continent_list
+            }
             return response.json(0, res)
         except Exception as e:
             return response.json(500, repr(e))
@@ -237,7 +245,6 @@ class UserDataView(View):
             user_list = []
             user_count = 0
             region_list = []
-            region_count = 0
             for url in url_list:
                 url = url + request.path.replace('global/', '')
                 res = requests.get(url=url, params=request_dict, headers=headers)
@@ -254,29 +261,22 @@ class UserDataView(View):
                         if flag == 0:
                             user_list.append(item)
                             user_count += item['count']
-                    for item in user_list:
-                        if user_count:
-                            item['rate'] = round(item['count'] / user_count * 100, 2)
-                        else:
-                            item['rate'] = 0
+
                     for item in result['result']['region']:
                         flag = 0
                         for each in region_list:
                             if item['countryName'] == each['countryName']:
                                 each['count'] += item['count']
-                                region_count += item['count']
                                 flag = 1
                                 break
                         if flag == 0:
                             region_list.append(item)
-                            region_count += item['count']
-                    for item in region_list:
-                        if region_count:
-                            item['rate'] = round(item['count'] / region_count * 100, 2)
-                        else:
-                            item['rate'] = 0
                 else:
                     return response.json(result['result_code'], result['result'])
+            for item in user_list:
+                item['rate'] = round(item['count'] / user_count * 100, 2) if user_count else 0
+            for item in region_list:
+                item['rate'] = round(item['count'] / user_count * 100, 2) if user_count else 0
             res = {
                 'user': user_list,
                 'region': CommonService.list_sort(region_list)
@@ -302,7 +302,6 @@ class UserDataView(View):
             user_list = []
             user_count = 0
             region_list = []
-            region_count = 0
             for url in url_list:
                 url = url + request.path.replace('global/', '')
                 res = requests.get(url=url, params=request_dict, headers=headers)
@@ -319,29 +318,23 @@ class UserDataView(View):
                         if flag == 0:
                             user_list.append(item)
                             user_count += item['count']
-                    for item in user_list:
-                        if user_count:
-                            item['rate'] = round(item['count'] / user_count * 100, 2)
-                        else:
-                            item['rate'] = 0
+
                     for item in result['result']['region']:
                         flag = 0
                         for each in region_list:
                             if item['countryName'] == each['countryName']:
                                 each['count'] += item['count']
-                                region_count += item['count']
                                 flag = 1
                                 break
                         if flag == 0:
                             region_list.append(item)
-                            region_count += item['count']
-                    for item in region_list:
-                        if region_count:
-                            item['rate'] = round(item['count'] / region_count * 100, 2)
-                        else:
-                            item['rate'] = 0
+
                 else:
                     return response.json(result['result_code'], result['result'])
+            for item in user_list:
+                item['rate'] = round(item['count'] / user_count * 100, 2) if user_count else 0
+            for item in region_list:
+                item['rate'] = round(item['count'] / user_count * 100, 2) if user_count else 0
             res = {
                 'user': user_list,
                 'region': CommonService.list_sort(region_list)
@@ -363,8 +356,8 @@ class UserDataView(View):
             headers = {
                 'Authorization': request.META.get('HTTP_AUTHORIZATION')
             }
-            user_list = []
-            region_list = []
+            country_list = []
+            continent_list = []
             user_count = 0
             for url in url_list:
                 url = url + request.path.replace('global/', '')
@@ -374,39 +367,33 @@ class UserDataView(View):
                     # 处理地区
                     for item in result['result']['countries']:
                         flag = 0
-                        for each in user_list:
+                        for each in country_list:
                             if each['countryName'] == item['countryName']:
                                 each['count'] += int(item['count'])
                                 user_count += int(item['count'])
                                 flag = 1
                                 break
                         if flag == 0:
-                            user_list.append(item)
+                            country_list.append(item)
                             user_count += int(item['count'])
-                    for item in user_list:
-                        if user_count:
-                            item['rate'] = round(item['count'] / user_count * 100, 2)
-                        else:
-                            item['rate'] = 0
                     for item in result['result']['continent']:
                         flag = 0
-                        for each in region_list:
+                        for each in continent_list:
                             if each['continentName'] == item['continentName']:
                                 each['count'] += item['count']
                                 flag = 1
                                 break
                         if flag == 0:
-                            region_list.append(item)
-                    for item in region_list:
-                        if user_count:
-                            item['rate'] = round(item['count'] / user_count * 100, 2)
-                        else:
-                            item['rate'] = 0
+                            continent_list.append(item)
                 else:
                     return response.json(result['result_code'], result['result'])
+            for item in country_list:
+                item['rate'] = round(item['count'] / user_count * 100, 2) if user_count else 0
+            for item in continent_list:
+                item['rate'] = round(item['count'] / user_count * 100, 2) if user_count else 0
             res = {
-                'countries': CommonService.list_sort(user_list[:20]),
-                'continent': CommonService.list_sort(region_list)
+                'countries': CommonService.list_sort(country_list[:20]),
+                'continent': CommonService.list_sort(continent_list)
             }
             return response.json(0, res)
         except Exception as e:

Ansjer/config.py

@@ -1,17 +1,3 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
-@AUTHOR: ASJRD018
-@NAME: Ansjer
-@software: PyCharm
-@DATE: 2018/7/2 14:06
-@Version: python3.6
-@MODIFY DECORD:ansjer dev
-@file: Conf.py
-@Contact: chanjunkai@163.com
-"""
-# 主要静态变量配置文件
 import os
 import datetime
 
@@ -21,6 +7,10 @@ CONFIG_CN = 'cn'
 CONFIG_US = 'us'
 CONFIG_EUR = 'eur'
 
+# redis列表
+USED_SERIAL_REDIS_LIST = 'used_serial_redis_list'
+UNUSED_SERIAL_REDIS_LIST = 'unused_serial_redis_list'
+
 SERVER_TYPE = os.environ.get('DJANGO_SETTINGS_MODULE')
 print(SERVER_TYPE)
 
@@ -91,6 +81,7 @@ SERVER_DOMAIN_US = 'http://www.dvema.com/'
 SERVER_DOMAIN_CN = 'http://www.zositechc.cn/'
 SERVER_DOMAIN_EUR = 'http://www.zositeche.com/'
 SERVER_DOMAIN_TEST = 'http://test.zositechc.cn/'
+SERVER_DOMAIN_LIST = [SERVER_DOMAIN_US, SERVER_DOMAIN_CN, SERVER_DOMAIN_EUR, SERVER_DOMAIN_TEST]
 
 # 不同环境配置
 # 本地

Ansjer/urls.py

@@ -396,6 +396,8 @@ urlpatterns = [
     re_path(r'^cron/del/(?P<operation>.*)', CronTaskController.CronDelDataView.as_view()),
     # 定时更新任务接口
     re_path(r'^cron/update/(?P<operation>.*)', CronTaskController.CronUpdateDataView.as_view()),
+    # 定时收集数据任务接口
+    re_path(r'^cron/collect/(?P<operation>.*)', CronTaskController.CronCollectDataView.as_view()),
 
     re_path('(?P<path>.*)', LogManager.errorPath),
 

Controller/AiController.py

@@ -173,7 +173,7 @@ class AiView(View):
 
             qs_data['detect_status'] = status  # ai开关状态
             ai_service_qs.update(**qs_data)
-            thing_name = CommonService.query_serial_with_uid(uid)   # 存在序列号则为使用序列号作为物品名
+            thing_name = CommonService.query_serial_with_uid(uid)  # 存在序列号则为使用序列号作为物品名
             topic_name = 'ansjer/generic/{}'.format(thing_name)
             if status == 0:  # 关闭
                 # mqtt通知设备关闭AI识别功能
@@ -381,6 +381,7 @@ class AiView(View):
     # 体验AI套餐
     @staticmethod
     def experience_order(request_dict, userID, response):
+        logger = logging.getLogger('info')
         uid = request_dict.get('uid', None)
         channel = request_dict.get('channel', None)
         pay_type = int(request_dict.get('pay_type', None))
@@ -402,7 +403,8 @@ class AiView(View):
                     return response.json(5)
 
             if cdk is not None and pay_type == 11:
-                cdk_qs = CDKcontextModel.objects.filter(cdk=cdk).values('is_activate', 'rank__id', 'rank__commodity_code')
+                cdk_qs = CDKcontextModel.objects.filter(cdk=cdk).values('is_activate', 'rank__id',
+                                                                        'rank__commodity_code')
                 if not cdk_qs.exists():
                     return response.json(10040)
                 if cdk_qs[0]['is_activate'] == 1:
@@ -434,14 +436,20 @@ class AiView(View):
                 return response.json(173)
 
             effective_day = ai_store_meal_qs[0]['effective_day']
-            endTime = nowTime + effective_day * 24 * 60 * 60  # 套餐结束时间
-
+            endTime = int(time.time()) + effective_day * 24 * 60 * 60  # 套餐结束时间
+            ai_cn_store_meal_qs = AiStoreMeal.objects.filter(id=rank, lang__lang='cn', is_show=1). \
+                values('lang__content', 'lang__title')
+            if ai_cn_store_meal_qs.exists():
+                store_meal_name = ai_cn_store_meal_qs[0]['lang__title'] + '-' + ai_cn_store_meal_qs[0]['lang__content']
+            else:
+                store_meal_name = '未知套餐'
             with transaction.atomic():
                 # 订单表创建数据
                 Order_Model.objects.create(orderID=orderID, UID=uid, channel=channel, userID_id=userID,
                                            desc=ai_store_meal_qs[0]['lang__content'], payType=pay_type, payTime=nowTime,
                                            price=ai_store_meal_qs[0]['price'], currency=ai_store_meal_qs[0]['currency'],
                                            addTime=nowTime, updTime=nowTime, pay_url='AI体验',
+                                           store_meal_name=store_meal_name, order_type=1,
                                            rank_id=1, ai_rank_id=rank, status=1)
                 # ai服务表创建数据
                 AiService.objects.create(uid=uid, channel=channel, orders_id=orderID, detect_status=1, endTime=endTime,
@@ -497,7 +505,12 @@ class AiView(View):
             content = ai_sm_qs[0]['lang__content']
             currency = ai_sm_qs[0]['currency']
             price = ai_sm_qs[0]['price']
-
+            ai_store_meal_qs = AiStoreMeal.objects.filter(id=rank, is_show=1, lang__lang='cn'). \
+                values('lang__title', 'lang__content')
+            if ai_store_meal_qs.exists():
+                store_meal_name = ai_store_meal_qs[0]['lang__title'] + '-' + ai_store_meal_qs[0]['lang__content']
+            else:
+                store_meal_name = '未知套餐'
             nowTime = int(time.time())
             orderID = CommonService.createOrderID()
             price = round(float(price), 2)
@@ -517,6 +530,7 @@ class AiView(View):
                 'ai_rank_id': rank,
                 'rank_id': 1,
                 'order_type': 1,
+                'store_meal_name': store_meal_name
             }
 
             if pay_type == 1:  # PayPal支付
@@ -808,7 +822,7 @@ class AiView(View):
                     boxDict['Width'] = val['Width']
                     boxDict['Height'] = merge_image_height * val['Height'] / single_height
                     boxDict['Top'] = ((merge_image_height * val['Top']) - (
-                                i * single_height)) / single_height  # 减去前i张图片的高度
+                            i * single_height)) / single_height  # 减去前i张图片的高度
                     boxDict['Left'] = val['Left']
                     boxDict['picName'] = "{n_time}_{i}".format(n_time=n_time, i=i)
                     # new_bounding_box_list.append(boxDict)

Controller/CloudStorage.py

@@ -148,9 +148,9 @@ class CloudStorageView(View):
                 return self.device_commodity(request_dict, userID, response)
             elif operation == 'switchdevicecommodity':  # 提前使用设备关联套餐
                 return self.switch_device_commodity(request_dict, userID, response)
-            elif operation == 'hasvod':  #APP的回放界面，日历表显示当天有无录像
+            elif operation == 'hasvod':  # APP的回放界面，日历表显示当天有无录像
                 return self.has_vod(request_dict, userID, response)
-            elif operation == 'videoPlaybackTime':    # 记录app播放时间
+            elif operation == 'videoPlaybackTime':  # 记录app播放时间
                 return self.videoPlaybackTime(request_dict, userID, response)
             else:
                 return response.json(414)
@@ -208,7 +208,7 @@ class CloudStorageView(View):
         eq = ExperienceContextModel.objects.filter(uid=uid, experience_type=0).values('id')
 
         if mold:
-            qs = qs.filter(bucket__mold=mold,lang__lang=lang)
+            qs = qs.filter(bucket__mold=mold, lang__lang=lang)
         else:
             qs = qs.filter(lang__lang=lang)
 
@@ -218,14 +218,15 @@ class CloudStorageView(View):
             qs = qs.filter(pay_type='10')
 
         qs = qs.filter(~Q(pay_type='11'))  # 过滤不显示激活码套餐
-        qs = qs.filter(is_show=0)  #过滤隐藏套餐
-        #qs = qs.filter(id='11111111')
-        #qs = qs.filter(bucket__region_id=regionObj.region_id)  # 过滤大洲
-        qs = qs.annotate(title=F('lang__title'),content=F('lang__content'),discount_content=F('lang__discount_content'))
+        qs = qs.filter(is_show=0)  # 过滤隐藏套餐
+        # qs = qs.filter(id='11111111')
+        # qs = qs.filter(bucket__region_id=regionObj.region_id)  # 过滤大洲
+        qs = qs.annotate(title=F('lang__title'), content=F('lang__content'),
+                         discount_content=F('lang__discount_content'))
         qs = qs.order_by('sort').values("id", "title", "content", "price", "day", "currency", "bucket__storeDay",
-                       "bucket__bucket", "bucket__area", "commodity_code",
-                       "commodity_type", "is_discounts", "virtual_price", "expire",
-                       "discount_price", "discount_content", "symbol","cycle_config_id")
+                                        "bucket__bucket", "bucket__area", "commodity_code",
+                                        "commodity_type", "is_discounts", "virtual_price", "expire",
+                                        "discount_price", "discount_content", "symbol", "cycle_config_id")
 
         if qs.exists():
             ql = list(qs)
@@ -242,10 +243,11 @@ class CloudStorageView(View):
                     del items_list[key]['cycle_config_id']
                 res_c = {'area': area, 'items': items_list}
                 res.append(res_c)
-            #是否促销
+            # 是否促销
             promotion = PromotionRuleModel.objects.filter(status=1, startTime__lte=nowTime,
-                                                          endTime__gte=nowTime).values('id','ruleConfig','ruleName',
-                                                                                       'startTime','endTime','ruleDesc')
+                                                          endTime__gte=nowTime).values('id', 'ruleConfig', 'ruleName',
+                                                                                       'startTime', 'endTime',
+                                                                                       'ruleDesc')
             if promotion.exists():
                 promotion = {
                     'is_promotion': 1,
@@ -253,7 +255,7 @@ class CloudStorageView(View):
                     'promotionEndTime': promotion[0]['endTime'],
                     'promotionName': json.loads(promotion[0]['ruleName']).get(lang, ''),
                     'promotionDesc': json.loads(promotion[0]['ruleDesc']).get(lang, ''),
-                    'nowTime':int(time.time())
+                    'nowTime': int(time.time())
                 }
             else:
                 promotion = {
@@ -263,10 +265,10 @@ class CloudStorageView(View):
                 'meals': res,
                 'extra':
                     {
-                        'cloud_banner': SERVER_DOMAIN+'web/images/cloud_cn_banner.png',
-                        'cloud_en_baner': SERVER_DOMAIN_SSL+'web/images/cloud_en_banner.png'
+                        'cloud_banner': SERVER_DOMAIN + 'web/images/cloud_cn_banner.png',
+                        'cloud_en_baner': SERVER_DOMAIN_SSL + 'web/images/cloud_en_banner.png'
                     },
-                'promotion':promotion,
+                'promotion': promotion,
             }
             return response.json(0, result)
         else:
@@ -289,10 +291,9 @@ class CloudStorageView(View):
         print(bucket__region)
         print(bucket_name)
 
-
         session = Session(
             aws_access_key_id=AWS_ACCESS_KEY_ID[vh_qs[0]["bucket__mold"]],
-            aws_secret_access_key = AWS_SECRET_ACCESS_KEY[vh_qs[0]["bucket__mold"]],
+            aws_secret_access_key=AWS_SECRET_ACCESS_KEY[vh_qs[0]["bucket__mold"]],
             region_name=bucket__region
         )
         '''
@@ -302,7 +303,7 @@ class CloudStorageView(View):
         playlist_entries = []
         fg = int(fg)
         # ts_count = fg & 0xf
-        #fg 64位整型，低四位代表ts文件总数，然后进行位运算，一次移四位，每四位转为十进制即为当前ts文件的秒数
+        # fg 64位整型，低四位代表ts文件总数，然后进行位运算，一次移四位，每四位转为十进制即为当前ts文件的秒数
         for i in range(15):
             shift = (i + 1) * 4
             duration = (fg >> shift) & 0xf
@@ -386,7 +387,7 @@ class CloudStorageView(View):
                         "Effect": "Allow",
                         "Action": "s3:*",
                         "Resource": ["{aws_arn}:::{bucket_name}/{uid_channel}*".
-                                         format(aws_arn=aws_arn, bucket_name=bucket_name, uid_channel=storage)]
+                                     format(aws_arn=aws_arn, bucket_name=bucket_name, uid_channel=storage)]
                     }
                 ]
             }
@@ -410,7 +411,7 @@ class CloudStorageView(View):
                 'endTime': ubqs[0]['endTime'],
                 'ip': ip,
                 'region': region_id,
-                'bucket_mold':ubqs[0]['bucket__mold']
+                'bucket_mold': ubqs[0]['bucket__mold']
             }
             if sts_qs.exists():
                 sts_qs.update(data=json.dumps(res, default=str), addTime=now_time)
@@ -435,7 +436,7 @@ class CloudStorageView(View):
 
         if uid == 'UWE2ZJ52SE4FX75U111A':
             logger.info({
-                "intoTime":intoTime,
+                "intoTime": intoTime,
             })
 
         dv_qs = Device_Info.objects.filter(userID_id=userID, UID=uid, isShare=False).values('vodPrimaryUserID',
@@ -450,11 +451,11 @@ class CloudStorageView(View):
                 "dvQsModelOverTime": dvQsModelTimeOver,
             })
 
-
         if dv_qs[0]['vodPrimaryUserID'] != userID:
             return response.json(10034)
         now_time = int(time.time())
-        bv_qs = UID_Bucket.objects.filter(uid=uid, endTime__gte=now_time ,channel=channel).values('bucket_id').order_by('addTime')
+        bv_qs = UID_Bucket.objects.filter(uid=uid, endTime__gte=now_time, channel=channel).values('bucket_id').order_by(
+            'addTime')
         if not bv_qs.exists():
             return response.json(10030)
 
@@ -476,7 +477,7 @@ class CloudStorageView(View):
         if not vh_qs.exists():
             return response.json(0, vod_play_list)
 
-        #不用关联外键查询，因为会查询非常慢
+        # 不用关联外键查询，因为会查询非常慢
         bucket_qs = VodBucketModel.objects.values()
         regroup_bucket_qs = {}
         for bucket_dict in bucket_qs:
@@ -542,12 +543,12 @@ class CloudStorageView(View):
         generatePresignedOverTime = int(time.time())
         if uid == 'UWE2ZJ52SE4FX75U111A':
             logger.info({
-                "intoTime":intoTime,
-                "dvQsModelOverTime":dvQsModelTimeOver,
-                "UidBucketModelOverTime":UidBucketModelTimeOver,
-                "vodHlsModelOverTime":vodHlsModelTimeOver,
-                "awsObjectOverTime":awsObjectOverTime,
-                "generatePresignedOverTime":generatePresignedOverTime,
+                "intoTime": intoTime,
+                "dvQsModelOverTime": dvQsModelTimeOver,
+                "UidBucketModelOverTime": UidBucketModelTimeOver,
+                "vodHlsModelOverTime": vodHlsModelTimeOver,
+                "awsObjectOverTime": awsObjectOverTime,
+                "generatePresignedOverTime": generatePresignedOverTime,
             })
 
         return response.json(0, vod_play_list)
@@ -665,7 +666,7 @@ class CloudStorageView(View):
 
                 nowTime = int(time.time())
                 order_list = order_qs.values("UID", "channel", "commodity_code", "rank", "isSelectDiscounts",
-                                             "userID__userID", "userID__username","coupon_id")
+                                             "userID__userID", "userID__username", "coupon_id")
                 userid = order_list[0]['userID__userID']
                 username = order_list[0]['userID__username']
                 UID = order_list[0]['UID']
@@ -677,7 +678,8 @@ class CloudStorageView(View):
                 bucketId = smqs[0]['bucket_id']
                 if not smqs.exists():
                     return response.json(173)
-                ubqs = UID_Bucket.objects.filter(uid=UID).values("id", "bucket_id", "bucket__storeDay", "bucket__region",
+                ubqs = UID_Bucket.objects.filter(uid=UID).values("id", "bucket_id", "bucket__storeDay",
+                                                                 "bucket__region",
                                                                  "endTime", "use_status")
                 expire = smqs[0]['expire']
                 if order_list[0]['isSelectDiscounts'] == 1:
@@ -685,7 +687,7 @@ class CloudStorageView(View):
                 # 是否有促销
                 nowTime = int(time.time())
                 promotion = PromotionRuleModel.objects.filter(status=1, startTime__lte=nowTime,
-                                                              endTime__gte=nowTime).values('id','ruleConfig')
+                                                              endTime__gte=nowTime).values('id', 'ruleConfig')
                 promotion_rule_id = ''
                 if promotion.exists():
                     promotion_rule_id = promotion[0]['id']
@@ -693,12 +695,12 @@ class CloudStorageView(View):
                 with transaction.atomic():
                     if ubqs.exists():
                         ubq = ubqs[0]
-                        if ubq['use_status'] == 1 and ubq['bucket_id'] == bucketId:  #套餐使用中并且相同套餐叠加过期时间
+                        if ubq['use_status'] == 1 and ubq['bucket_id'] == bucketId:  # 套餐使用中并且相同套餐叠加过期时间
                             endTime = CommonService.calcMonthLater(expire, ubq['endTime'])
                             UID_Bucket.objects.filter(id=ubq['id']).update \
                                 (uid=UID, channel=channel, bucket_id=bucketId,
                                  endTime=endTime, updateTime=nowTime)
-                        else:     #已过期或者不相同的套餐加入未使用的关联套餐表
+                        else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
                             has_unused = Unused_Uid_Meal.objects.filter(uid=UID, bucket_id=bucketId).values("id")
                             nums = 2 if order_list[0]['isSelectDiscounts'] == 1 else 1
                             if promotion.exists():
@@ -706,15 +708,15 @@ class CloudStorageView(View):
                             if has_unused.exists():
                                 Unused_Uid_Meal.objects.filter(id=has_unused[0]['id']).update(num=F('num') + nums)
                             else:
-                                Unused_Uid_Meal.objects.create(uid=UID,channel=channel,addTime=nowTime,num=nums,
-                                                               expire=smqs[0]['expire'],bucket_id=bucketId)
+                                Unused_Uid_Meal.objects.create(uid=UID, channel=channel, addTime=nowTime, num=nums,
+                                                               expire=smqs[0]['expire'], bucket_id=bucketId)
                             UID_Bucket.objects.filter(id=ubq['id']).update(has_unused=1)
                         uid_bucket_id = ubq['id']
                     else:
                         endTime = CommonService.calcMonthLater(expire)
                         ub_cqs = UID_Bucket.objects.create \
                             (uid=UID, channel=channel, bucket_id=bucketId, endTime=endTime, addTime=nowTime,
-                             updateTime=nowTime,use_status=1)
+                             updateTime=nowTime, use_status=1)
                         uid_bucket_id = ub_cqs.id
 
                     dvq = Device_Info.objects.filter(UID=UID, vodPrimaryUserID='', vodPrimaryMaster='')
@@ -735,9 +737,11 @@ class CloudStorageView(View):
 
                     # 核销coupon
                     if order_list[0]['coupon_id']:
-                        CouponModel.objects.filter(id=order_list[0]['coupon_id']).update(use_status=2, update_time=nowTime)
+                        CouponModel.objects.filter(id=order_list[0]['coupon_id']).update(use_status=2,
+                                                                                         update_time=nowTime)
 
-                    order_qs.update(status=1, updTime=nowTime, uid_bucket_id=uid_bucket_id, promotion_rule_id=promotion_rule_id)
+                    order_qs.update(status=1, updTime=nowTime, uid_bucket_id=uid_bucket_id,
+                                    promotion_rule_id=promotion_rule_id)
                     datetime = time.strftime("%Y-%m-%d", time.localtime())
                     # 如果存在序列号,消息提示用序列号
                     device_info_qs = Device_Info.objects.filter(UID=UID).values('serial_number', 'Type')
@@ -747,11 +751,14 @@ class CloudStorageView(View):
                         device_name = CommonService.get_full_serial_number(UID, serial_number, device_type)
                     else:
                         device_name = UID
-                    sys_msg_text_list = ['温馨提示：尊敬的客户，您的'+device_name+'设备在'+datetime+'已成功购买云存套餐', 'Dear customer,you already subscribed the cloud storage package successfully for device ' + device_name + ' on '+ time.strftime("%b %dth,%Y", time.localtime())]
+                    sys_msg_text_list = ['温馨提示：尊敬的客户，您的' + device_name + '设备在' + datetime + '已成功购买云存套餐',
+                                         'Dear customer,you already subscribed the cloud storage package successfully for device ' + device_name + ' on ' + time.strftime(
+                                             "%b %dth,%Y", time.localtime())]
                     self.do_vod_msg_Notice(UID, channel, userid, lang, sys_msg_text_list, 'SMS_219738485')
                     red_url = "{SERVER_DOMAIN_SSL}web/paid2/success.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
                     if lang != 'cn':
-                        red_url = "{SERVER_DOMAIN_SSL}web/paid2/en_success.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
+                        red_url = "{SERVER_DOMAIN_SSL}web/paid2/en_success.html".format(
+                            SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
                     redisObj.del_data(key=orderID + 'do_notify')
                     return HttpResponseRedirect(red_url)
             return response.json(0, signature)
@@ -779,7 +786,7 @@ class CloudStorageView(View):
         orderID = request_dict.get('orderID', None)
         lang = request_dict.get('lang', 'en')
 
-        logger.info("paymentID={paymentId},payerID={PayerID}".format(paymentId=paymentId,PayerID=PayerID))
+        logger.info("paymentID={paymentId},payerID={PayerID}".format(paymentId=paymentId, PayerID=PayerID))
 
         # redis加锁，防止订单重复
         redisObj = RedisObject()
@@ -819,7 +826,7 @@ class CloudStorageView(View):
             nowTime = int(time.time())
             order_list = order_qs.values("UID", "channel", "commodity_code", "rank", "isSelectDiscounts",
                                          "userID__userID",
-                                         "userID__username","coupon_id")
+                                         "userID__username", "coupon_id")
             userid = order_list[0]['userID__userID']
             username = order_list[0]['userID__username']
             UID = order_list[0]['UID']
@@ -840,7 +847,7 @@ class CloudStorageView(View):
             # 是否有促销
             nowTime = int(time.time())
             promotion = PromotionRuleModel.objects.filter(status=1, startTime__lte=nowTime,
-                                                          endTime__gte=nowTime).values('id','ruleConfig')
+                                                          endTime__gte=nowTime).values('id', 'ruleConfig')
             promotion_rule_id = ''
             if promotion.exists():
                 promotion_rule_id = promotion[0]['id']
@@ -848,12 +855,12 @@ class CloudStorageView(View):
             with transaction.atomic():
                 if ubqs.exists():
                     ubq = ubqs[0]
-                    if ubq['use_status'] == 1 and ubq['bucket_id'] == bucketId:  #套餐使用中并且相同套餐叠加过期时间
+                    if ubq['use_status'] == 1 and ubq['bucket_id'] == bucketId:  # 套餐使用中并且相同套餐叠加过期时间
                         endTime = CommonService.calcMonthLater(expire, ubq['endTime'])
                         UID_Bucket.objects.filter(id=ubq['id']).update \
                             (uid=UID, channel=channel, bucket_id=bucketId,
                              endTime=endTime, updateTime=nowTime)
-                    else:     #已过期或者不相同的套餐加入未使用的关联套餐表
+                    else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
                         has_unused = Unused_Uid_Meal.objects.filter(uid=UID, bucket_id=bucketId).values("id")
                         nums = 2 if order_list[0]['isSelectDiscounts'] == 1 else 1
                         if promotion.exists():
@@ -861,15 +868,15 @@ class CloudStorageView(View):
                         if has_unused.exists():
                             Unused_Uid_Meal.objects.filter(id=has_unused[0]['id']).update(num=F('num') + nums)
                         else:
-                            Unused_Uid_Meal.objects.create(uid=UID,channel=channel,addTime=nowTime,num=nums,
-                                                           expire=smqs[0]['expire'],bucket_id=bucketId)
+                            Unused_Uid_Meal.objects.create(uid=UID, channel=channel, addTime=nowTime, num=nums,
+                                                           expire=smqs[0]['expire'], bucket_id=bucketId)
                         UID_Bucket.objects.filter(id=ubq['id']).update(has_unused=1)
                     uid_bucket_id = ubq['id']
                 else:
                     endTime = CommonService.calcMonthLater(expire)
                     ub_cqs = UID_Bucket.objects.create \
                         (uid=UID, channel=channel, bucket_id=bucketId, endTime=endTime, addTime=nowTime,
-                         updateTime=nowTime,use_status=1)
+                         updateTime=nowTime, use_status=1)
                     uid_bucket_id = ub_cqs.id
 
                 dvq = Device_Info.objects.filter(UID=UID, vodPrimaryUserID='', vodPrimaryMaster='')
@@ -892,7 +899,8 @@ class CloudStorageView(View):
                 if order_list[0]['coupon_id']:
                     CouponModel.objects.filter(id=order_list[0]['coupon_id']).update(use_status=2, update_time=nowTime)
 
-                order_qs.update(status=1, updTime=nowTime, uid_bucket_id=uid_bucket_id, promotion_rule_id=promotion_rule_id)
+                order_qs.update(status=1, updTime=nowTime, uid_bucket_id=uid_bucket_id,
+                                promotion_rule_id=promotion_rule_id)
                 datetime = time.strftime("%Y-%m-%d", time.localtime())
                 # 如果存在序列号,消息提示用序列号
                 device_info_qs = Device_Info.objects.filter(UID=UID).values('serial_number', 'Type')
@@ -947,7 +955,7 @@ class CloudStorageView(View):
                     return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL', 'return_msg': '签名失败'}))
                 orderID = out_trade_no
 
-                #redis加锁，防止订单重复
+                # redis加锁，防止订单重复
                 redisObj = RedisObject()
                 isLock = redisObj.CONN.setnx(orderID + 'do_notify', 1)
                 redisObj.CONN.expire(orderID + 'do_notify', 60)
@@ -974,21 +982,22 @@ class CloudStorageView(View):
                 expire = smqs[0]['expire']
                 if order_list[0]['isSelectDiscounts'] == 1:
                     expire = smqs[0]['expire'] * 2
-                #是否有促销
+                # 是否有促销
                 nowTime = int(time.time())
-                promotion = PromotionRuleModel.objects.filter(status=1,startTime__lte=nowTime,endTime__gte=nowTime).values('id','ruleConfig')
+                promotion = PromotionRuleModel.objects.filter(status=1, startTime__lte=nowTime,
+                                                              endTime__gte=nowTime).values('id', 'ruleConfig')
                 if promotion.exists():
                     promotion_rule_id = promotion[0]['id']
                     expire = expire * 2
                 with transaction.atomic():
                     if ubqs.exists():
                         ubq = ubqs[0]
-                        if ubq['use_status'] == 1 and ubq['bucket_id'] == bucketId:  #套餐使用中并且相同套餐叠加过期时间
+                        if ubq['use_status'] == 1 and ubq['bucket_id'] == bucketId:  # 套餐使用中并且相同套餐叠加过期时间
                             endTime = CommonService.calcMonthLater(expire, ubq['endTime'])
                             UID_Bucket.objects.filter(id=ubq['id']).update \
                                 (uid=UID, channel=channel, bucket_id=bucketId,
                                  endTime=endTime, updateTime=nowTime)
-                        else:     #已过期或者不相同的套餐加入未使用的关联套餐表
+                        else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
                             has_unused = Unused_Uid_Meal.objects.filter(uid=UID, bucket_id=bucketId).values("id")
                             nums = 2 if order_list[0]['isSelectDiscounts'] == 1 else 1
                             if promotion.exists():
@@ -996,15 +1005,15 @@ class CloudStorageView(View):
                             if has_unused.exists():
                                 Unused_Uid_Meal.objects.filter(id=has_unused[0]['id']).update(num=F('num') + nums)
                             else:
-                                Unused_Uid_Meal.objects.create(uid=UID,channel=channel,addTime=nowTime,num=nums,
-                                                               expire=smqs[0]['expire'],bucket_id=bucketId)
+                                Unused_Uid_Meal.objects.create(uid=UID, channel=channel, addTime=nowTime, num=nums,
+                                                               expire=smqs[0]['expire'], bucket_id=bucketId)
                             UID_Bucket.objects.filter(id=ubq['id']).update(has_unused=1)
                         uid_bucket_id = ubq['id']
                     else:
                         endTime = CommonService.calcMonthLater(expire)
                         ub_cqs = UID_Bucket.objects.create \
                             (uid=UID, channel=channel, bucket_id=bucketId, endTime=endTime, addTime=nowTime,
-                             updateTime=nowTime,use_status=1)
+                             updateTime=nowTime, use_status=1)
                         uid_bucket_id = ub_cqs.id
 
                     dvq = Device_Info.objects.filter(UID=UID, vodPrimaryUserID='', vodPrimaryMaster='')
@@ -1025,9 +1034,11 @@ class CloudStorageView(View):
 
                     # 核销coupon
                     if order_list[0]['coupon_id']:
-                        CouponModel.objects.filter(id=order_list[0]['coupon_id']).update(use_status=2, update_time=nowTime)
+                        CouponModel.objects.filter(id=order_list[0]['coupon_id']).update(use_status=2,
+                                                                                         update_time=nowTime)
 
-                    order_qs.update(status=1, updTime=nowTime, uid_bucket_id=uid_bucket_id, promotion_rule_id=promotion_rule_id)
+                    order_qs.update(status=1, updTime=nowTime, uid_bucket_id=uid_bucket_id,
+                                    promotion_rule_id=promotion_rule_id)
                     datetime = time.strftime("%Y-%m-%d", time.localtime())
                     # 如果存在序列号,消息提示用序列号
                     device_info_qs = Device_Info.objects.filter(UID=UID).values('serial_number', 'Type')
@@ -1108,16 +1119,16 @@ class CloudStorageView(View):
         #     ubqs_count = ubqs.count()
         #     ubq = ubqs[ubqs_count - 1, ubqs_count]
         #     new_starTime = ubq['endTime'] + 1
-        is_mold = 0  #判断国内外
-        if smqs[0]['bucket__mold']==0:
+        is_mold = 0  # 判断国内外
+        if smqs[0]['bucket__mold'] == 0:
             is_mold = 1
 
-        order_qs = Order_Model.objects.filter(UID=uid , rank__bucket__mold=is_mold)
+        order_qs = Order_Model.objects.filter(UID=uid, rank__bucket__mold=is_mold)
         if order_qs.exists():
             return response.json(10041)
 
         orderID = CommonService.createOrderID()
-        #优惠券
+        # 优惠券
         if coupon_id:
             couponObj = CouponModel.objects.filter(id=coupon_id, use_status=0, distribute_time__lte=nowTime,
                                                    valid_time__gt=nowTime)
@@ -1126,9 +1137,9 @@ class CloudStorageView(View):
                 return response.json(10049)
             price = Decimal(price)
             coupon_discount = Decimal(couponQuery[0]['coupon_config__coupon_discount'])
-            if couponQuery[0]['coupon_config__type'] == 1:  #打折
-                price = coupon_discount/10 * price
-            elif couponQuery[0]['coupon_config__type'] == 2:  #抵扣
+            if couponQuery[0]['coupon_config__type'] == 1:  # 打折
+                price = coupon_discount / 10 * price
+            elif couponQuery[0]['coupon_config__type'] == 2:  # 抵扣
                 price = price - coupon_discount
         price = float(price)
         if price < 0 or price == 0 or price < 0.01:
@@ -1136,28 +1147,36 @@ class CloudStorageView(View):
         price = round(price, 2)
         if pay_type == 1:
             # 订阅周期扣款
-            if(smqs[0]['cycle_config_id']):
-                #查询是否有订阅过，活跃状态
+            if (smqs[0]['cycle_config_id']):
+                # 查询是否有订阅过，活跃状态
                 # return HttpResponse(price)
-                checkHasSubscribe = Paypal.checkSubscriptions(userID,uid,rank)
+                checkHasSubscribe = Paypal.checkSubscriptions(userID, uid, rank)
                 if checkHasSubscribe is False:
                     return response.json(10050)
-                subInfo = Paypal.subscriptions(store_info=smqs[0],lang=lang,orderID=orderID,price=price)
+                subInfo = Paypal.subscriptions(store_info=smqs[0], lang=lang, orderID=orderID, price=price)
                 if not subInfo:
                     return response.json(10048)
+                store_meal_qs = Store_Meal.objects.filter(id=rank, lang__lang='cn', is_show=0).values('lang__title',
+                                                                                                      'lang__content')
+                if store_meal_qs.exists():
+                    store_meal_name = store_meal_qs[0]['lang__title'] + '-' + store_meal_qs[0]['lang__content']
+                else:
+                    store_meal_name = '未知套餐'
                 Order_Model.objects.create(orderID=orderID, UID=uid, channel=channel, userID_id=userID,
                                            desc=content, payType=pay_type, payTime=nowTime,
                                            price=price, currency=currency, addTime=nowTime, updTime=nowTime,
                                            pay_url=subInfo['url'], isSelectDiscounts=is_select_discount,
                                            commodity_code=commodity_code, commodity_type=commodity_type,
-                                           rank_id=rank, plan_id=subInfo['plan_id'],coupon_id=coupon_id,ai_rank_id=1)
+                                           rank_id=rank, plan_id=subInfo['plan_id'], coupon_id=coupon_id, ai_rank_id=1,
+                                           store_meal_name=store_meal_name
+                                           )
                 # if coupon_id:
                 #     #冻结优惠券
                 #     CouponModel.objects.filter(id=coupon_id, use_status=0, distribute_time__lte=nowTime,
                 #                                            valid_time__gt=nowTime).update(use_status=1)
 
                 return response.json(0, {"redirectUrl": subInfo['url'], "orderID": orderID})
-            #正常扣款
+            # 正常扣款
             cal_url = "{SERVER_DOMAIN_SSL}web/paid2/fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
             if lang != 'cn':
                 cal_url = "{SERVER_DOMAIN_SSL}web/paid2/en_fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
@@ -1184,17 +1203,24 @@ class CloudStorageView(View):
             print(payment)
             logger.info('paypal创建订单返回----------')
             logger.info(payment)
-            paymentID = payment['id']   # 获取paymentID
+            paymentID = payment['id']  # 获取paymentID
             for link in payment.links:
                 if link.rel == "approval_url":
                     approval_url = str(link.href)
                     print("Redirect for approval: %s" % (approval_url))
+                    store_meal_qs = Store_Meal.objects.filter(id=rank, lang__lang='cn', is_show=0).values('lang__title',
+                                                                                                          'lang__content')
+                    if store_meal_qs.exists():
+                        store_meal_name = store_meal_qs[0]['lang__title'] + '-' + store_meal_qs[0]['lang__content']
+                    else:
+                        store_meal_name = '未知套餐'
                     Order_Model.objects.create(orderID=orderID, UID=uid, channel=channel, userID_id=userID,
                                                desc=content, payType=pay_type, payTime=nowTime,
                                                price=price, currency=currency, addTime=nowTime, updTime=nowTime,
                                                pay_url=approval_url, isSelectDiscounts=is_select_discount,
                                                commodity_code=commodity_code, commodity_type=commodity_type,
-                                               rank_id=rank, paymentID=paymentID,coupon_id=coupon_id,ai_rank_id=1)
+                                               rank_id=rank, paymentID=paymentID, coupon_id=coupon_id, ai_rank_id=1,
+                                               store_meal_name=store_meal_name)
                     return response.json(0, {"redirectUrl": approval_url, "orderID": orderID})
             return response.json(10, 'generate_order_false')
         elif pay_type == 2:
@@ -1218,7 +1244,7 @@ class CloudStorageView(View):
                     notify_url="{SERVER_DOMAIN_SSL}cloudstorage/doalicallback".format(
                         SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL),
                     quit_url="{SERVER_DOMAIN_SSL}web/paid2/fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL),
-                    passback_params=quote("lang="+lang)
+                    passback_params=quote("lang=" + lang)
                     # return_url="http://192.168.136.40/cloudstorage/payOK",
                     # notify_url="http://192.168.136.40/cloudstorage/aliPayCallback"
                 )
@@ -1232,12 +1258,19 @@ class CloudStorageView(View):
                     redirectUrl = aliPayObj.alipay_prefix + order_string
                     print('---------tttt')
                     print(redirectUrl)
+                    store_meal_qs = Store_Meal.objects.filter(id=rank, lang__lang='cn', is_show=0).values('lang__title',
+                                                                                                          'lang__content')
+                    if store_meal_qs.exists():
+                        store_meal_name = store_meal_qs[0]['lang__title'] + '-' + store_meal_qs[0]['lang__content']
+                    else:
+                        store_meal_name = '未知套餐'
                     Order_Model.objects.create(orderID=orderID, UID=uid, channel=channel, userID_id=userID,
                                                desc=content, payType=pay_type, payTime=nowTime,
                                                price=price, currency=currency, addTime=nowTime, updTime=nowTime,
                                                pay_url=redirectUrl, isSelectDiscounts=is_select_discount,
                                                commodity_code=commodity_code, commodity_type=commodity_type,
-                                               rank_id=rank,coupon_id=coupon_id,ai_rank_id=1)
+                                               rank_id=rank, coupon_id=coupon_id, ai_rank_id=1,
+                                               store_meal_name=store_meal_name)
 
                     return JsonResponse(status=200, data={'result_code': 0, 'reason': 'success',
                                                           'result': {"redirectUrl": redirectUrl, "orderID": orderID},
@@ -1252,7 +1285,8 @@ class CloudStorageView(View):
             # 获取参数
             response = ResponseObject()
 
-            parameter_dict = pay.get_parameter(orderID, content, float(price) * 100, ip, notify_url, quote("lang="+lang))
+            parameter_dict = pay.get_parameter(orderID, content, float(price) * 100, ip, notify_url,
+                                               quote("lang=" + lang))
             print('parameter_dict', parameter_dict)
             # parameter_dict 参数中获取MWEB_URL 调转页面在路径后面添加redirect_url
             # 统一调用接口
@@ -1260,11 +1294,18 @@ class CloudStorageView(View):
             if not response:
                 return response.json(10, '生成订单错误.')
             # 回调函数
+            store_meal_qs = Store_Meal.objects.filter(id=rank, lang__lang='cn', is_show=0).values('lang__title',
+                                                                                                  'lang__content')
+            if store_meal_qs.exists():
+                store_meal_name = store_meal_qs[0]['lang__title'] + '-' + store_meal_qs[0]['lang__content']
+            else:
+                store_meal_name = '未知套餐'
             Order_Model.objects.create(orderID=orderID, UID=uid, channel=channel, userID_id=userID,
                                        desc=content, payType=pay_type, payTime=nowTime,
                                        price=price, currency=currency, addTime=nowTime, updTime=nowTime,
                                        pay_url=notify_url, isSelectDiscounts=is_select_discount,
-                                       commodity_code=commodity_code, commodity_type=commodity_type, rank_id=rank, ai_rank_id=1)
+                                       commodity_code=commodity_code, commodity_type=commodity_type, rank_id=rank,
+                                       ai_rank_id=1, store_meal_name=store_meal_name)
             return JsonResponse(status=200, data={'result_code': 0, 'reason': 'success',
                                                   'result': response,
                                                   'orderId': orderID,
@@ -1282,8 +1323,8 @@ class CloudStorageView(View):
         lang = request_dict.get('lang', 'en')
 
         redisObj = RedisObject()
-        isLock = redisObj.CONN.setnx(uid+'do_experience_order', 1)
-        redisObj.CONN.expire(uid+'do_experience_order', 60)
+        isLock = redisObj.CONN.setnx(uid + 'do_experience_order', 1)
+        redisObj.CONN.expire(uid + 'do_experience_order', 60)
         logger = logging.getLogger('info')
         if not isLock:
             return response.json(5)
@@ -1321,8 +1362,9 @@ class CloudStorageView(View):
 
         orderID = CommonService.createOrderID()
         nowTime = int(time.time())
-        smqs = Store_Meal.objects.filter(id=rank,lang__lang=lang,is_show=0). \
-            values("day", "bucket_id", "bucket__storeDay", "expire", 'lang__content', 'price', 'currency', 'commodity_type')
+        smqs = Store_Meal.objects.filter(id=rank, lang__lang=lang, is_show=0). \
+            values("day", "bucket_id", "bucket__storeDay", "expire", 'lang__content', 'price', 'currency',
+                   'commodity_type')
         if not smqs.exists():
             return response.json(173)
         bucketId = smqs[0]['bucket_id']
@@ -1334,40 +1376,44 @@ class CloudStorageView(View):
             with transaction.atomic():
                 if ubqs.exists():
                     ubq = ubqs[0]
-                    if ubq['use_status'] == 1 and ubq['bucket_id'] == bucketId:  #套餐使用中并且相同套餐叠加过期时间
+                    if ubq['use_status'] == 1 and ubq['bucket_id'] == bucketId:  # 套餐使用中并且相同套餐叠加过期时间
                         endTime = CommonService.calcMonthLater(expire, ubq['endTime'])
                         UID_Bucket.objects.filter(id=ubq['id']).update \
                             (uid=uid, channel=channel, bucket_id=bucketId,
                              endTime=endTime, updateTime=nowTime)
-                    else:     #已过期或者不相同的套餐加入未使用的关联套餐表
+                    else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
                         has_unused = Unused_Uid_Meal.objects.filter(uid=uid, bucket_id=bucketId).values("id")
                         nums = 1
                         if has_unused.exists():
                             Unused_Uid_Meal.objects.filter(id=has_unused[0]['id']).update(num=F('num') + nums)
                         else:
-                            Unused_Uid_Meal.objects.create(uid=uid,channel=channel,addTime=nowTime,num=nums,
-                                                           expire=smqs[0]['expire'],bucket_id=bucketId)
+                            Unused_Uid_Meal.objects.create(uid=uid, channel=channel, addTime=nowTime, num=nums,
+                                                           expire=smqs[0]['expire'], bucket_id=bucketId)
                         UID_Bucket.objects.filter(id=ubq['id']).update(has_unused=1)
                     uid_bucket_id = ubq['id']
                 else:
                     endTime = CommonService.calcMonthLater(expire)
                     ub_cqs = UID_Bucket.objects.create \
                         (uid=uid, channel=channel, bucket_id=bucketId, endTime=endTime, addTime=nowTime,
-                         updateTime=nowTime,use_status=1)
+                         updateTime=nowTime, use_status=1)
                     uid_bucket_id = ub_cqs.id
+                store_meal_qs = Store_Meal.objects.filter(id=rank, lang__lang='cn', is_show=0).values('lang__title',
+                                                                                                      'lang__content')
+                if store_meal_qs.exists():
+                    store_meal_name = store_meal_qs[0]['lang__title'] + '-' + store_meal_qs[0]['lang__content']
+                else:
+                    store_meal_name = '未知套餐'
                 Order_Model.objects.create(orderID=orderID, UID=uid, channel=channel, userID_id=userID,
                                            desc=smqs[0]['lang__content'], payType=pay_type, payTime=nowTime,
                                            price=smqs[0]['price'], currency=smqs[0]['currency'], addTime=nowTime,
                                            updTime=nowTime,
-                                           pay_url="体验版",
+                                           pay_url="体验版", store_meal_name=store_meal_name,
                                            commodity_code=commodity_code, commodity_type=smqs[0]['commodity_type'],
                                            rank_id=rank, status=1, uid_bucket_id=uid_bucket_id, ai_rank_id=1)
 
                 duq = Device_User.objects.filter(userID=userID).values('username')
                 dvq = Device_Info.objects.filter(UID=uid, vodPrimaryUserID='', vodPrimaryMaster='')
 
-
-
                 if dvq.exists():
                     dvq_set_update_dict = {
                         'vodPrimaryUserID': userID,
@@ -1396,33 +1442,38 @@ class CloudStorageView(View):
                                      'Dear customer,you already subscribed the cloud storage package successfully for device ' + device_name + ' on ' + time.strftime(
                                          "%b %dth,%Y", time.localtime())]
 
-                returnurl = "{SERVER_DOMAIN_SSL}cloudstorage/payOK?lang={lang}".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL,lang=lang)
+                returnurl = "{SERVER_DOMAIN_SSL}cloudstorage/payOK?lang={lang}".format(
+                    SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL, lang=lang)
                 if pay_type == 10:
                     ExperienceContextModel.objects.create(
                         experience_type=0,
                         uid=uid,
                         do_time=nowTime
                     )
-                    returnurl = "{SERVER_DOMAIN_SSL}cloudstorage/payOK?paytype=10&lang={lang}".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL,lang=lang)
+                    returnurl = "{SERVER_DOMAIN_SSL}cloudstorage/payOK?paytype=10&lang={lang}".format(
+                        SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL, lang=lang)
                     datetime = time.strftime("%Y-%m-%d", time.localtime())
                     sys_msg_text_list = ['温馨提示：尊敬的客户，您的' + device_name + '设备在' + datetime + '已成功开通云存体验套餐',
-                                         'Dear customer,you already subscribed the free trial cloud storage service successfully for device ' + device_name + ' on '+ time.strftime("%b %dth,%Y", time.localtime())]
+                                         'Dear customer,you already subscribed the free trial cloud storage service successfully for device ' + device_name + ' on ' + time.strftime(
+                                             "%b %dth,%Y", time.localtime())]
                     sms = 'SMS_222870823'
                 if pay_type == 11:
                     update_dict = {}
                     update_dict['is_activate'] = 1
                     update_dict['order'] = orderID
                     CDKcontextModel.objects.filter(cdk=cdk).update(**update_dict)
-                    returnurl = "{SERVER_DOMAIN_SSL}cloudstorage/payOK?paytype=11&lang={lang}".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL,lang=lang)
+                    returnurl = "{SERVER_DOMAIN_SSL}cloudstorage/payOK?paytype=11&lang={lang}".format(
+                        SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL, lang=lang)
 
                     datetime = time.strftime("%Y-%m-%d", time.localtime())
                     sys_msg_text_list = ['温馨提示：尊敬的客户，您的' + device_name + '设备在' + datetime + '已成功兑换云存套餐',
-                                         'Dear customer, you already redeemed for the cloud storage package successfully for device ' +device_name +' on '+time.strftime("%b %dth,%Y", time.localtime())]
+                                         'Dear customer, you already redeemed for the cloud storage package successfully for device ' + device_name + ' on ' + time.strftime(
+                                             "%b %dth,%Y", time.localtime())]
                     sms = 'SMS_219748439'
 
                 self.do_vod_msg_Notice(uid, channel, userID, lang, sys_msg_text_list, sms)
                 result = returnurl
-                redisObj.del_data(key=uid+'do_experience_order')
+                redisObj.del_data(key=uid + 'do_experience_order')
                 return response.json(0, result)
         except Exception as e:
             logger.info('出错了~体验云存异常,errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
@@ -1482,8 +1533,9 @@ class CloudStorageView(View):
         now_time = int(time.time())
         bucket_id_list = []
         store_list = []
-        uid_bucket = UID_Bucket.objects.filter(uid=uid, endTime__gte=now_time).values("id", "uid","bucket__content",
-                                                                    "use_status","endTime","has_unused","bucket__id")
+        uid_bucket = UID_Bucket.objects.filter(uid=uid, endTime__gte=now_time).values("id", "uid", "bucket__content",
+                                                                                      "use_status", "endTime",
+                                                                                      "has_unused", "bucket__id")
         if not uid_bucket:
             return response.json(10030)
 
@@ -1502,11 +1554,11 @@ class CloudStorageView(View):
         bucket_id_list.append(uid_bucket[0]['bucket__id'])
         if has_unused == 1:
             unuseds = Unused_Uid_Meal.objects.filter(uid=uid).annotate(unused_id=F('id')) \
-                .values("unused_id","uid","bucket__content","num","bucket__id","expire")
+                .values("unused_id", "uid", "bucket__content", "num", "bucket__id", "expire")
             month = 'month' if lang != 'cn' else '个月'
             for ub in unuseds:
                 storage_time = ub['num'] * ub['expire']
-                if lang != 'cn' and storage_time > 1:   # 英文大于一个月使用复数
+                if lang != 'cn' and storage_time > 1:  # 英文大于一个月使用复数
                     month += 's'
                 storage = "{storage_time}{month}".format(storage_time=storage_time, month=month)
                 unused_dict = {
@@ -1520,7 +1572,9 @@ class CloudStorageView(View):
                 }
                 store_list.append(unused_dict)
                 bucket_id_list.append(ub['bucket__id'])
-        smqs = Store_Meal.objects.filter(bucket__id__in=bucket_id_list, lang__lang=lang).values('lang__lang','bucket__id','lang__title')
+        smqs = Store_Meal.objects.filter(bucket__id__in=bucket_id_list, lang__lang=lang).values('lang__lang',
+                                                                                                'bucket__id',
+                                                                                                'lang__title')
         for index, value in enumerate(store_list):
             for sm in smqs:
                 if value['bucket__id'] == sm['bucket__id']:
@@ -1538,10 +1592,10 @@ class CloudStorageView(View):
         unused_id = request_dict.get('switch_commodity_id', None)
         if unused_id:
             # 切换设备套餐关联
-            using_uid_bucket = UID_Bucket.objects.filter(uid=uid,has_unused=1).values("id", "uid", "endTime",
-                                                                 "bucket__content","addTime")
-            unuseds = Unused_Uid_Meal.objects.filter(id=unused_id).values("id","uid","channel","addTime","expire",
-                                                                         "num","bucket_id")
+            using_uid_bucket = UID_Bucket.objects.filter(uid=uid, has_unused=1).values("id", "uid", "endTime",
+                                                                                       "bucket__content", "addTime")
+            unuseds = Unused_Uid_Meal.objects.filter(id=unused_id).values("id", "uid", "channel", "addTime", "expire",
+                                                                          "num", "bucket_id")
             if not unuseds.exists() or not using_uid_bucket.exists():
                 return response.json(10030)
             unused = unuseds[0]
@@ -1549,10 +1603,11 @@ class CloudStorageView(View):
             try:
                 with transaction.atomic():
                     count_unused = Unused_Uid_Meal.objects.filter(uid=uid).count()
-                    has_unused = 1 if count_unused>1 else 0
+                    has_unused = 1 if count_unused > 1 else 0
                     endTime = CommonService.calcMonthLater(unused['expire'] * unused['num'])
-                    UID_Bucket.objects.filter(uid=uid).update(channel=unused['channel'],endTime=endTime,bucket_id=unused['bucket_id']
-                                                              ,updateTime=nowTime,use_status=1, has_unused=has_unused)
+                    UID_Bucket.objects.filter(uid=uid).update(channel=unused['channel'], endTime=endTime,
+                                                              bucket_id=unused['bucket_id']
+                                                              , updateTime=nowTime, use_status=1, has_unused=has_unused)
                     Unused_Uid_Meal.objects.filter(id=unused_id).delete()
                     StsCrdModel.objects.filter(uid=uid).delete()  # 删除sts记录
                     # VodHlsModel.objects.filter(uid=uid).delete()  # 删除播放列表,后期数据量多时应该考虑延后删除
@@ -1571,12 +1626,14 @@ class CloudStorageView(View):
         if dv_qs[0]['vodPrimaryUserID'] != userID:
             return response.json(10034)
         now_time = int(time.time())
-        bv_qs = UID_Bucket.objects.filter(uid=uid, endTime__gte=now_time ,channel=channel).values('bucket_id').order_by('addTime')
+        bv_qs = UID_Bucket.objects.filter(uid=uid, endTime__gte=now_time, channel=channel).values('bucket_id').order_by(
+            'addTime')
         if not bv_qs.exists():
             return response.json(10030)
 
         had_vod_query = VodHlsModel.objects.extra(select={'date': "FROM_UNIXTIME(time,'%%Y-%%m-%%d')"}).values(
-            'date').filter(uid=uid,endTime__gte=now_time,channel=channel).annotate(count=Count('time')).order_by('-date')[:31]
+            'date').filter(uid=uid, endTime__gte=now_time, channel=channel).annotate(count=Count('time')).order_by(
+            '-date')[:31]
 
         had_vod_list = []
         for vod in had_vod_query:
@@ -1644,15 +1701,16 @@ class CloudStorageView(View):
                         device_name = CommonService.get_full_serial_number(uid, serial_number, device_type)
                     else:
                         device_name = uid
-                    params = u'{"devname":"' + device_name + '","submittime":"' + time.strftime("%Y-%m-%d",time.localtime()) + '"}'
+                    params = u'{"devname":"' + device_name + '","submittime":"' + time.strftime("%Y-%m-%d",
+                                                                                                time.localtime()) + '"}'
                     self.sendMessage(username, params, sms)
 
                 self.pushApp(nowTime, uid, channel, sys_msg_text)
 
-
             logger.info('出去了')
         except Exception as e:
             return repr(e)
+
     # 云存到期续费提醒   提前3天
     def do_vod_msg_end(self, request_dict):
         response = ResponseObject()
@@ -1662,12 +1720,18 @@ class CloudStorageView(View):
         # self.do_vod_msg(now_time,list)
 
         # 过期前第7天提示一次
-        list = UID_Bucket.objects.filter(Q(endTime__gt=now_time + 3600 * 144) & Q(endTime__lte=(now_time + 3600 * 168))).values('id','uid','bucket__area','channel','endTime')
-        self.do_vod_msg(now_time,list)
+        list = UID_Bucket.objects.filter(
+            Q(endTime__gt=now_time + 3600 * 144) & Q(endTime__lte=(now_time + 3600 * 168))).values('id', 'uid',
+                                                                                                   'bucket__area',
+                                                                                                   'channel', 'endTime')
+        self.do_vod_msg(now_time, list)
 
         # 过期前第3天提示一次
-        list = UID_Bucket.objects.filter(Q(endTime__gt=now_time + 3600 * 48) & Q(endTime__lte=(now_time + 3600 * 72))).values('id','uid','bucket__area','channel','endTime')
-        self.do_vod_msg(now_time,list)
+        list = UID_Bucket.objects.filter(
+            Q(endTime__gt=now_time + 3600 * 48) & Q(endTime__lte=(now_time + 3600 * 72))).values('id', 'uid',
+                                                                                                 'bucket__area',
+                                                                                                 'channel', 'endTime')
+        self.do_vod_msg(now_time, list)
         return response.json(0)
 
     def do_vod_msg(self, now_time, list):
@@ -1682,7 +1746,7 @@ class CloudStorageView(View):
             for oo in oqlist:
                 if ub['id'] == oo['uid_bucket_id']:
                     # 如果存在序列号,消息提示用序列号
-                    uid=ub['uid']
+                    uid = ub['uid']
                     device_info_qs = Device_Info.objects.filter(UID=uid).values('serial_number', 'Type')
                     serial_number = device_info_qs[0]['serial_number']
                     device_type = device_info_qs[0]['Type']
@@ -1691,9 +1755,12 @@ class CloudStorageView(View):
                     else:
                         device_name = uid
                     if ub['bucket__area'] == 'cn':
-                        sys_msg_text = "温馨提示：尊敬的客户，您" + device_name + "设备的云存套餐将在" + time.strftime("%Y-%m-%d", time.localtime(ub['endTime'])) + "到期"
+                        sys_msg_text = "温馨提示：尊敬的客户，您" + device_name + "设备的云存套餐将在" + time.strftime("%Y-%m-%d",
+                                                                                                  time.localtime(ub[
+                                                                                                                     'endTime'])) + "到期"
                     else:
-                        sys_msg_text = 'Dear customer,the cloud storage package for your device '+device_name+' will expire on '+time.strftime('%m-%d-%y',time.localtime(ub['endTime']))
+                        sys_msg_text = 'Dear customer,the cloud storage package for your device ' + device_name + ' will expire on ' + time.strftime(
+                            '%m-%d-%y', time.localtime(ub['endTime']))
                     uq_list.append(SysMsgModel(
                         userID_id=oo['userID_id'],
                         addTime=now_time,
@@ -1714,13 +1781,13 @@ class CloudStorageView(View):
                             S3Email().faEmail(sys_msg_text, username)
                         elif data_valid.mobile_validate(username):
                             params = u'{"devname":"' + device_name + '","submittime":"' + time.strftime("%Y-%m-%d",
-                                                                                                      time.localtime(ub['endTime'])) + '"}'
+                                                                                                        time.localtime(
+                                                                                                            ub[
+                                                                                                                'endTime'])) + '"}'
                             self.sendMessage(username, params, 'SMS_219748440')
 
                         self.pushApp(now_time, ub['uid'], ub['channel'], sys_msg_text)
 
-
-
     def pushApp(self, nowTime, uid, channel, sys_msg_text):
         n_time = nowTime
 
@@ -1838,21 +1905,21 @@ class CloudStorageView(View):
                 print(res)
                 return res.status_code
 
-    def sendMessage(self, phone , params, temp_msg):
-            # 购买成功
-            sign_ms = '周视'
-            # 发送手机验证码
-            aliSms = AliSmsObject()
-            res = aliSms.send_code_sms_cloud(phone=phone, params = params, sign_name=sign_ms,
-                                       temp_msg=temp_msg)
+    def sendMessage(self, phone, params, temp_msg):
+        # 购买成功
+        sign_ms = '周视'
+        # 发送手机验证码
+        aliSms = AliSmsObject()
+        res = aliSms.send_code_sms_cloud(phone=phone, params=params, sign_name=sign_ms,
+                                         temp_msg=temp_msg)
 
     def do_refund(self, request_dict, response):
-        orderID = request_dict.get('orderID', None)    # 商户订单号
+        orderID = request_dict.get('orderID', None)  # 商户订单号
         refund_amount = request_dict.get('refund_amount', None)  # 退款金额
         if not all([orderID, refund_amount]):
             return response.json(444)
         try:
-            order_qs = Order_Model.objects.filter(orderID=orderID).\
+            order_qs = Order_Model.objects.filter(orderID=orderID). \
                 values('status', 'payType', 'price', 'refunded_amount', 'currency', 'paymentID')
             if not order_qs.exists():
                 return response.json(173)
@@ -1865,21 +1932,21 @@ class CloudStorageView(View):
             refund_amount = float(refund_amount)
             now_time = int(time.time())
             payType = order_qs[0]['payType']
-            price = order_qs[0]['price']                        # 订单金额
-            refunded_amount = order_qs[0]['refunded_amount']    # 已退款金额
-            currency = order_qs[0]['currency']                  # 货币
+            price = order_qs[0]['price']  # 订单金额
+            refunded_amount = order_qs[0]['refunded_amount']  # 已退款金额
+            currency = order_qs[0]['currency']  # 货币
 
             # 判断是否符合付款条件
-            if refunded_amount == float(price):                 # 已全额退款
+            if refunded_amount == float(price):  # 已全额退款
                 return response.json(805)
             if refund_amount + refunded_amount > float(price):  # 退款金额超出订单价格
                 return response.json(805)
             # 部分退款标识
-            is_partial_refund = True if(float(price) > refund_amount + refunded_amount) else False
+            is_partial_refund = True if (float(price) > refund_amount + refunded_amount) else False
 
-            out_request_no = str(time.strftime('%Y%m%d%H%M%S', time.localtime(now_time)))    # 退款请求号
+            out_request_no = str(time.strftime('%Y%m%d%H%M%S', time.localtime(now_time)))  # 退款请求号
             # 根据支付类型处理退款
-            if payType == 1:    # PayPal
+            if payType == 1:  # PayPal
                 paymentID = order_qs[0]['paymentID']  # PayPal PAYMENT_ID
                 if not paymentID:
                     return response.json(805)
@@ -1910,14 +1977,14 @@ class CloudStorageView(View):
                 alipay = aliPayObj.conf()
                 refund_response = alipay.api_alipay_trade_refund(refund_amount=refund_amount, out_trade_no=orderID,
                                                                  out_request_no=out_request_no)
-                refund_success = True if(refund_response['code'] == '10000') else False
+                refund_success = True if (refund_response['code'] == '10000') else False
             elif payType == 3:  # 微信
                 wechatPayObj = WechatPayObject()
                 refund_fee = int(refund_amount * 100)  # 退款金额,单位为分,只能为整数
                 success = wechatPayObj.refund(out_trade_no=orderID, out_refund_no=out_request_no,
                                               total_fee=refund_fee, refund_fee=refund_fee)
                 refund_success = True if success else False
-            else:   # 不支持退款的支付类型
+            else:  # 不支持退款的支付类型
                 return response.json(805)
 
             # 更新订单状态和已退款金额
@@ -1932,5 +1999,3 @@ class CloudStorageView(View):
         except Exception as e:
             print(e)
             return response.json(500, repr(e))
-
-

Controller/Cron/CronTaskController.py

@@ -8,17 +8,22 @@
 # @File    : CronTaskController.py
 # @Software: PyCharm
 import datetime
+import threading
 import time
 
+import requests
 from django.db import connection, connections, transaction
-from django.db.models import Q
+from django.db.models import Q, Sum, Count
 from django.views import View
 
 from Model.models import Device_User, Device_Info, UidSetModel, UID_Bucket, Unused_Uid_Meal, Order_Model, StsCrdModel, \
-    VodHlsModel, ExperienceContextModel, AiService
+    VodHlsModel, ExperienceContextModel, AiService, VodHlsSummary, VideoPlaybackTimeModel, DeviceUserSummary, \
+    CountryModel, DeviceTypeModel, Lang, UnicomCombo, OrdersSummary, DeviceInfoSummary, CompanySerialModel
+from Object.RedisObject import RedisObject
 from Object.ResponseObject import ResponseObject
 from Object.utils import LocalDateTimeUtil
 from Service.CommonService import CommonService
+from Ansjer.config import USED_SERIAL_REDIS_LIST, UNUSED_SERIAL_REDIS_LIST
 
 
 class CronDelDataView(View):
@@ -104,14 +109,27 @@ class CronDelDataView(View):
     @staticmethod
     def delVodHls(response):
         nowTime = int(time.time())
-        cursor = connection.cursor()
         try:
-            # 删除3个月前的数据
-            sql = "DELETE FROM `vod_hls` WHERE endTime<={} LIMIT 50000".format(
-                nowTime - 3 * 30 * 24 * 60 * 60)
-            cursor.execute(sql)
-            # 关闭游标
-            cursor.close()
+            with transaction.atomic():
+                month_ago_time = nowTime - 30 * 24 * 60 * 60  # 删除1个月前的数据
+                vod_hls_qs = VodHlsModel.objects.filter(endTime__lte=month_ago_time)
+                for vod_hls in vod_hls_qs:
+                    end_time = vod_hls.endTime
+                    end_time_str = datetime.datetime.fromtimestamp(int(end_time))
+                    this_month_start = datetime.datetime(end_time_str.year, end_time_str.month, 1)
+                    this_month_start_stamp = CommonService.str_to_timestamp(
+                        this_month_start.strftime('%Y-%m-%d %H:%M:%S'))
+                    vod_hls_summary_qs = VodHlsSummary.objects.filter(time=this_month_start_stamp,
+                                                                      uid=vod_hls.uid)
+                    if vod_hls_summary_qs.exists():
+                        vod_hls_summary = vod_hls_summary_qs.first()
+                        vod_hls_summary.upload_duration = vod_hls_summary.upload_duration + vod_hls.sec
+                        vod_hls_summary.upload_frequency = vod_hls_summary.upload_frequency + 1
+                        vod_hls_summary.save()
+                    else:
+                        VodHlsSummary.objects.create(time=this_month_start_stamp, uid=vod_hls.uid,
+                                                     upload_duration=vod_hls.sec, upload_frequency=1)
+                    vod_hls.delete()
             return response.json(0)
         except Exception as e:
             return response.json(500, repr(e))
@@ -189,6 +207,10 @@ class CronUpdateDataView(View):
             return self.updateUnusedUidBucket(response)
         elif operation == 'updateUnusedAiService':  # 定时更新过期ai关联的未使用套餐状态
             return self.updateUnusedAiService(response)
+        elif operation == 'reqUpdateSerialStatus':  # 定时请求更新序列号状态
+            return self.reqUpdateSerialStatus(response)
+        elif operation == 'updateSerialStatus':  # 更新序列号状态
+            return self.updateSerialStatus(request_dict, response)
         else:
             return response.json(404)
 
@@ -276,3 +298,482 @@ class CronUpdateDataView(View):
             except Exception:
                 continue
         return response.json(0)
+
+    @classmethod
+    def reqUpdateSerialStatus(cls, response):
+        redis_obj = RedisObject()
+        # 更新已使用序列号其他服务器的状态
+        used_serial_redis_list_len = redis_obj.llen(USED_SERIAL_REDIS_LIST)
+        if used_serial_redis_list_len > 0:
+            used_serial_redis_list = []
+            for i in range(used_serial_redis_list_len):
+                used_serial_redis_list.append(redis_obj.lpop(USED_SERIAL_REDIS_LIST))
+            request_thread = threading.Thread(target=cls.do_request_thread, args=(used_serial_redis_list, 3))
+            request_thread.start()
+        # 更新未使用序列号其他服务器的状态
+        unused_serial_redis_list_len = redis_obj.llen(UNUSED_SERIAL_REDIS_LIST)
+        if unused_serial_redis_list_len > 0:
+            unused_serial_redis_list = []
+            for i in range(unused_serial_redis_list_len):
+                unused_serial_redis_list.append(redis_obj.lpop(UNUSED_SERIAL_REDIS_LIST))
+            request_thread = threading.Thread(target=cls.do_request_thread, args=(used_serial_redis_list, 1))
+            request_thread.start()
+        return response.json(0)
+
+    @staticmethod
+    def do_request_thread(serial_redis_list, status):
+        """
+        请求更新序列号线程
+        @param serial_redis_list: 序列号redis列表
+        @param status: 状态, 1: 未使用, 3: 已占用
+        """
+        data = {
+            'serial_redis_list': serial_redis_list,
+            'status': status
+        }
+        # 确认域名列表
+        orders_domain_name_list = CommonService.get_orders_domain_name_list()
+        for domain_name in orders_domain_name_list:
+            url = '{}cron/update/updateSerialStatus'.format(domain_name)
+            requests.post(url=url, data=data, timeout=2)
+
+    @staticmethod
+    def updateSerialStatus(request_dict, response):
+        serial_redis_list = request_dict.get('serial_redis_list', None)
+        status = request_dict.get('status', None)
+        if not all([serial_redis_list, status]):
+            return response.json(444)
+        serial_redis_list = eval(serial_redis_list)
+        CompanySerialModel.objects.filter(serial_number__in=serial_redis_list).update(status=int(status))
+
+class CronCollectDataView(View):
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        operation = kwargs.get('operation')
+        return self.validation(request.GET, request, operation)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        operation = kwargs.get('operation')
+        return self.validation(request.POST, request, operation)
+
+    def validation(self, request_dict, request, operation):
+        response = ResponseObject()
+        if operation == 'collectPlayBack':  # 定时保存云存视频回放
+            return self.collect_play_back(response)
+        elif operation == 'collectDeviceUser':  # 定时保存用户数据
+            return self.collect_device_user(response)
+        elif operation == 'collectOrder':  # 定时保存订单数据
+            return self.collect_order(response)
+        elif operation == 'collectDeviceInfo':  # 定时保存设备数据
+            return self.collect_device_info(response)
+        else:
+            return response.json(404)
+
+    @staticmethod
+    def collect_play_back(response):
+        try:
+            end_time = int(time.time())
+            start_time = end_time - 24 * 60 * 60  # 每天执行一次
+            today = datetime.datetime.today()
+            this_month_str = datetime.datetime(today.year, today.month, 1)
+            this_month_stamp = CommonService.str_to_timestamp(this_month_str.strftime('%Y-%m-%d %H:%M:%S'))
+            video_play_back_time_qs = VideoPlaybackTimeModel.objects.filter(startTime__gte=start_time,
+                                                                            startTime__lt=end_time,
+                                                                            playMode='cloud').values('uid').annotate(
+                play_duration=Sum('duration'), play_frequency=Count('uid'))
+            with transaction.atomic():
+                for item in video_play_back_time_qs:
+                    vod_hls_summary_qs = VodHlsSummary.objects.filter(uid=item['uid'], time=this_month_stamp)
+                    if vod_hls_summary_qs.exists():
+                        vod_hls_summary = vod_hls_summary_qs.first()
+                        vod_hls_summary.play_duration += item['play_duration']
+                        vod_hls_summary.play_frequency += 1
+                        vod_hls_summary.save()
+                    else:
+                        VodHlsSummary.objects.create(uid=item['uid'], time=this_month_stamp,
+                                                     play_duration=item['play_duration'], play_frequency=1)
+
+            return response.json(0)
+        except Exception as e:
+            return response.json(500, repr(e))
+
+    @staticmethod
+    def collect_device_user(response):
+        try:
+            today = datetime.datetime.today()
+            start_time = datetime.datetime(today.year, today.month, today.day)
+            end_time = start_time + datetime.timedelta(days=1)
+            increase_user_qs = Device_User.objects.filter(data_joined__gte=start_time, data_joined__lt=end_time).values(
+                'data_joined',
+                'region_country')
+            active_user_qs = Device_User.objects.filter(last_login__gte=start_time, last_login__lt=end_time).values(
+                'last_login',
+                'region_country')
+            start_time = CommonService.str_to_timestamp(start_time.strftime('%Y-%m-%d %H:%M:%S'))
+            country_qs = CountryModel.objects.all().values('id', 'region__name', 'country_name')
+            country_dict = {}
+            continent_dict = {}
+            for item in country_qs:
+                country_dict[item['id']] = item['country_name']
+                continent_dict[item['country_name']] = item['region__name']
+            with transaction.atomic():
+                for item in increase_user_qs:
+                    device_user_summary_qs = DeviceUserSummary.objects.filter(time=start_time, query_type=0)
+                    country_name = country_dict.get(item['region_country'], '未知国家')
+                    continent_name = continent_dict.get(country_name, '未知大洲')
+                    if device_user_summary_qs.exists():
+                        device_user_summary = device_user_summary_qs.first()
+                        country_temp_dict = eval(device_user_summary.country)
+                        continent_temp_dict = eval(device_user_summary.continent)
+                        if country_name in country_temp_dict:
+                            country_temp_dict[country_name] += 1
+                        else:
+                            country_temp_dict[country_name] = 1
+                        if continent_name in continent_temp_dict:
+                            continent_temp_dict[continent_name] += 1
+                        else:
+                            continent_temp_dict[continent_name] = 1
+                        device_user_summary.country = country_temp_dict
+                        device_user_summary.continent = continent_temp_dict
+                        device_user_summary.count += 1
+                        device_user_summary.save()
+                    else:
+                        country_temp_dict = {country_name: 1}
+                        continent_temp_dict = {continent_name: 1}
+                        DeviceUserSummary.objects.create(time=start_time, count=1,
+                                                         country=country_temp_dict,
+                                                         continent=continent_temp_dict)
+                for item in active_user_qs:
+                    device_user_summary_qs = DeviceUserSummary.objects.filter(time=start_time, query_type=1)
+                    country_name = country_dict.get(item['region_country'], '未知国家')
+                    continent_name = continent_dict.get(country_name, '未知大洲')
+                    if device_user_summary_qs.exists():
+                        device_user_summary = device_user_summary_qs.first()
+                        country_temp_dict = eval(device_user_summary.country)
+                        continent_temp_dict = eval(device_user_summary.continent)
+                        if country_name in country_temp_dict:
+                            country_temp_dict[country_name] += 1
+                        else:
+                            country_temp_dict[country_name] = 1
+                        if continent_name in continent_temp_dict:
+                            continent_temp_dict[continent_name] += 1
+                        else:
+                            continent_temp_dict[continent_name] = 1
+                        device_user_summary.country = country_temp_dict
+                        device_user_summary.continent = continent_temp_dict
+                        device_user_summary.count += 1
+                        device_user_summary.save()
+                    else:
+                        country_temp_dict = {country_name: 1}
+                        continent_temp_dict = {continent_name: 1}
+                        DeviceUserSummary.objects.create(time=start_time, query_type=1, count=1,
+                                                         country=country_temp_dict,
+                                                         continent=continent_temp_dict)
+
+            return response.json(0)
+        except Exception as e:
+            return response.json(500, repr(e))
+
+    @staticmethod
+    def collect_order(response):
+        try:
+            today = datetime.datetime.today()
+            start_time = datetime.datetime(today.year, today.month, today.day)
+            end_time = start_time + datetime.timedelta(days=1)
+            start_time = CommonService.str_to_timestamp(start_time.strftime('%Y-%m-%d %H:%M:%S'))
+            end_time = CommonService.str_to_timestamp(end_time.strftime('%Y-%m-%d %H:%M:%S'))
+            order_qs = Order_Model.objects.filter(addTime__gte=start_time, addTime__lt=end_time,
+                                                  status=1).values('UID', 'order_type',
+                                                                   'ai_rank', 'price',
+                                                                   'unify_combo_id',
+                                                                   'rank',
+                                                                   'addTime').order_by(
+                'addTime')
+            uid_list = []
+            all_order_qs = Order_Model.objects.filter(addTime__lt=start_time, status=1).values('UID')
+            for item in all_order_qs:
+                if item['UID'] not in uid_list:
+                    uid_list.append(item['UID'])
+            # 国家表数据
+            country_qs = CountryModel.objects.values('id', 'country_name')
+            country_dict = {}
+            for item in country_qs:
+                country_dict[item['id']] = item['country_name']
+            # 设备类型数据
+            device_type_qs = DeviceTypeModel.objects.values('name', 'type')
+            device_type_dict = {}
+            for item in device_type_qs:
+                device_type_dict[item['type']] = item['name']
+            # 云存套餐数据
+            cloud_store_meal_dict = {}
+            cloud_lang_qs = Lang.objects.filter(lang='cn').values('store_meal__id', 'title', 'content')
+            for item in cloud_lang_qs:
+                cloud_store_meal_dict[item['store_meal__id']] = item['title'] + ':' + item['content']
+            # AI套餐数据
+            ai_store_meal_dict = {}
+            ai_lang_qs = Lang.objects.filter(lang='cn').values('aistoremeal__id', 'title', 'content')
+            for item in ai_lang_qs:
+                ai_store_meal_dict[item['aistoremeal__id']] = item['title'] + ':' + item['content']
+            # 4g套餐数据
+            unicom_combo_store_meal_dict = {}
+            unicom_combo_qs = UnicomCombo.objects.values('id', 'combo_name')
+            for item in unicom_combo_qs:
+                unicom_combo_store_meal_dict[item['id']] = item['combo_name']
+
+            with transaction.atomic():
+                for item in order_qs:
+                    is_pay = 0
+                    price = float(item['price'])
+                    uid_set_qs = UidSetModel.objects.filter(uid=item['UID']).values('tb_country')
+                    country_id = uid_set_qs[0]['tb_country'] if uid_set_qs.exists() else 0
+                    country_name = country_dict.get(country_id, '未知国家')
+                    order_type = item['order_type']
+                    device_info_qs = Device_Info.objects.filter(UID=item['UID']).values('Type')
+                    device_type_id = device_info_qs[0]['Type'] if device_info_qs.exists() else 0
+                    device_type_name = device_type_dict.get(device_type_id, '未知设备')
+                    if item['order_type'] == 0:
+                        store_meal_id = item['rank']
+                        store_meal_name = cloud_store_meal_dict.get(store_meal_id, '未知套餐')
+                    elif item['order_type'] == 1:
+                        store_meal_id = item['ai_rank']
+                        store_meal_name = ai_store_meal_dict.get(store_meal_id, '未知套餐')
+                    else:
+                        store_meal_id = item['unify_combo_id']
+                        store_meal_name = unicom_combo_store_meal_dict.get(store_meal_id, '未知套餐')
+                    add_time_stamp = item['addTime']
+                    add_time_str = datetime.datetime.fromtimestamp(int(add_time_stamp))
+                    add_time_str = datetime.datetime(add_time_str.year, add_time_str.month, add_time_str.day)
+                    add_time_stamp = CommonService.str_to_timestamp(add_time_str.strftime('%Y-%m-%d %H:%M:%S'))
+                    if price == 0:
+                        is_pay = 1
+                        order_summary_qs = OrdersSummary.objects.filter(time=add_time_stamp, query_type=1,
+                                                                        service_type=order_type)
+                    else:
+                        order_summary_qs = OrdersSummary.objects.filter(time=add_time_stamp, query_type=0,
+                                                                        service_type=order_type)
+                        if item['UID'] not in uid_list:
+                            pay_order_summary_qs = OrdersSummary.objects.filter(time=add_time_stamp, query_type=2,
+                                                                                service_type=order_type)
+                            query_type = 2
+                        else:
+                            pay_order_summary_qs = OrdersSummary.objects.filter(time=add_time_stamp, query_type=3,
+                                                                                service_type=order_type)
+                            query_type = 3
+                        if pay_order_summary_qs.exists():
+                            pay_order_summary = pay_order_summary_qs.first()
+                            pay_order_summary.count += 1
+                            pay_order_summary.total = str(round(float(pay_order_summary.total) + price, 2))
+                            country_temp_dict = eval(pay_order_summary.country)
+                            if country_name in country_temp_dict:
+                                country_temp_dict[country_name] += 1
+                            else:
+                                country_temp_dict[country_name] = 1
+                            pay_order_summary.country = country_temp_dict
+                            device_type_temp_dict = eval(pay_order_summary.device_type)
+                            if device_type_name in device_type_temp_dict:
+                                device_type_temp_dict[device_type_name] += 1
+                            else:
+                                device_type_temp_dict[device_type_name] = 1
+                            pay_order_summary.device_type = device_type_temp_dict
+                            store_meal_temp_dict = eval(pay_order_summary.store_meal)
+                            if store_meal_name in store_meal_temp_dict:
+                                store_meal_temp_dict[store_meal_name] += 1
+                            else:
+                                store_meal_temp_dict[store_meal_name] = 1
+                            pay_order_summary.store_meal = store_meal_temp_dict
+                            pay_order_summary.save()
+                        else:
+                            country_temp_dict = {
+                                country_name: 1
+                            }
+                            device_type_temp_dict = {
+                                device_type_name: 1
+                            }
+                            store_meal_temp_dict = {
+                                store_meal_name: 1
+                            }
+                            OrdersSummary.objects.create(time=add_time_stamp, count=1, query_type=query_type,
+                                                         service_type=order_type, total=price,
+                                                         country=country_temp_dict,
+                                                         device_type=device_type_temp_dict,
+                                                         store_meal=store_meal_temp_dict)
+                    if order_summary_qs.exists():
+                        order_summary = order_summary_qs.first()
+                        order_summary.count += 1
+                        order_summary.total = str(round(float(order_summary.total) + price, 2))
+                        country_temp_dict = eval(order_summary.country)
+                        if country_name in country_temp_dict:
+                            country_temp_dict[country_name] += 1
+                        else:
+                            country_temp_dict[country_name] = 1
+                        order_summary.country = country_temp_dict
+                        device_type_temp_dict = eval(order_summary.device_type)
+                        if device_type_name in device_type_temp_dict:
+                            if is_pay == 0:
+                                device_type_temp_dict[device_type_name]['数量'] += 1
+                                device_type_temp_dict[device_type_name]['销售额'] = str(
+                                    round(float(device_type_temp_dict[device_type_name]['销售额']) + price, 2))
+                            else:
+                                device_type_temp_dict[device_type_name] += 1
+                        else:
+                            if is_pay == 0:
+                                device_type_temp_dict[device_type_name] = {'数量': 1, '销售额': price}
+                            else:
+                                device_type_temp_dict[device_type_name] = 1
+                        order_summary.device_type = device_type_temp_dict
+                        store_meal_temp_dict = eval(order_summary.store_meal)
+                        if store_meal_name in store_meal_temp_dict:
+                            if is_pay == 0:
+                                store_meal_temp_dict[store_meal_name]['数量'] += 1
+                                store_meal_temp_dict[store_meal_name]['销售额'] = str(
+                                    round(float(store_meal_temp_dict[store_meal_name]['销售额']) + price, 2))
+                            else:
+                                store_meal_temp_dict[store_meal_name] += 1
+                        else:
+                            if is_pay == 0:
+                                store_meal_temp_dict[store_meal_name] = {'数量': 1, '销售额': price}
+                            else:
+                                store_meal_temp_dict[store_meal_name] = 1
+                        order_summary.store_meal = store_meal_temp_dict
+                        order_summary.save()
+                    else:
+                        country_temp_dict = {
+                            country_name: 1
+                        }
+                        if is_pay == 0:
+                            device_type_temp_dict = {
+                                device_type_name: {
+                                    '数量': 1,
+                                    '销售额': price
+                                }
+                            }
+                            store_meal_temp_dict = {
+                                store_meal_name: {
+                                    '数量': 1,
+                                    '销售额': price
+                                }
+                            }
+                        else:
+                            device_type_temp_dict = {
+                                device_type_name: 1
+                            }
+                            store_meal_temp_dict = {
+                                store_meal_name: 1
+                            }
+                        OrdersSummary.objects.create(time=add_time_stamp, count=1, query_type=is_pay,
+                                                     service_type=order_type, total=price,
+                                                     country=country_temp_dict,
+                                                     device_type=device_type_temp_dict, store_meal=store_meal_temp_dict)
+            return response.json(0)
+        except Exception as e:
+            return response.json(500, repr(e))
+
+    @staticmethod
+    def collect_device_info(response):
+        try:
+            today = datetime.datetime.today()
+            start_time = datetime.datetime(today.year, today.month, today.day)
+            end_time = start_time + datetime.timedelta(days=1)
+            start_time = CommonService.str_to_timestamp(start_time.strftime('%Y-%m-%d %H:%M:%S'))
+            end_time = CommonService.str_to_timestamp(end_time.strftime('%Y-%m-%d %H:%M:%S'))
+            increase_device_qs = UidSetModel.objects.filter(addTime__gte=start_time, addTime__lt=end_time).values(
+                'tb_country',
+                'cloud_vod',
+                'uid',
+                'is_ai', 'mobile_4g',
+                'addTime')
+            video_play_back_time_qs = VideoPlaybackTimeModel.objects.filter(startTime__gte=start_time,
+                                                                            startTime__lt=end_time).values('uid')
+            active_device_qs = UidSetModel.objects.filter(uid__in=video_play_back_time_qs).values('tb_country',
+                                                                                                  'addTime',
+                                                                                                  'cloud_vod',
+                                                                                                  'is_ai', 'mobile_4g',
+                                                                                                  'uid')
+            # 国家表数据
+            country_qs = CountryModel.objects.values('id', 'country_name', 'region__name')
+            country_dict = {}
+            continent_dict = {}
+            for item in country_qs:
+                country_dict[item['id']] = item['country_name']
+                continent_dict[item['country_name']] = item['region__name']
+            # 设备类型数据
+            device_type_qs = DeviceTypeModel.objects.values('name', 'type')
+            device_type_dict = {}
+            for item in device_type_qs:
+                device_type_dict[item['type']] = item['name']
+            with transaction.atomic():
+                for index, each in enumerate([increase_device_qs, active_device_qs]):
+                    for item in each:
+                        device_info_qs = Device_Info.objects.filter(UID=item['uid']).values('Type')
+                        device_type_id = device_info_qs[0]['Type'] if device_info_qs.exists() else 0
+                        time_stamp = item['addTime']
+                        time_str = datetime.datetime.fromtimestamp(int(time_stamp))
+                        this_day_str = datetime.datetime(time_str.year, time_str.month, time_str.day)
+                        this_day_stamp = CommonService.str_to_timestamp(this_day_str.strftime('%Y-%m-%d %H:%M:%S'))
+                        device_info_summary_qs = DeviceInfoSummary.objects.filter(time=this_day_stamp, query_type=index)
+                        country_name = country_dict.get(item['tb_country'], '未知国家')
+                        continent_name = continent_dict.get(country_name, '未知大洲')
+                        device_type_name = device_type_dict.get(device_type_id, '未知设备类型')
+                        if device_info_summary_qs.exists():
+                            device_info_summary = device_info_summary_qs.first()
+                            country_temp_dict = eval(device_info_summary.country)
+                            continent_temp_dict = eval(device_info_summary.continent)
+                            vod_service_temp_dict = eval(device_info_summary.vod_service)
+                            device_type_temp_dict = eval(device_info_summary.device_type)
+                            ai_service_temp_dict = eval(device_info_summary.ai_service)
+                            unicom_service_temp_dict = eval(device_info_summary.unicom_service)
+                            if country_name in country_temp_dict:
+                                country_temp_dict[country_name] += 1
+                            else:
+                                country_temp_dict[country_name] = 1
+                            if continent_name in continent_temp_dict:
+                                continent_temp_dict[continent_name] += 1
+                            else:
+                                continent_temp_dict[continent_name] = 1
+                            if item['cloud_vod'] != 2:
+                                if device_type_name in vod_service_temp_dict:
+                                    vod_service_temp_dict[device_type_name] += 1
+                                else:
+                                    vod_service_temp_dict[device_type_name] = 1
+                            if item['is_ai'] != 2:
+                                if device_type_name in ai_service_temp_dict:
+                                    ai_service_temp_dict[device_type_name] += 1
+                                else:
+                                    ai_service_temp_dict[device_type_name] = 1
+                            if item['mobile_4g'] != 2:
+                                if device_type_name in unicom_service_temp_dict:
+                                    unicom_service_temp_dict[device_type_name] += 1
+                                else:
+                                    unicom_service_temp_dict[device_type_name] = 1
+                            if device_type_name in device_type_temp_dict:
+                                device_type_temp_dict[device_type_name] += 1
+                            else:
+                                device_type_temp_dict[device_type_name] = 1
+                            device_info_summary.country = country_temp_dict
+                            device_info_summary.continent = continent_temp_dict
+                            device_info_summary.vod_service = vod_service_temp_dict
+                            device_info_summary.ai_service = ai_service_temp_dict
+                            device_info_summary.unicom_service = unicom_service_temp_dict
+                            device_info_summary.device_type = device_type_temp_dict
+                            device_info_summary.count += 1
+                            device_info_summary.save()
+                        else:
+                            country_temp_dict = {country_name: 1}
+                            continent_temp_dict = {continent_name: 1}
+                            vod_service_temp_dict = {device_type_name: 1} if item['cloud_vod'] != 2 else {}
+                            ai_service_temp_dict = {device_type_name: 1} if item['is_ai'] != 2 else {}
+                            unicom_service_temp_dict = {device_type_name: 1} if item['mobile_4g'] != 2 else {}
+                            device_type_temp_dict = {device_type_name: 1}
+                            DeviceInfoSummary.objects.create(time=this_day_stamp, count=1,
+                                                             query_type=index,
+                                                             country=country_temp_dict,
+                                                             continent=continent_temp_dict,
+                                                             vod_service=vod_service_temp_dict,
+                                                             ai_service=ai_service_temp_dict,
+                                                             unicom_service=unicom_service_temp_dict,
+                                                             device_type=device_type_temp_dict)
+
+            return response.json(0)
+        except Exception as e:
+            return response.json(500, repr(e))

Controller/EquipmentManagerV3.py

@@ -14,7 +14,7 @@ from Controller.CheckUserData import RandomStr
 from Controller.DeviceConfirmRegion import Device_Region
 from Controller.SensorGateway.EquipmentFamilyController import EquipmentFamilyView
 from Model.models import Device_Info, UID_Bucket, UID_Preview, UidSetModel, UidChannelSetModel, \
-    Device_User, iotdeviceInfoModel, UIDCompanySerialModel, UIDModel, UnicomDeviceInfo
+    Device_User, iotdeviceInfoModel, UIDCompanySerialModel, UIDModel, UnicomDeviceInfo, CountryModel
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
 from Service.CommonService import CommonService
@@ -169,10 +169,16 @@ class EquipmentManagerV3(View):
             nowTime = int(time.time())
             us_qs = UidSetModel.objects.filter(uid=UID)
             if us_qs.exists():
-                us_qs.update(nickname=NickName)
+                us_qs.update(nickname=NickName, device_type=Type)
                 UidSet_id = us_qs.first().id
             else:
                 ip = CommonService.get_ip_address(request)
+                ipInfo = CommonService.getIpIpInfo(ip, 'CN')
+                country_qs = CountryModel.objects.filter(country_code=ipInfo['country_code']).values('id')
+                if country_qs.exists():
+                    country = country_qs[0]['id']
+                else:
+                    country = '0'
                 region_id = Device_Region().get_device_region(ip)
                 region_alexa = 'CN' if region_id == 1 else 'ALL'
                 uid_set_create_dict = {
@@ -184,6 +190,8 @@ class EquipmentManagerV3(View):
                     'nickname': NickName,
                     'version': version,
                     'region_alexa': region_alexa,
+                    'device_type': Type,
+                    'tb_country': country
                 }
                 UidSet = UidSetModel.objects.create(**uid_set_create_dict)
                 UidSet_id = UidSet.id
@@ -1048,7 +1056,7 @@ class EquipmentManagerV3(View):
             if uid:
                 uid_qs = UidSetModel.objects.filter(uid=uid)
                 if uid_qs.exists():
-                    uid_qs = uid_qs.values('is_alexa', 'is_human', 'is_custom_voice', 'double_wifi')
+                    uid_qs = uid_qs.values('is_alexa', 'is_human', 'is_custom_voice', 'double_wifi', 'mobile_4g')
                     return response.json(0, uid_qs[0])
                 else:
                     return response.json(173)

Controller/IotCoreController.py

@@ -40,7 +40,7 @@ class IotCoreView(View):
         lang = request_dict.get('lang', 'en')
         response.lang = lang
         if operation == 'createKeysAndCertificate':     # 设备注册到IoT core
-            return self.create_keys_and_certificate(request_dict, response, request)
+            return self.create_key_and_certificate(request_dict, response)
         elif operation == 'requestPublishMessage':
             return self.request_publish_message(request_dict, response)
         elif operation == 'getS3PullKey':
@@ -64,7 +64,7 @@ class IotCoreView(View):
 
     # 设备注册到aws iot core
     @staticmethod
-    def create_keys_and_certificate(request_dict, response, request):
+    def create_key_and_certificate(request_dict, response):
         logger = logging.getLogger('info')
         logger.info('设备注册到aws iot core请求参数:{}'.format(request_dict))
         token = request_dict.get('token', None)
@@ -130,8 +130,7 @@ class IotCoreView(View):
                 return response.json(0, {'res': res})
             else:
                 # 获取并判断region_id是否有效
-                region_id = request_dict.get('region_id', None)
-                region_id = int(region_id) if region_id else CommonService.confirm_region_id()
+                region_id = CommonService.confirm_region_id()
                 if region_id not in [1, 2, 3, 4]:
                     return response.json(444, {'invalid region_id': region_id})
 
@@ -198,8 +197,7 @@ class IotCoreView(View):
                 return response.json(13)
 
         # 获取并判断region_id是否有效
-        region_id = request_dict.get('region_id', None)
-        region_id = int(region_id) if region_id else CommonService.confirm_region_id()
+        region_id = CommonService.confirm_region_id()
         if region_id not in [1, 2, 3, 4]:
             return response.json(444, {'invalid region_id': region_id})
 

Controller/PaymentCycle.py

@@ -1,7 +1,7 @@
 import traceback
 
 from Ansjer.config import PAYPAL_CRD, SERVER_DOMAIN, SERVER_DOMAIN_SSL, PAYPAL_WEB_HOOK_ID, PAYPAL_WEB_HOOK_ID_TWO
-from Model.models import PayCycleConfigModel, Order_Model, Store_Meal, UID_Bucket, PromotionRuleModel, \
+from Model.models import PayCycleConfigModel, Store_Meal, UID_Bucket, PromotionRuleModel, \
     Unused_Uid_Meal, Device_Info, CouponModel, Order_Model, PaypalWebHookEvent
 from Service.CommonService import CommonService
 from django.http import JsonResponse, HttpResponseRedirect, HttpResponse
@@ -502,6 +502,12 @@ class PaypalCycleNotify(View):
                 #     }
                 #     UIDMainUser.objects.create(**uid_main_dict)
                 orderID = CommonService.createOrderID()
+                store_meal_qs = Store_Meal.objects.filter(id=rank, lang__lang='cn', is_show=0).values('lang__title',
+                                                                                                      'lang__content')
+                if store_meal_qs.exists():
+                    store_meal_name = store_meal_qs[0]['lang__title'] + '-' + store_meal_qs[0]['lang__content']
+                else:
+                    store_meal_name = '未知套餐'
                 Order_Model.objects.create(orderID=orderID, UID=UID, channel=channel, userID_id=userid,
                                            desc=order_list[0]['desc'], payType=order_list[0]['payType'],
                                            payTime=nowTime,
@@ -511,7 +517,7 @@ class PaypalCycleNotify(View):
                                            commodity_code=order_list[0]['commodity_code'],
                                            commodity_type=order_list[0]['commodity_type'], rank_id=rank, paymentID='',
                                            coupon_id='', uid_bucket_id=uid_bucket_id, status=1,
-                                           agreement_id=agreement_id,
+                                           agreement_id=agreement_id, store_meal_name=store_meal_name,
                                            plan_id=order_list[0]['plan_id'], ai_rank_id=1,
                                            trade_no=paypal_transaction_id)
                 # 如果存在序列号,消息提示用序列号

Controller/RegionController.py

@@ -3,9 +3,10 @@
 import json
 import time
 
+from django.db.models import F
 from django.views import View
 
-from Model.models import RegionModel, CountryModel, LanguageModel, CountryLanguageModel
+from Model.models import RegionModel, CountryModel, LanguageModel, CountryLanguageModel, App_Info
 from Object.uidManageResponseObject import uidManageResponseObject
 from Object.TokenObject import TokenObject
 from Service.CommonService import CommonService
@@ -27,13 +28,11 @@ class RegionView(View):
         return self.validate(request_dict, operation)
 
     def validate(self, request_dict, operation):
-        token = TokenObject(request_dict.get('token', None))
-
         response = uidManageResponseObject()
-
-        if operation == 'getCountry':
+        if operation == 'getCountryAndDomainName':
             return self.get_country(request_dict, response)
         else:
+            token = TokenObject(request_dict.get('token', None))
             if token.code != 0:
                 return response.json(token.code)
 
@@ -254,32 +253,49 @@ class RegionView(View):
         else:
             return response.json(444)
 
-    def get_country(self, request_dict, response):
-        type = request_dict.get('type', None)
-        token = request_dict.get('token', None)
+    @staticmethod
+    def get_country(request_dict, response):
+        lang = request_dict.get('lang', None)
+        app_bundle_id = request_dict.get('app_bundle_id', None)
         time_stamp = request_dict.get('time_stamp', None)
+        time_stamp_token = request_dict.get('time_stamp_token', None)
 
-        if token and time_stamp and type:
-            token = int(CommonService.decode_data(token))
-            time_stamp = int(time_stamp)
+        if not all([lang, app_bundle_id, time_stamp, time_stamp_token]):
+            return response.json(444)
 
+        try:
+            # 校验时间戳token
+            time_stamp_token = int(CommonService.decode_data(time_stamp_token))
+            time_stamp = int(time_stamp)
             now_time = int(time.time())
             distance = now_time - time_stamp
-
-            if token != time_stamp or distance > 60000 or distance < -60000:  # 为了全球化时间控制在一天内
+            if time_stamp_token != time_stamp or distance > 60000 or distance < -60000:  # 为了全球化时间控制在一天内
                 return response.json(404)
 
-            lang_qs = LanguageModel.objects.filter(lang=type)
+            # 查询app名
+            app_inf_qs = App_Info.objects.filter(appBundleId=app_bundle_id).values('appName')
+            if not app_inf_qs.exists():
+                return response.json(173)
 
+            lang_qs = LanguageModel.objects.filter(lang=lang)
             if not lang_qs.exists():
                 lang_qs = LanguageModel.objects.filter(lang='en')
-
             lang = lang_qs[0]
-            country_qs = CountryLanguageModel.objects.filter(language_id=lang.id).values('country_name', 'country__number')
 
+            # 根据app名返回相应域名
+            app_name = app_inf_qs[0]['appName']
+            country_qs = CountryLanguageModel.objects.filter(language_id=lang.id).annotate(
+                country_number=F('country__number'), push_api=F('country__region__push_api'))
+            if 'Zosi' in app_name:
+                country_qs = country_qs.annotate(api=F('country__region__zosi_api'))
+            elif 'Loocam' in app_name:
+                country_qs = country_qs.annotate(api=F('country__region__loocam_api'))
+            else:
+                country_qs = country_qs.annotate(api=F('country__region__api'))
+            country_qs = country_qs.values('country_name', 'country_number', 'api', 'push_api')
             return response.json(0, list(country_qs))
-        else:
-            return response.json(444)
+        except Exception as e:
+            return response.json(500, repr(e))
 
     def get_country_info(self, userID, request_dict, response):
         # perm = ModelService.check_perm_uid_manage(userID, 0)

Controller/SensorGateway/EquipmentFamilyController.py

@@ -19,7 +19,7 @@ from Ansjer.config import OSS_STS_ACCESS_SECRET, OSS_STS_ACCESS_KEY
 from Controller.DeviceConfirmRegion import Device_Region
 from Model.models import Device_Info, UID_Bucket, UID_Preview, UidSetModel, UidChannelSetModel, \
     iotdeviceInfoModel, UIDModel, Device_User, UserFamily, FamilyMember, FamilyMemberPermission, \
-    FamilyRoomDevice, FamilyRoom, FamilyMemberJoin, GatewaySubDevice
+    FamilyRoomDevice, FamilyRoom, FamilyMemberJoin, GatewaySubDevice, CountryModel
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
 from Service.CommonService import CommonService
@@ -197,6 +197,12 @@ class EquipmentFamilyView(View):
                 if not us_qs:
                     n_time = int(time.time())
                     ip = CommonService.get_ip_address(request)
+                    ipInfo = CommonService.getIpIpInfo(ip, 'CN')
+                    country_qs = CountryModel.objects.filter(country_code=ipInfo['country_code']).values('id')
+                    if country_qs.exists():
+                        country = country_qs[0]['id']
+                    else:
+                        country = '0'
                     region_id = Device_Region().get_device_region(ip)
                     region_alexa = 'CN' if region_id == 1 else 'ALL'
                     uid_set_create_dict = {
@@ -206,6 +212,8 @@ class EquipmentFamilyView(View):
                         'ip': CommonService.get_ip_address(request_dict),
                         'nickname': nick_name,
                         'region_alexa': region_alexa,
+                        'device_type': device_type,
+                        'td_country': country
                     }
                     UidSetModel.objects.create(**uid_set_create_dict)
                 return response.json(0)
@@ -997,9 +1005,9 @@ class EquipmentFamilyView(View):
         permission = cls.get_member_permission_details(user_id, int(family_id))
         if not permission or permission == '003':
             return response.json(404)
-        family_room_device_qs = FamilyRoomDevice.objects.filter(Q(family_id=family_id), ~Q(device_id__isExist=2),
-                                                                Q(device__userID=user_id)).values().order_by('sort',
-                                                                                                             '-device__data_joined')
+        family_room_device_qs = FamilyRoomDevice.objects \
+            .filter(Q(family_id=family_id), ~Q(device_id__isExist=2), Q(device__userID=user_id)) \
+            .values().order_by('sort', '-device__data_joined')
         if not family_room_device_qs.exists():
             return response.json(0, device_dict)
         gateways = []

Controller/SerialNumberController.py

@@ -9,7 +9,7 @@ from django.db import transaction
 from django.views import View
 
 from Ansjer.config import CRCKey, SERVER_DOMAIN_US, SERVER_DOMAIN_CN, CONFIG_INFO, CONFIG_TEST, CONFIG_US, \
-    CONFIG_CN
+    CONFIG_CN, USED_SERIAL_REDIS_LIST, UNUSED_SERIAL_REDIS_LIST
 from Model.models import SerialNumberModel, CompanySerialModel, UIDCompanySerialModel, UIDModel, Device_Info, \
     iotdeviceInfoModel, LogModel, UidSetModel, UID_Bucket, \
     Unused_Uid_Meal, Order_Model, StsCrdModel, VodHlsModel, ExperienceContextModel, UidUserModel, ExperienceAiModel, \
@@ -166,8 +166,7 @@ class SerialNumberView(View):
                     return response.json(5)
 
                 # 获取并判断region_id
-                region_id = request_dict.get('region_id', None)
-                region_id = int(region_id) if region_id else CommonService.confirm_region_id(request)
+                region_id = CommonService.confirm_region_id()
                 if region_id not in [1, 2, 3, 4]:
                     return response.json(444, {'invalid region_id': region_id})
 
@@ -175,9 +174,6 @@ class SerialNumberView(View):
                 if serial_number[9:10]:
                     p2p_type = serial_number[9:10]
                 p2p_type = int(p2p_type)
-                # 尚云: 地区为亚洲分配美洲的uid
-                if p2p_type == 1 and region_id == 2:
-                    region_id = 3
 
                 with transaction.atomic():
                     count = 0
@@ -237,12 +233,8 @@ class SerialNumberView(View):
                             'operation': '序列号{}绑定uid: {}'.format(serial, uid.uid),
                         }
                         LogModel.objects.create(**log)
-                        # 修改其他数据库的序列号使用状态为已占用
-                        update_success = self.update_serial_status(serial=serial, status=3)
-                        try:
-                            assert update_success
-                        except AssertionError:
-                            return response.json(378)
+                        if CONFIG_INFO != CONFIG_TEST:  # 不为测试服,则序列号写入redis列表
+                            redisObj.rpush(USED_SERIAL_REDIS_LIST, serial)
                         redisObj.del_data(key=key)
                         return response.json(0, res)
                     return response.json(5)
@@ -326,7 +318,7 @@ class SerialNumberView(View):
         if not uid_serial_qs.exists():
             return response.json(173)
         uid_serial = uid_serial_qs[0]
-
+        redisObj = RedisObject()
         try:
             with transaction.atomic():
                 uid = uid_serial.uid.uid
@@ -352,12 +344,8 @@ class SerialNumberView(View):
                 ExperienceAiModel.objects.filter(uid=uid).delete()
                 AiService.objects.filter(uid=uid).delete()
 
-                # 修改其他数据库的序列号使用状态为已使用
-                update_success = self.update_serial_status(serial=serial, status=1)
-                try:
-                    assert update_success
-                except AssertionError:
-                    return response.json(378)
+                if CONFIG_INFO != CONFIG_TEST:  # 不为测试服,则序列号写入redis列表
+                    redisObj.rpush(UNUSED_SERIAL_REDIS_LIST, serial)
 
                 UIDModel.objects.filter(uid=uid).update(status=0, mac='')  # 重置uid的使用状态为未使用
                 uid_serial.delete()

Controller/TestApi.py

@@ -15,6 +15,7 @@ import botocore
 from botocore import client
 from Controller.DeviceConfirmRegion import Device_Region
 from Object.AWS.AmazonS3Util import AmazonS3Util
+from Object.RedisObject import RedisObject
 
 '''
 http://192.168.136.40:8077/Test
@@ -141,6 +142,10 @@ class testView(View):
             return self.object_delete(request_dict, response)
         elif operation == 'head-bucket':
             return self.head_bucket(request_dict, response)
+        elif operation == 'write_redis_list':
+            return self.write_redis_list(response)
+        elif operation == 'read_redis_list':
+            return self.read_redis_list(response)
         else:
             return 123
 
@@ -820,9 +825,16 @@ class testView(View):
             return response.json(10, repr(e))
         if order_string:
             redirectUrl = aliPayObj.alipay_prefix + order_string
+            store_meal_qs = Store_Meal.objects.filter(id=rank, lang__lang='cn', is_show=0).values('lang__title',
+                                                                                                  'lang__content')
+            if store_meal_qs.exists():
+                store_meal_name = store_meal_qs[0]['lang__title'] + '-' + store_meal_qs[0]['lang__content']
+            else:
+                store_meal_name = '未知套餐'
             Order_Model.objects.create(orderID=orderID, UID=uid, channel=channel, userID_id=userID, desc=content,
                                        price=price, currency=currency, addTime=nowTime, updTime=nowTime,
-                                       endTime=nowTime + int(day) * 3600 * 24, rank_id=rank, payType=1)
+                                       endTime=nowTime + int(day) * 3600 * 24, rank_id=rank, payType=1,
+                                       store_meal_name=store_meal_name)
             return JsonResponse(status=200,
                                 data={'result_code': 0, 'reason': 'success',
                                       'result': {"redirectUrl": redirectUrl, "orderID": orderID},
@@ -981,3 +993,20 @@ class testView(View):
                                                                                                               sumTs=sumTs,
                                                                                                               sumSec=sumSec,
                                                                                                               size=size))
+
+    @staticmethod
+    def write_redis_list(response):
+        redis_obj = RedisObject()
+        for i in range(10):
+            redis_obj.rpush('serial_redis_list', i)
+        return response.json(0)
+
+    @staticmethod
+    def read_redis_list(response):
+        redis_obj = RedisObject()
+        serial_redis_list_len = redis_obj.llen('serial_redis_list')
+        if serial_redis_list_len > 0:
+            for i in range(serial_redis_list_len):
+                serial = redis_obj.lpop('serial_redis_list')
+                print(serial)
+        return response.json(0)

Controller/UnicomCombo/UnicomComboController.py

@@ -503,6 +503,7 @@ class UnicomComboView(View):
                               'payTime': now_time, 'price': price, 'currency': 'CNY', 'addTime': now_time,
                               'updTime': now_time,
                               'unify_combo_id': str(unicom_combo_qs['id']), 'order_type': 2,
+                              'store_meal_name': unicom_combo_qs['combo_name']
                               }
 
                 params = 'lang=cn' + '&activateType=' + activate_type

Controller/UserController.py

@@ -41,7 +41,7 @@ from Ansjer.config import BASE_DIR, CONFIG_US, CONFIG_EUR, CONFIG_INFO, SERVER_D
 from Controller.CheckUserData import DataValid, date_handler, RandomStr
 from Model.models import Device_User, Role, UidPushModel, UserOauth2Model, UserExModel, Device_Info, UidSetModel, \
     UserAppFrequencyModel, CountryIPModel, CountryModel, UidChannelSetModel, Order_Model, UID_Bucket, Unused_Uid_Meal, \
-    GatewayPush
+    GatewayPush, CountryLanguageModel, LanguageModel
 from Object.AWS.SesClassObject import SesClassObject
 from Object.AliSmsObject import AliSmsObject
 from Object.RedisObject import RedisObject
@@ -1800,7 +1800,7 @@ class v2LoginView(TemplateView):
             data={'userID': userID, 'lang': response.lang, 'user': users['username'], 'm_code': '123413243214'})
         if tko.code == 0:
             now_time = datetime.datetime.utcnow().replace(tzinfo=utc).astimezone(utc)
-            if not number:
+            if not number or number == '0':
                 user_qs.update(last_login=now_time, language=response.lang)
             else:
                 user_qs.update(last_login=now_time, language=response.lang, region_country=number)
@@ -2012,7 +2012,7 @@ class v3LoginView(TemplateView):
 
         users = user_qs.values('role__rid', 'role__roleName', 'userID', 'NickName', 'username', 'userEmail',
                                'phone', 'password', 'userIconPath', 'fingerprint_enable', 'fingerprint_key',
-                               'subscribe_email')[0]
+                               'subscribe_email', 'region_country')[0]
         if not check_password(password, users['password']):
             return response.json(111)
 
@@ -2045,10 +2045,19 @@ class v3LoginView(TemplateView):
                                            push_type=push_type, token_val=token_val, m_code=m_code, lang=lang, tz=tz)
 
         now_time = datetime.datetime.utcnow().replace(tzinfo=utc).astimezone(utc)
-        if not number:
+        region_country = users['region_country']
+        lang_id = LanguageModel.objects.filter(lang=lang).values('id')
+        if not number or number == '0':
             user_qs.update(last_login=now_time, language=response.lang)
         else:
-            user_qs.update(last_login=now_time, language=response.lang, region_country=number)
+            number = int(number)
+            if number != region_country and region_country != 0:
+                res['status'] = 1
+                user_qs.update(last_login=now_time, language=response.lang)
+            else:
+                res['status'] = 0
+                user_qs.update(last_login=now_time, language=response.lang, region_country=number)
+        region_qs = CountryLanguageModel.objects.filter(country_id=region_country, language_id=lang_id[0]['id']).values('country_name')
 
         res['rid'] = users['role__rid']
         res['roleName'] = users['role__roleName']
@@ -2067,6 +2076,7 @@ class v3LoginView(TemplateView):
         res['phone'] = users['phone'] if users['phone'] is not None else ''
         res['authType'] = auth_type
         res['subscribe_email'] = users['subscribe_email'] if users['subscribe_email'] is not None else ''
+        res['region'] = region_qs[0]['country_name'] if region_qs.exists() else ''
         return response.json(0, res)
 
 

Controller/UserManger.py

@@ -16,7 +16,7 @@ from django.views.generic import TemplateView, View
 
 from Ansjer.config import BASE_DIR, SERVER_TYPE, ACCESS_KEY_ID, SECRET_ACCESS_KEY, REGION_NAME, AVATAR_BUCKET
 from Ansjer.config import SERVER_DOMAIN
-from Model.models import Role, Device_User, UserOauth2Model, UserExModel
+from Model.models import Role, Device_User, UserOauth2Model, UserExModel, CountryLanguageModel
 from Object.RedisObject import RedisObject
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
@@ -69,8 +69,16 @@ class showUserMoreView(TemplateView):
             if len(v['fields']['role']):
                 roleName = ModelService.getRole(rid=v['fields']['role'][0])
                 sqlDict["datas"][k]['fields']['rolename'] = roleName
+            region_country = sqlDict["datas"][k]['fields']['region_country']
+            if not region_country == 0:
+                country_qs = CountryLanguageModel.objects.filter(country_id=region_country).values(
+                    'country__region__api')
+                sqlDict["datas"][k]['fields']['api'] = country_qs[0]['country__region__api']
+            else:
+                sqlDict["datas"][k]['fields']['api'] = ''
+
         # 增加oauth2关联数据
-        ua_qs = UserOauth2Model.objects.filter(userID_id=userID).values_list('authType',flat=True)
+        ua_qs = UserOauth2Model.objects.filter(userID_id=userID).values_list('authType', flat=True)
         sqlDict["oauth2"] = list(ua_qs)
         return response.json(0, sqlDict)
 
@@ -207,7 +215,7 @@ class getAvatarView(TemplateView):
             except Exception as e:
                 print(e)
                 return response.json(500, repr(e))
-        
+
         fullPath = os.path.join(BASE_DIR, "static", filePath).replace('\\', '/')
         if os.path.isfile(fullPath):
             try:

Model/models.py

@@ -171,8 +171,8 @@ class Device_User(AbstractBaseUser):
     NickName = models.CharField(blank=True, max_length=64, default='', verbose_name=u'用户昵称')
     is_superuser = models.IntegerField(blank=True, default=0, verbose_name=u'用户类型')
     is_active = models.BooleanField(blank=True, default=False, verbose_name=u'用户活动状态')
-    data_joined = models.DateTimeField(blank=True, verbose_name=u'加入时间', auto_now_add=True)
-    last_login = models.DateTimeField(blank=True, verbose_name='u最后登录时间', auto_now=True)
+    data_joined = models.DateTimeField(blank=True, verbose_name=u'加入时间', auto_now_add=True, db_index=True)
+    last_login = models.DateTimeField(blank=True, verbose_name='u最后登录时间', auto_now=True, db_index=True)
     user_isValid = models.BooleanField(blank=True, default=False, verbose_name=u'用户有效性', help_text=u'是否是认证通过的用户')
     online = models.BooleanField(blank=True, default=False, verbose_name=u'用户登录状态')
     machine_code = models.CharField(blank=True, max_length=128, default='', verbose_name=u'机械码')
@@ -265,7 +265,7 @@ class Device_Info(models.Model):
     primaryMaster = models.CharField(max_length=64, verbose_name=u'主用户名', default='')
     vodPrimaryUserID = models.CharField(blank=True, verbose_name='云存主用户id', max_length=32, default='')
     vodPrimaryMaster = models.CharField(max_length=64, verbose_name=u'云存主用户名', default='')
-    data_joined = models.DateTimeField(blank=True, verbose_name=u'设备添加时间', auto_now_add=True)
+    data_joined = models.DateTimeField(blank=True, verbose_name=u'设备添加时间', auto_now_add=True, db_index=True)
     update_time = models.DateTimeField(blank=True, verbose_name=u'更新时间', auto_now=True, null=True)
 
     ip = models.CharField(blank=True, max_length=20, default='', verbose_name=u'设备区域ip')
@@ -671,7 +671,7 @@ class User_Brand(models.Model):
         ordering = ('id',)
 
 
-# 存储通表
+# 存储桶表
 class VodBucketModel(models.Model):
     id = models.AutoField(primary_key=True, verbose_name='主键')
     bucket = models.CharField(max_length=60, verbose_name='存储桶名称')
@@ -905,9 +905,7 @@ class Order_Model(models.Model):
     plan_id = models.CharField(default='', blank=True, max_length=64, verbose_name=u'paypal计划id')
     agreement_id = models.CharField(default='', blank=True, max_length=64, verbose_name=u'paypal协议id')
     coupon_id = models.CharField(default='', blank=True, max_length=10, verbose_name=u'优惠券id')
-
-    # 备用字段
-    spare_4 = models.CharField(default='', blank=True, max_length=64, db_index=True, verbose_name=u'备用字段4')
+    store_meal_name = models.CharField(default='', blank=True, max_length=64, verbose_name=u'关联套餐名')
 
     def __str__(self):
         return self.orderID
@@ -1155,8 +1153,8 @@ class UidSetModel(models.Model):
     channel = models.SmallIntegerField(default=0, verbose_name='通道数量')  #
     detect_status = models.SmallIntegerField(default=0, verbose_name='推送开关')  # 状态[0:关闭,1:开启,2:用户解绑]
     detect_interval = models.IntegerField(verbose_name='推送间隔', default=60)  # 秒
-    addTime = models.IntegerField(verbose_name='添加时间', default=0)
-    updTime = models.IntegerField(verbose_name='更新时间', default=0)
+    addTime = models.IntegerField(verbose_name='添加时间', default=0, db_index=True)
+    updTime = models.IntegerField(verbose_name='更新时间', default=0, db_index=True)
     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
@@ -1192,6 +1190,7 @@ class UidSetModel(models.Model):
     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='国家')
+    device_type = models.SmallIntegerField(default=0, verbose_name='设备类型')
 
     class Meta:
         db_table = 'uid_set'
@@ -1820,7 +1819,10 @@ class RegionModel(models.Model):
     id = models.AutoField(primary_key=True)
     name = models.CharField(max_length=32, default='', verbose_name='区域名称')
     continent_code = models.CharField(max_length=3, default='', verbose_name='洲代码')
-    api = models.CharField(max_length=50, default='', verbose_name='请求地址')
+    api = models.CharField(max_length=50, default='', verbose_name='域名')
+    zosi_api = models.CharField(max_length=50, default='', verbose_name='周视域名')
+    loocam_api = models.CharField(max_length=50, default='', verbose_name='录看域名')
+    push_api = models.CharField(max_length=50, default='', verbose_name='推送域名')
 
     class Meta:
         db_table = 'tb_region'
@@ -2888,3 +2890,79 @@ class DeviceUidAlgorithmType(models.Model):
         db_table = 'device_uid_algorithm_type'
         verbose_name = '设备uid关联算法类型'
         verbose_name_plural = verbose_name
+
+
+class VodHlsSummary(models.Model):
+    id = models.AutoField(primary_key=True, verbose_name='回放汇总列表主键')
+    uid = models.CharField(max_length=20, verbose_name='设备UID', db_index=True)
+    time = models.IntegerField(verbose_name='汇总年月时间戳', default=0, db_index=True)
+    upload_duration = models.IntegerField(verbose_name='上传秒数', default=0)
+    upload_frequency = models.SmallIntegerField(verbose_name='上传次数', default=0)
+    play_duration = models.IntegerField(verbose_name='播放秒数', default=0)
+    play_frequency = models.SmallIntegerField(verbose_name='播放次数', default=0)
+
+    def __str__(self):
+        return self.id
+
+    class Meta:
+        db_table = 'vod_hls_summary'
+        verbose_name = u'云存回放汇总信息表'
+        verbose_name_plural = verbose_name
+
+
+class DeviceUserSummary(models.Model):
+    id = models.AutoField(primary_key=True, verbose_name='用户汇总列表主键')
+    time = models.IntegerField(verbose_name='时间戳', default=0, db_index=True)
+    query_type = models.SmallIntegerField(verbose_name='查询类型{0：新增用户，1：活跃用户}', default=0)
+    count = models.IntegerField(verbose_name='总人数', default=0)
+    country = models.TextField(verbose_name='所属国家', default='')
+    continent = models.TextField(verbose_name='四大洲信息', default='')
+
+    def __str__(self):
+        return self.id
+
+    class Meta:
+        db_table = 'device_user_summary'
+        verbose_name = u'用户汇总信息表'
+        verbose_name_plural = verbose_name
+
+
+class OrdersSummary(models.Model):
+    id = models.AutoField(primary_key=True, verbose_name='订单汇总列表主键')
+    time = models.IntegerField(verbose_name='时间戳', default=0, db_index=True)
+    query_type = models.SmallIntegerField(verbose_name='查询类型{0：付费订单，1：免费订单，2：首次付费订单，3：复购订单}', default=0)
+    service_type = models.SmallIntegerField(verbose_name='增值服务类型{0：云存，1：AI，2：4G}', default=0)
+    count = models.IntegerField(verbose_name='订单数量', default=0)
+    total = models.CharField(verbose_name='销售额', default='', max_length=16)
+    country = models.TextField(verbose_name='所属国家', default='')
+    device_type = models.TextField(verbose_name='设备类型信息', default='')
+    store_meal = models.TextField(verbose_name='套餐信息', default='')
+
+    def __str__(self):
+        return self.id
+
+    class Meta:
+        db_table = 'orders_summary'
+        verbose_name = u'订单汇总信息表'
+        verbose_name_plural = verbose_name
+
+
+class DeviceInfoSummary(models.Model):
+    id = models.AutoField(primary_key=True, verbose_name='设备汇总列表主键')
+    time = models.IntegerField(verbose_name='时间戳', default=0, db_index=True)
+    query_type = models.SmallIntegerField(verbose_name='查询类型{0：新增设备，1：活跃设备}', default=0)
+    count = models.IntegerField(verbose_name='设备数量', default=0)
+    country = models.TextField(verbose_name='所属国家', default='')
+    continent = models.TextField(verbose_name='四大洲信息', default='')
+    device_type = models.TextField(verbose_name='设备类型信息', default='')
+    vod_service = models.TextField(verbose_name='云存服务信息', default='')
+    ai_service = models.TextField(verbose_name='ai服务信息', default='')
+    unicom_service = models.TextField(verbose_name='联通服务信息', default='')
+
+    def __str__(self):
+        return self.id
+
+    class Meta:
+        db_table = 'device_info_summary'
+        verbose_name = u'设备汇总信息表'
+        verbose_name_plural = verbose_name

Object/RedisObject.py

@@ -70,8 +70,8 @@ class RedisObject:
     def rpush(self, name, val):
         self.CONN.rpush(name, val)
 
-    def lpop(self, key):
-        val = self.CONN.lpop(key)
+    def lpop(self, name):
+        val = self.CONN.lpop(name)
         if val:
             return val.decode('utf-8')
         else:

Service/CommonService.py

@@ -17,7 +17,7 @@ from django.utils import timezone
 from pyipip import IPIPDatabase
 
 from Ansjer.config import BASE_DIR, SERVER_DOMAIN_SSL, CONFIG_INFO, CONFIG_TEST, CONFIG_CN, SERVER_DOMAIN_TEST, \
-    SERVER_DOMAIN_CN, SERVER_DOMAIN_US, CONFIG_US, CONFIG_EUR
+    SERVER_DOMAIN_CN, SERVER_DOMAIN_US, CONFIG_US, CONFIG_EUR, SERVER_DOMAIN_LIST, SERVER_DOMAIN_EUR
 from Controller.CheckUserData import RandomStr
 from Model.models import iotdeviceInfoModel, Device_Info, CountryModel, RegionModel, UIDModel
 from Object.ResponseObject import ResponseObject
@@ -625,33 +625,18 @@ GCqvlyw5dfxNA+EtxNE2wCW/LW7ENJlACgcfgPlBZtpLheWoZB/maw4=
             return thing_name_suffix
 
     @staticmethod
-    def confirm_region_id(request=None):
+    def confirm_region_id():
         """
         根据配置信息确定region_id
-        @param request: 请求体
         @return: region_id
         """
         region_id = 3
-        if request is None:
-            if CONFIG_INFO == CONFIG_TEST or CONFIG_INFO == CONFIG_CN:
-                region_id = 1
-            elif CONFIG_INFO == CONFIG_US:
-                region_id = 3
-            elif CONFIG_INFO == CONFIG_EUR:
-                region_id = 4
-        else:
-            if CONFIG_INFO == CONFIG_TEST or CONFIG_INFO == CONFIG_CN:
-                region_id = 1
-            else:  # 国外配置暂时通过ip确认
-                ip = CommonService.get_ip_address(request)
-                ipInfo = CommonService.getIpIpInfo(ip, 'CN')
-                if ipInfo['country_code']:
-                    country_qs = CountryModel.objects.filter(country_code=ipInfo['country_code']).values('region__id')
-                    if country_qs.exists():
-                        region_id = country_qs[0]['region__id']
-                else:  # 不存在默认返回美洲地区api
-                    region_qs = RegionModel.objects.filter(continent_code='NA').values("id")
-                    region_id = region_qs[0]['id']
+        if CONFIG_INFO == CONFIG_TEST or CONFIG_INFO == CONFIG_CN:  # 测试&中国
+            region_id = 1
+        elif CONFIG_INFO == CONFIG_US:      # 美洲
+            region_id = 3
+        elif CONFIG_INFO == CONFIG_EUR:     # 欧洲
+            region_id = 4
         return region_id
 
     @staticmethod
@@ -726,6 +711,23 @@ GCqvlyw5dfxNA+EtxNE2wCW/LW7ENJlACgcfgPlBZtpLheWoZB/maw4=
             domain_name_list = []
         return domain_name_list
 
+    @staticmethod
+    def get_orders_domain_name_list():
+        """
+        获取其他服务器域名列表
+        @return: orders_domain_name_list 其他服务器域名列表
+        """
+        orders_domain_name_list = SERVER_DOMAIN_LIST
+        if CONFIG_INFO == CONFIG_TEST:
+            orders_domain_name_list.remove(SERVER_DOMAIN_TEST)
+        elif CONFIG_INFO == CONFIG_CN:
+            orders_domain_name_list.remove(SERVER_DOMAIN_CN)
+        elif CONFIG_INFO == CONFIG_US:
+            orders_domain_name_list.remove(SERVER_DOMAIN_US)
+        elif CONFIG_INFO == CONFIG_EUR:
+            orders_domain_name_list.remove(SERVER_DOMAIN_EUR)
+        return orders_domain_name_list
+
     @staticmethod
     def list_sort(e):
         """