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

AdminController/dataSystemManagement/UserDataController.py

@@ -128,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)).values('region_country', )
+            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']
+            # 处理用户地区
+            region_list = []
+            for item in all_user_qs:
+                country_temp_dict = eval(item['country'])
+                for k, v in country_temp_dict.items():
+                    flag = 0
+                    for each in region_list:
+                        if k == each['countryName']:
+                            each['count'] += v
+                            flag = 1
+                            break
+                    if flag == 0:
+                        region_list.append({
+                            'countryName': k,
+                            'count': v
+                        })
+            for item in region_list:
+                item['rate'] = round(item['count'] / count * 100, 2) if count else 0
+            # 处理时间段用户
+            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], query_type=0).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[:30]:
-                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
@@ -186,36 +186,49 @@ class UserDataView(View):
             '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']
             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():
+                country_temp_dict = eval(item['country'])
+                continent_temp_dict = eval(item['continent'])
+                # 处理用户国家
+                for k, v in country_temp_dict.items():
+                    flag = 0
+                    for each in country_list:
+                        if k == each['countryName']:
+                            each['count'] += v
+                            flag = 1
+                            break
+                    if flag == 0:
+                        country_list.append({
+                            'countryName': k,
+                            'count': v
+                        })
+                # 处理用户大洲
+                for k, v in continent_temp_dict.items():
                     flag = 0
                     for each in continent_list:
-                        if country_qs[0]['region__name'] == each['continentName']:
-                            each['count'] += item['count']
+                        if k == each['continentName']:
+                            each['count'] += v
                             flag = 1
                             break
                     if flag == 0:
                         continent_list.append({
-                            'continentName': country_qs[0]['region__name'],
-                            'count': item['count']
+                            'continentName': k,
+                            'count': v
                         })
-            for item in continent_list:
                 if count:
                     item['rate'] = round(item['count'] / count * 100, 2)
                 else:
                     item['rate'] = 0
-            res['countries'] = list(user_qs)
+
+            for item in country_list:
+                item['rate'] = round(item['count'] / count * 100, 2) if count else 0
+            for item in continent_list:
+                item['rate'] = round(item['count'] / count * 100, 2) if count else 0
+            res['countries'] = country_list
             res['continent'] = continent_list
             return response.json(0, res)
         except Exception as e:

Controller/Cron/CronTaskController.py

@@ -16,7 +16,7 @@ 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, VodHlsSummary, VideoPlaybackTimeModel, DeviceUserSummary, \
-    CountryModel
+    CountryModel, DeviceTypeModel, Lang, UnicomCombo, OrdersSummary, DeviceInfoSummary
 from Object.ResponseObject import ResponseObject
 from Object.utils import LocalDateTimeUtil
 from Service.CommonService import CommonService
@@ -307,8 +307,12 @@ class CronCollectDataView(View):
         response = ResponseObject()
         if operation == 'collectPlayBack':  # 定时保存云存视频回放
             return self.collect_play_back(response)
-        if operation == 'collectDeviceUser':  # 定时保存云存视频回放
+        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)
 
@@ -416,3 +420,301 @@ class CronCollectDataView(View):
             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',
+                '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',
+                                                                                                  '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)
+                            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 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.device_type = device_type_temp_dict
+                            device_info_summary.count += 1
+                            device_info_summary.save()
+                        else:
+                            country_temp_dict = {country_name: 1}
+                            continent_temp_dict = {continent_name: 1}
+                            vod_service_temp_dict = {device_type_name: 1} if item['cloud_vod'] != 2 else {
+                                device_type_name: 0}
+                            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,
+                                                             device_type=device_type_temp_dict)
+
+            return response.json(0)
+        except Exception as e:
+            return response.json(500, repr(e))

Model/models.py

@@ -2913,7 +2913,7 @@ class DeviceUserSummary(models.Model):
     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.CharField(verbose_name='国家信息', max_length=255, default='')
+    country = models.CharField(verbose_name='所属国家', max_length=255, default='')
     continent = models.CharField(verbose_name='四大洲信息', max_length=255, default='')
 
     def __str__(self):
@@ -2923,3 +2923,42 @@ class DeviceUserSummary(models.Model):
         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.CharField(verbose_name='所属国家', max_length=255, default='')
+    device_type = models.CharField(verbose_name='设备类型信息', max_length=255, default='')
+    store_meal = models.CharField(verbose_name='套餐信息', max_length=255, 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.CharField(verbose_name='所属国家', max_length=255, default='')
+    continent = models.CharField(verbose_name='四大洲信息', max_length=255, default='')
+    device_type = models.CharField(verbose_name='设备类型信息', max_length=255, default='')
+    vod_service = models.CharField(verbose_name='云存服务信息', max_length=255, default='')
+
+    def __str__(self):
+        return self.id
+
+    class Meta:
+        db_table = 'device_info_summary'
+        verbose_name = u'设备汇总信息表'
+        verbose_name_plural = verbose_name