数据系统全球统计接口

AdminController/dataSystemManagement/BusinessDataController.py

@@ -7,22 +7,11 @@
 @Software: PyCharm
 """
 
-import time
-
-import oss2
-from django.db import connection
-from django.db import transaction
-from django.db.models import Q, Count
+import requests
+from django.db.models import Q, Count, Sum
 from django.views.generic.base import View
-import datetime
 
-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, CountryModel
-from Object.ResponseObject import ResponseObject
-from Object.TokenObject import TokenObject
+from Model.models import VodHlsModel, VideoPlaybackTimeModel
 from Service.CommonService import CommonService
 
 
@@ -40,27 +29,20 @@ class BusinessDataView(View):
         return self.validation(request.POST, request, operation)
 
     def validation(self, request_dict, request, operation):
-
-        token = TokenObject(request.META.get('HTTP_AUTHORIZATION'))
-        lang = request_dict.get('lang', None)
-        if lang:
-            response = ResponseObject(lang)
-        else:
-            response = ResponseObject(token.lang) if token.lang else ResponseObject()
-
-        if token.code != 0:
-            return response.json(token.code)
-        user_id = token.userID
-
-        if operation == 'increase':  # 查询新增用户数据
-            return self.user_increase(request_dict, response)
+        token_code, user_id, response = CommonService.verify_token_get_user_id(request_dict, request)
+        if token_code != 0:
+            return response.json(token_code)
+        if operation == 'vodData':  # 查询设备云存储数据
+            return self.query_device_vod_business(request_dict, response)
+        elif operation == 'global/vodData':  # 查询全球设备云存储数据
+            return self.query_global_device_vod_business(request, request_dict, response)
         else:
             return response.json(414)
 
     @classmethod
-    def user_increase(cls, request_dict, response):
+    def query_device_vod_business(cls, request_dict, response):
         """
-        查询用户增长数据
+        查询设备云存储数据
         @param request_dict:请求参数
         @request_dict startTime:开始时间
         @request_dict endTime:结束时间
@@ -71,27 +53,63 @@ class BusinessDataView(View):
         end_time = request_dict.get('endTime', None)
         if not all([start_time, end_time]):
             return response.json(444, {'error param': 'startTime or endTime'})
-        start_time = datetime.datetime.fromtimestamp(int(start_time))
-        end_time = datetime.datetime.fromtimestamp(int(end_time))
         try:
-            user_qs = Device_User.objects.filter(data_joined__range=(start_time, end_time))
+            vod_hls_qs = VodHlsModel.objects.filter(time__range=(start_time, end_time))
+            video_play_qs = VideoPlaybackTimeModel.objects.filter(startTime__range=(start_time, end_time))
+            upload_duration_qs = vod_hls_qs.values('uid').annotate(uploadFrequency=Count('uid')).order_by(
+                'uploadFrequency')
+            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['playFrequency'] = video_play_qs.filter(uid=item['uid'], playMode='cloud').count()
+                uid_list.append(item['uid'])
+
+            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')
+
+            for item in play_duration_qs:
+                item['uploadFrequency'] = 0
+                item['uploadDuration'] = 0
+            res = {
+                'deviceCount': device_count,
+                'vodData': list(upload_duration_qs) + list(play_duration_qs)
+            }
+            return response.json(0, res)
+        except Exception as e:
+            return response.json(500, repr(e))
+
+    @classmethod
+    def query_global_device_vod_business(cls, request, request_dict, response):
+        """
+        查询全球设备云存储数据
+        @param request:请求
+        @param request_dict:请求参数
+        @param response:响应对象
+        @return:
+        """
+        ap_url = 'https://www.zositechc.cn/dataManagement/businessData/vodData'
+        as_url = 'https://www.zositecha.com/dataManagement/businessData/vodData'
+        na_url = 'https://www.dvema.com/dataManagement/businessData/vodData'
+        eu_url = 'https://www.zositeche.com/dataManagement/businessData/vodData'
+        local_url = 'http://127.0.0.1:8000/dataManagement/businessData/vodData'
+        url_list = [local_url]
+        try:
+            headers = {
+                'Authorization': request.META.get('HTTP_AUTHORIZATION')
+            }
+            device_count = 0
+            vod_list = []
+            for url in url_list:
+                res = requests.get(url=url, params=request_dict, headers=headers)
+                result = res.json()
+                device_count += int(result['result']['deviceCount'])
+                vod_list += result['result']['vodData']
             res = {
-                'total': user_qs.count(),
-                'region': []
+                'deviceCount': device_count,
+                'vodData': vod_list
             }
-            if user_qs.exists():
-                user_country_qs = user_qs.values('region_country').annotate(count=Count('region_country')).order_by('-count')
-                region = []
-                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 '未知区域'
-                    country_dict = {
-                        'countryName': country_name,
-                        'count': item['count']
-                    }
-                    region.append(country_dict)
-                res['region'] = region
             return response.json(0, res)
         except Exception as e:
             return response.json(500, repr(e))

AdminController/dataSystemManagement/DeviceDataController.py

@@ -40,18 +40,9 @@ class DeviceDataView(View):
         return self.validation(request.POST, request, operation)
 
     def validation(self, request_dict, request, operation):
-
-        token = TokenObject(request.META.get('HTTP_AUTHORIZATION'))
-        lang = request_dict.get('lang', None)
-        if lang:
-            response = ResponseObject(lang)
-        else:
-            response = ResponseObject(token.lang) if token.lang else ResponseObject()
-
-        if token.code != 0:
-            return response.json(token.code)
-        user_id = token.userID
-
+        token_code, user_id, response = CommonService.verify_token_get_user_id(request_dict, request)
+        if token_code != 0:
+            return response.json(token_code)
         if operation == 'increase':  # 查询新增用户数据
             return self.device_increase(request_dict, response)
         if operation == 'type':  # 统计设备类型
@@ -174,8 +165,8 @@ class DeviceDataView(View):
         @param response:响应对象
         """
         device_info_qs = Device_Info.objects.all()
-        count = device_info_qs.count()
         device_info_qs = device_info_qs.values('UID').order_by('UID').distinct()
+        count = device_info_qs.count()
         if not device_info_qs.exists():
             return response.json(444)
         try:
@@ -201,10 +192,10 @@ class DeviceDataView(View):
                 device_info = region_list.count(country_id)
                 rate = round(device_info / count * 100, 2)
                 res = {
-                'id': country_id,
-                'name': countryName,
-                'total': device_info,
-                'rate': rate
+                    'id': country_id,
+                    'name': countryName,
+                    'total': device_info,
+                    'rate': rate
                 }
                 device_region_list.append(res)
             return response.json(0, device_region_list)
@@ -212,7 +203,6 @@ class DeviceDataView(View):
             print(e)
             return response.json(500)
 
-
     @classmethod
     def type_statistics(cls, response):
         """
@@ -220,36 +210,31 @@ class DeviceDataView(View):
         @param response:响应对象
         @return:
         """
-        device_info_qs = Device_Info.objects.values('UID').order_by('UID').distinct()
+        device_info_qs = Device_Info.objects.values('UID').order_by('UID').distinct().values('UID', 'Type')
         if not device_info_qs.exists():
             return response.json(444)
-        device_type_list = []
         try:
-            for device_info in device_info_qs:
-                UID = device_info['UID']
-                device_type_list.append(UID)
-            device_info_type_qs = device_info_qs.filter(UID__in=device_type_list).values('Type')
-            device_type_qs = device_info_type_qs.values('Type').order_by('Type').distinct()
             device_info_list = []
-            for device_info in device_type_qs:
-                Type = device_info['Type']
-                device_type_qs = DEVICE_TYPE.get(Type)
-                name = device_type_qs
-                type_qs = device_info_type_qs.filter(Type=Type)
-                total = type_qs.count()
-                if name is None:
-                    continue
-                res = {
-                    'type': name,
-                    'total': total
-                }
-                device_info_list.append(res)
+            for device_info in device_info_qs:
+                type = device_info['Type']
+                name = DEVICE_TYPE.get(type, '未知类型')
+                name = name if name != 'UNKOWN' else '未知类型'
+                flag = 0
+                for item in device_info_list:
+                    if item['type'] == name:
+                        item['total'] += 1
+                        flag = 1
+                        break
+                if flag == 0:
+                    device_info_list.append({
+                        'type': name,
+                        'total': 1
+                    })
             return response.json(0, device_info_list)
         except Exception as e:
             print(e)
             return response.json(500)
 
-
     @classmethod
     def device_increase(cls, request_dict, response):
         """

AdminController/dataSystemManagement/ServiceDataController.py

@@ -7,20 +7,13 @@
 @Software: PyCharm
 """
 
-import time
-
-import oss2
-from django.db import connection
-from django.db import transaction
 from django.db.models import Q, Count, Sum
 from django.views.generic.base import View
+from Ansjer.config import DEVICE_TYPE
 import datetime
+import requests
 
-from Ansjer.config import OSS_STS_ACCESS_SECRET, OSS_STS_ACCESS_KEY
-from Controller.DeviceConfirmRegion import Device_Region
 from Model.models import Order_Model, CountryModel, Device_Info, DeviceTypeModel
-from Object.ResponseObject import ResponseObject
-from Object.TokenObject import TokenObject
 from Service.CommonService import CommonService
 
 
@@ -43,6 +36,20 @@ class ServiceDataView(View):
             return response.json(token_code)
         if operation == 'payOrder':  # 查询付费订单数据
             return self.query_pay_order(request_dict, response)
+        elif operation == 'freeOrder':  # 查询免费订单数据
+            return self.query_free_order(request_dict, response)
+        elif operation == 'firstPayOrder':  # 查询首次付费订单数据
+            return self.query_first_pay_order(request_dict, response)
+        elif operation == 'repeatPayOrder':  # 查询复购订单数据
+            return self.query_repeat_pay_order(request_dict, response)
+        elif operation == 'global/payOrder':  # 查询付费订单数据
+            return self.query_global_pay_order(request, request_dict, response)
+        elif operation == 'global/freeOrder':  # 查询免费订单数据
+            return self.query_global_free_order(request, request_dict, response)
+        elif operation == 'global/firstPayOrder':  # 查询首次付费订单数据
+            return self.query_global_first_pay_order(request, request_dict, response)
+        elif operation == 'global/repeatPayOrder':  # 查询复购订单数据
+            return self.query_global_repeat_pay_order(request, request_dict, response)
         else:
             return response.json(414)
 
@@ -79,13 +86,13 @@ class ServiceDataView(View):
             order_list = []
             for item in time_list:
                 order_temp_qs = order_qs.filter(addTime__range=item)
-                order_dict = {
-                    'orderId': order_temp_qs[0].orderID,
-                    'count': order_temp_qs.count(),
-                    'startTime': item[0],
-                    'endTime': item[1]
-                }
-                order_list.append(order_dict)
+                if order_temp_qs.exists():
+                    order_dict = {
+                        'count': order_temp_qs.count(),
+                        'startTime': item[0],
+                        'endTime': item[1]
+                    }
+                    order_list.append(order_dict)
 
             # 区域订单统计
             region_list = []
@@ -104,7 +111,7 @@ class ServiceDataView(View):
 
             # 设备类型订单统计
             device_type_list = []
-            device_type_qs = order_qs.values('UID').annotate()
+            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:
@@ -118,8 +125,8 @@ class ServiceDataView(View):
             device_qs = Device_Info.objects.filter(UID__in=uid_list).values('Type').annotate(
                 count=Count('Type', distinct=True)).order_by('-count')
             for item in device_qs:
-                type_qs = DeviceTypeModel.objects.filter(id=item['Type'])
-                type_name = type_qs[0]['name'] if type_qs.exists() else '未知类型'
+                type_name = DEVICE_TYPE.get(item['Type'], '未知类型')
+                type_name = type_name if type_name != 'UNKOWN' else '未知类型'
                 type_rate = round(item['count'] / device_count * 100, 2)
                 temp_total = order_qs.filter(UID__in=uid_type_dict[item['Type']]).aggregate(total=Sum('price'))['total']
                 total_rate = round(temp_total / total * 100, 2)
@@ -127,6 +134,7 @@ class ServiceDataView(View):
                     'typeName': type_name,
                     'count': item['count'],
                     'typeRate': type_rate,
+                    'totalMoney': temp_total,
                     'totalRate': total_rate
                 }
                 device_type_list.append(device_temp_qs)
@@ -153,3 +161,618 @@ class ServiceDataView(View):
             return response.json(0, res)
         except Exception as e:
             return response.json(500, repr(e))
+
+    @classmethod
+    def query_free_order(cls, request_dict, response):
+        """
+        查询免费订单数据
+        @param request_dict:请求参数
+        @request_dict startTime:开始时间
+        @request_dict endTime:结束时间
+        @request_dict timeUnit:时间单位
+        @request_dict storeMealType:套餐类型
+        @param response:响应对象
+        @return:
+        """
+        start_time = request_dict.get('startTime', None)
+        end_time = request_dict.get('endTime', None)
+        time_unit = request_dict.get('timeUnit', None)
+        store_meal_type = request_dict.get('storeMealType', None)
+        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_qs = Order_Model.objects.filter(order_type=store_meal_type, status=1,
+                                                  addTime__range=(start_time, end_time)).filter(Q(price='0.00'))
+            count = 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)
+
+            # 订单数量统计
+            order_list = []
+            for item in time_list:
+                order_temp_qs = order_qs.filter(addTime__range=item)
+                if order_temp_qs.exists():
+                    order_dict = {
+                        'count': order_temp_qs.count(),
+                        'startTime': item[0],
+                        'endTime': item[1]
+                    }
+                    order_list.append(order_dict)
+
+            # 区域订单统计
+            region_list = []
+            region_qs = order_qs.values('userID__region_country').annotate(count=Count('UID')).order_by('-count')
+            for item in region_qs:
+                country_id = item['userID__region_country']
+                country_qs = CountryModel.objects.filter(id=country_id).values('country_name')
+                country_name = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
+                rate = round(item['count'] / count * 100, 2)
+                region_dict = {
+                    'countryName': country_name,
+                    'count': item['count'],
+                    'rate': rate
+                }
+                region_list.append(region_dict)
+
+            # 设备类型订单统计
+            device_type_list = []
+            device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
+            uid_list = []
+            for item in device_type_qs:
+                uid_list.append(item['UID'])
+            device_count = len(set(uid_list))
+            device_qs = Device_Info.objects.filter(UID__in=uid_list).values('Type').annotate(
+                count=Count('Type', distinct=True)).order_by('-count')
+            for item in device_qs:
+                type_name = DEVICE_TYPE.get(item['Type'], '未知类型')
+                type_name = type_name if type_name != 'UNKOWN' else '未知类型'
+                type_rate = round(item['count'] / device_count * 100, 2)
+                device_temp_qs = {
+                    'typeName': type_name,
+                    'count': item['count'],
+                    'typeRate': type_rate,
+                }
+                device_type_list.append(device_temp_qs)
+
+            res = {
+                'orders': order_list,
+                'regions': region_list,
+                'deviceType': device_type_list,
+            }
+            return response.json(0, res)
+        except Exception as e:
+            return response.json(500, repr(e))
+
+    @classmethod
+    def query_first_pay_order(cls, request_dict, response):
+        """
+        查询首次付费订单数据
+        @param request_dict:请求参数
+        @request_dict startTime:开始时间
+        @request_dict endTime:结束时间
+        @request_dict timeUnit:时间单位
+        @request_dict storeMealType:套餐类型
+        @param response:响应对象
+        @return:
+        """
+        start_time = request_dict.get('startTime', None)
+        end_time = request_dict.get('endTime', None)
+        time_unit = request_dict.get('timeUnit', None)
+        store_meal_type = request_dict.get('storeMealType', None)
+        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'))
+            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))
+            count = 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)
+
+            # 订单数量统计
+            order_list = []
+            for item in time_list:
+                order_temp_qs = order_qs.filter(addTime__range=item)
+                if order_temp_qs.exists():
+                    order_dict = {
+                        'count': order_temp_qs.count(),
+                        'startTime': item[0],
+                        'endTime': item[1]
+                    }
+                    order_list.append(order_dict)
+
+            # 区域订单统计
+            region_list = []
+            region_qs = order_qs.values('userID__region_country').annotate(count=Count('UID')).order_by('-count')
+            for item in region_qs:
+                country_id = item['userID__region_country']
+                country_qs = CountryModel.objects.filter(id=country_id).values('country_name')
+                country_name = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
+                rate = round(item['count'] / count * 100, 2)
+                region_dict = {
+                    'countryName': country_name,
+                    'count': item['count'],
+                    'rate': rate
+                }
+                region_list.append(region_dict)
+
+            # 设备类型订单统计
+            device_type_list = []
+            device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
+            uid_list = []
+            for item in device_type_qs:
+                uid_list.append(item['UID'])
+            device_count = len(set(uid_list))
+            device_qs = Device_Info.objects.filter(UID__in=uid_list).values('Type').annotate(
+                count=Count('Type', distinct=True)).order_by('-count')
+            for item in device_qs:
+                type_name = DEVICE_TYPE.get(item['Type'], '未知类型')
+                type_name = type_name if type_name != 'UNKOWN' else '未知类型'
+                type_rate = round(item['count'] / device_count * 100, 2)
+                device_temp_qs = {
+                    'typeName': type_name,
+                    'count': item['count'],
+                    'typeRate': type_rate,
+                }
+                device_type_list.append(device_temp_qs)
+
+            res = {
+                'orders': order_list,
+                'regions': region_list,
+                'deviceType': device_type_list,
+            }
+            return response.json(0, res)
+        except Exception as e:
+            return response.json(500, repr(e))
+
+    @classmethod
+    def query_repeat_pay_order(cls, request_dict, response):
+        """
+        查询复购订单数据
+        @param request_dict:请求参数
+        @request_dict startTime:开始时间
+        @request_dict endTime:结束时间
+        @request_dict timeUnit:时间单位
+        @request_dict storeMealType:套餐类型
+        @param response:响应对象
+        @return:
+        """
+        start_time = request_dict.get('startTime', None)
+        end_time = request_dict.get('endTime', None)
+        time_unit = request_dict.get('timeUnit', None)
+        store_meal_type = request_dict.get('storeMealType', None)
+        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'))
+            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'))
+            total = order_qs.count()
+
+            # 订单复购率
+            order_qs = order_qs.filter(Q(UID__in=uid_list))
+            count = order_qs.count()
+            repeat_rate = round(count / total * 100, 2)
+
+            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)
+                if order_temp_qs.exists():
+                    order_dict = {
+                        'count': order_temp_qs.count(),
+                        'startTime': item[0],
+                        'endTime': item[1]
+                    }
+                    order_list.append(order_dict)
+
+            # 区域订单统计
+            region_list = []
+            region_qs = order_qs.values('userID__region_country').annotate(count=Count('UID')).order_by('-count')
+            for item in region_qs:
+                country_id = item['userID__region_country']
+                country_qs = CountryModel.objects.filter(id=country_id).values('country_name')
+                country_name = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
+                rate = round(item['count'] / count * 100, 2)
+                region_dict = {
+                    'countryName': country_name,
+                    'count': item['count'],
+                    'rate': rate
+                }
+                region_list.append(region_dict)
+
+            # 设备类型订单统计
+            device_type_list = []
+            device_type_qs = order_qs.values('UID').annotate(count=Count('UID')).order_by('count')
+            uid_list = []
+            for item in device_type_qs:
+                uid_list.append(item['UID'])
+            device_count = len(set(uid_list))
+            device_qs = Device_Info.objects.filter(UID__in=uid_list).values('Type').annotate(
+                count=Count('Type', distinct=True)).order_by('-count')
+            for item in device_qs:
+                type_name = DEVICE_TYPE.get(item['Type'], '未知类型')
+                type_name = type_name if type_name != 'UNKOWN' else '未知类型'
+                type_rate = round(item['count'] / device_count * 100, 2)
+                device_temp_qs = {
+                    'typeName': type_name,
+                    'count': item['count'],
+                    'typeRate': type_rate,
+                }
+                device_type_list.append(device_temp_qs)
+
+            res = {
+                'orders': order_list,
+                'regions': region_list,
+                'deviceType': device_type_list,
+                'repeatRate': repeat_rate,
+                'repeatCount': count,
+                'orderCount': total
+            }
+            return response.json(0, res)
+        except Exception as e:
+            return response.json(500, repr(e))
+
+    @classmethod
+    def query_global_pay_order(cls, request, request_dict, response):
+        """
+        查询全球付费订单数据
+        @param request:请求
+        @param request_dict:请求参数
+        @param response:响应对象
+        @return:
+        """
+        ap_url = 'https://www.zositechc.cn/dataManagement/serviceData/payOrder'
+        as_url = 'https://www.zositecha.com/dataManagement/serviceData/payOrder'
+        na_url = 'https://www.dvema.com/dataManagement/serviceData/payOrder'
+        eu_url = 'https://www.zositeche.com/dataManagement/serviceData/payOrder'
+        local_url = 'http://127.0.0.1:8000/dataManagement/serviceData/payOrder'
+        url_list = [local_url]
+
+        try:
+            headers = {
+                'Authorization': request.META.get('HTTP_AUTHORIZATION')
+            }
+            order_list = []
+            region_list = []
+            region_count = 0
+            device_type_list = []
+            device_type_count = 0
+            device_type_total = 0
+            store_meal_list = []
+            store_meal_count = 0
+            for url in url_list:
+                res = requests.get(url=url, params=request_dict, headers=headers)
+                result = res.json()
+                if result['result_code'] == 0:
+                    # 处理订单
+                    for item in result['result']['orders']:
+                        flag = 0
+                        for each in order_list:
+                            if each['startTime'] == item['startTime'] and each['endTime'] == item['endTime']:
+                                each['count'] += int(item['count'])
+                                flag = 1
+                                break
+                        if flag == 0:
+                            order_list.append(item)
+                    # 处理地区
+                    for item in result['result']['regions']:
+                        flag = 0
+                        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:
+                        rate = round(item['count'] / region_count * 100, 2)
+                        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'])
+                                item['totalMoney'] += item['totalMoney']
+                                device_type_count += int(item['count'])
+                                device_type_total += item['totalMoney']
+                                flag = 1
+                                break
+                        if flag == 0:
+                            device_type_list.append(item)
+                            device_type_count += int(item['count'])
+                            device_type_total += item['totalMoney']
+                    for item in device_type_list:
+                        type_rate = round(item['count'] / device_type_count * 100, 2)
+                        total_rate = round(item['totalMoney'] / device_type_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']:
+                                each['count'] += int(item['count'])
+                                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:
+                        rate = round(item['count'] / store_meal_count * 100, 2)
+                        item['rate'] = rate
+                else:
+                    return response.json(result['result_code'])
+            res = {
+                'orders': order_list,
+                'regions': region_list,
+                'deviceType': device_type_list,
+                'storeMeal': store_meal_list,
+            }
+            return response.json(0, res)
+        except Exception as e:
+            return response.json(500, repr(e))
+
+    @classmethod
+    def query_global_free_order(cls, request, request_dict, response):
+        """
+        查询全球免费订单数据
+        @param request:请求
+        @param request_dict:请求参数
+        @param response:响应对象
+        @return:
+        """
+        ap_url = 'https://www.zositechc.cn/dataManagement/serviceData/freeOrder'
+        as_url = 'https://www.zositecha.com/dataManagement/serviceData/freeOrder'
+        na_url = 'https://www.dvema.com/dataManagement/serviceData/freeOrder'
+        eu_url = 'https://www.zositeche.com/dataManagement/serviceData/freeOrder'
+        local_url = 'http://127.0.0.1:8000/dataManagement/serviceData/freeOrder'
+        url_list = [local_url]
+        try:
+            headers = {
+                'Authorization': request.META.get('HTTP_AUTHORIZATION')
+            }
+            order_list = []
+            region_list = []
+            region_count = 0
+            device_type_list = []
+            device_type_count = 0
+            for url in url_list:
+                res = requests.get(url=url, params=request_dict, headers=headers)
+                result = res.json()
+                if result['result_code'] == 0:
+                    # 处理订单
+                    for item in result['result']['orders']:
+                        flag = 0
+                        for each in order_list:
+                            if each['startTime'] == item['startTime'] and each['endTime'] == item['endTime']:
+                                each['count'] += int(item['count'])
+                                flag = 1
+                                break
+                        if flag == 0:
+                            order_list.append(item)
+                    # 处理地区
+                    for item in result['result']['regions']:
+                        flag = 0
+                        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:
+                        rate = round(item['count'] / region_count * 100, 2)
+                        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:
+                        type_rate = round(item['count'] / device_type_count * 100, 2)
+                        item['typeRate'] = type_rate
+                else:
+                    return response.json(result['result_code'])
+            res = {
+                'orders': order_list,
+                'regions': region_list,
+                'deviceType': device_type_list,
+            }
+            return response.json(0, res)
+        except Exception as e:
+            return response.json(500, repr(e))
+
+    @classmethod
+    def query_global_first_pay_order(cls, request, request_dict, response):
+        """
+        查询全球首次付费订单数据
+        @param request:请求
+        @param request_dict:请求参数
+        @param response:响应对象
+        @return:
+        """
+        ap_url = 'https://www.zositechc.cn/dataManagement/serviceData/firstPayOrder'
+        as_url = 'https://www.zositecha.com/dataManagement/serviceData/firstPayOrder'
+        na_url = 'https://www.dvema.com/dataManagement/serviceData/firstPayOrder'
+        eu_url = 'https://www.zositeche.com/dataManagement/serviceData/firstPayOrder'
+        local_url = 'http://127.0.0.1:8000/dataManagement/serviceData/firstPayOrder'
+        url_list = [local_url]
+        try:
+            headers = {
+                'Authorization': request.META.get('HTTP_AUTHORIZATION')
+            }
+            order_list = []
+            region_list = []
+            region_count = 0
+            device_type_list = []
+            device_type_count = 0
+            for url in url_list:
+                res = requests.get(url=url, params=request_dict, headers=headers)
+                result = res.json()
+                if result['result_code'] == 0:
+                    # 处理订单
+                    for item in result['result']['orders']:
+                        flag = 0
+                        for each in order_list:
+                            if each['startTime'] == item['startTime'] and each['endTime'] == item['endTime']:
+                                each['count'] += int(item['count'])
+                                flag = 1
+                                break
+                        if flag == 0:
+                            order_list.append(item)
+                    # 处理地区
+                    for item in result['result']['regions']:
+                        flag = 0
+                        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:
+                        rate = round(item['count'] / region_count * 100, 2)
+                        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:
+                        type_rate = round(item['count'] / device_type_count * 100, 2)
+                        item['typeRate'] = type_rate
+                else:
+                    return response.json(result['result_code'])
+            res = {
+                'orders': order_list,
+                'regions': region_list,
+                'deviceType': device_type_list,
+            }
+            return response.json(0, res)
+        except Exception as e:
+            return response.json(500, repr(e))
+
+    @classmethod
+    def query_global_repeat_pay_order(cls, request, request_dict, response):
+        """
+        查询全球复购订单数据
+        @param request:请求
+        @param request_dict:请求参数
+        @param response:响应对象
+        @return:
+        """
+        ap_url = 'https://www.zositechc.cn/dataManagement/businessData/repeatPayOrder'
+        as_url = 'https://www.zositecha.com/dataManagement/businessData/repeatPayOrder'
+        na_url = 'https://www.dvema.com/dataManagement/businessData/repeatPayOrder'
+        eu_url = 'https://www.zositeche.com/dataManagement/businessData/repeatPayOrder'
+        local_url = 'http://127.0.0.1:8000/dataManagement/businessData/repeatPayOrder'
+        url_list = [local_url]
+        try:
+            headers = {
+                'Authorization': request.META.get('HTTP_AUTHORIZATION')
+            }
+            order_list = []
+            region_list = []
+            region_count = 0
+            device_type_list = []
+            device_type_count = 0
+            repeat_count = 0
+            order_count = 0
+            for url in url_list:
+                res = requests.get(url=url, params=request_dict, headers=headers)
+                result = res.json()
+                if result['result_code'] == 0:
+                    # 处理订单
+                    for item in result['result']['orders']:
+                        flag = 0
+                        for each in order_list:
+                            if each['startTime'] == item['startTime'] and each['endTime'] == item['endTime']:
+                                each['count'] += int(item['count'])
+                                flag = 1
+                                break
+                        if flag == 0:
+                            order_list.append(item)
+                    # 处理地区
+                    for item in result['result']['regions']:
+                        flag = 0
+                        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:
+                        rate = round(item['count'] / region_count * 100, 2)
+                        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:
+                        type_rate = round(item['count'] / device_type_count * 100, 2)
+                        item['typeRate'] = type_rate
+                    # 处理订单复购率
+                    repeat_count += result['result']['repeatCount']
+                    order_count += result['result']['orderCount']
+                else:
+                    return response.json(result['result_code'])
+            repeat_rate = round(repeat_count / order_count * 100, 2)
+            res = {
+                'orders': order_list,
+                'regions': region_list,
+                'deviceType': device_type_list,
+                'repeatRate': repeat_rate,
+                'repeatCount': repeat_count,
+                'orderCount': order_count
+            }
+            return response.json(0, res)
+        except Exception as e:
+            return response.json(500, repr(e))

AdminController/dataSystemManagement/UserDataController.py

@@ -7,15 +7,12 @@
 @Software: PyCharm
 """
 
-from django.db.models import Q, Count
+from django.db.models import Count
 from django.views.generic.base import View
 import datetime
+import requests
 
-from Ansjer.config import OSS_STS_ACCESS_SECRET, OSS_STS_ACCESS_KEY
-from Controller.DeviceConfirmRegion import Device_Region
 from Model.models import Device_User, CountryModel
-from Object.ResponseObject import ResponseObject
-from Object.TokenObject import TokenObject
 from Service.CommonService import CommonService
 
 
@@ -42,6 +39,12 @@ class UserDataView(View):
             return self.user_active(request_dict, response)
         elif operation == 'region':  # 查询用户地区分布
             return self.user_region(response)
+        elif operation == 'global/increase':  # 查询全球用户新增数据
+            return self.global_user_increase(request, request_dict, response)
+        elif operation == 'global/active':  # 查询全球用户活跃数据
+            return self.global_user_active(request, request_dict, response)
+        elif operation == 'global/region':  # 查询全球用户地区分布
+            return self.global_user_region(request, response)
         else:
             return response.json(414)
 
@@ -172,10 +175,177 @@ class UserDataView(View):
             for item in user_qs:
                 country_id = item['region_country']
                 country_qs = CountryModel.objects.filter(id=country_id).values('country_name')
-                item['country_name'] = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
+                item['countryName'] = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
                 item['rate'] = round(item['count'] / count * 100, 2)
             res['countries'] = list(user_qs)
 
             return response.json(0, res)
         except Exception as e:
             return response.json(500, repr(e))
+
+    @classmethod
+    def global_user_increase(cls, request, request_dict, response):
+        """
+        查询全球用户新增数据
+        @param request:请求
+        @param request_dict:请求参数
+        @param response:响应对象
+        @return:
+        """
+        ap_url = 'https://www.zositechc.cn/dataManagement/userData/increase'
+        as_url = 'https://www.zositecha.com/dataManagement/userData/increase'
+        na_url = 'https://www.dvema.com/dataManagement/userData/increase'
+        eu_url = 'https://www.zositeche.com/dataManagement/userData/increase'
+        local_url = 'http://127.0.0.1:8000/dataManagement/userData/increase'
+        url_list = [local_url]
+        try:
+            headers = {
+                'Authorization': request.META.get('HTTP_AUTHORIZATION')
+            }
+            user_list = []
+            region_list = []
+            region_count = 0
+            for url in url_list:
+                res = requests.get(url=url, params=request_dict, headers=headers)
+                result = res.json()
+                if result['result_code'] == 0:
+                    for item in result['result']['user']:
+                        flag = 0
+                        for each in user_list:
+                            if item['startTime'] == each['startTime'] and item['endTime'] == each['endTime']:
+                                each['count'] += item['count']
+                                flag = 1
+                                break
+                        if flag == 0:
+                            user_list.append(item)
+                    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:
+                        item['rate'] = round(item['count']/region_count*100, 2)
+                else:
+                    return response.json(result['result_code'])
+            res = {
+                'user': user_list,
+                'region': region_list
+            }
+            return response.json(0, res)
+        except Exception as e:
+            return response.json(500, repr(e))
+
+    @classmethod
+    def global_user_active(cls, request, request_dict, response):
+        """
+        查询全球用户活跃数据
+        @param request:请求
+        @param request_dict:请求参数
+        @param response:响应对象
+        @return:
+        """
+        ap_url = 'https://www.zositechc.cn/dataManagement/userData/active'
+        as_url = 'https://www.zositecha.com/dataManagement/userData/active'
+        na_url = 'https://www.dvema.com/dataManagement/userData/active'
+        eu_url = 'https://www.zositeche.com/dataManagement/userData/active'
+        local_url = 'http://127.0.0.1:8000/dataManagement/userData/active'
+        url_list = [local_url]
+        try:
+            headers = {
+                'Authorization': request.META.get('HTTP_AUTHORIZATION')
+            }
+            user_list = []
+            region_list = []
+            region_count = 0
+            for url in url_list:
+                res = requests.get(url=url, params=request_dict, headers=headers)
+                result = res.json()
+                if result['result_code'] == 0:
+                    for item in result['result']['user']:
+                        flag = 0
+                        for each in user_list:
+                            if item['startTime'] == each['startTime'] and item['endTime'] == each['endTime']:
+                                each['count'] += item['count']
+                                flag = 1
+                                break
+                        if flag == 0:
+                            user_list.append(item)
+                    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:
+                        item['rate'] = round(item['count']/region_count*100, 2)
+                else:
+                    return response.json(result['result_code'])
+            res = {
+                'user': user_list,
+                'region': region_list
+            }
+            return response.json(0, res)
+        except Exception as e:
+            return response.json(500, repr(e))
+
+    @classmethod
+    def global_user_region(cls, request, response):
+        """
+        查询全球用户地区分布
+        @param request:请求
+        @param request_dict:请求参数
+        @param response:响应对象
+        @return:
+        """
+        ap_url = 'https://www.zositechc.cn/dataManagement/userData/region'
+        as_url = 'https://www.zositecha.com/dataManagement/userData/region'
+        na_url = 'https://www.dvema.com/dataManagement/userData/region'
+        eu_url = 'https://www.zositeche.com/dataManagement/userData/region'
+        local_url = 'http://127.0.0.1:8000/dataManagement/userData/region'
+        url_list = [local_url]
+        try:
+            headers = {
+                'Authorization': request.META.get('HTTP_AUTHORIZATION')
+            }
+            user_list = []
+            user_count = 0
+            for url in url_list:
+                res = requests.get(url=url, headers=headers)
+                result = res.json()
+                if result['result_code'] == 0:
+                    # 处理地区
+                    for item in result['result']['countries']:
+                        flag = 0
+                        for each in user_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)
+                            user_count += int(item['count'])
+                    for item in user_list:
+                        rate = round(item['count'] / user_count * 100, 2)
+                        item['rate'] = rate
+
+                else:
+                    return response.json(result['result_code'])
+            res = {
+                'countries': user_list
+            }
+            return response.json(0, res)
+        except Exception as e:
+            return response.json(500, repr(e))
+