ASJServer/AdminController/dataSystemManagement/DeviceDataController.py

# -*- encoding: utf-8 -*-
"""
@File    : UserDataController.py
@Time    : 2022/8/16 10:44
@Author  : peng
@Email   : zhangdongming@asj6.wecom.work
@Software: PyCharm
"""

import time

import oss2
from django.db import connection
from django.db import transaction
from django.db.models import Q, Count
from django.views.generic.base import View
import datetime

from Ansjer.config import OSS_STS_ACCESS_SECRET, OSS_STS_ACCESS_KEY, DEVICE_TYPE
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, DeviceTypeModel, Order_Model
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject
from Service.CommonService import CommonService


# 设备数据
class DeviceDataView(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):
        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':  # 统计设备类型
            return self.type_statistics(response)
        if operation == 'regional':  # 设备地区分布
            return self.regional_statistics(response)
        if operation == 'active':  # 查询设备增长数据
            return self.device_add(request_dict, response)
        if operation == 'typeUid':
            return self.type_uid(request_dict, response)
        else:
            return response.json(414)

    @classmethod
    def type_uid(cls, request_dict, response):
        order_type = request_dict.get('orderType', None)
        if not order_type:
            return response.json(444)
        order_type = int(order_type)
        order_type_qs = Order_Model.objects.filter(order_type=order_type).values('UID').order_by('UID').distinct()
        try:
            order_type_list = []
            for order in order_type_qs:
                UID = order['UID']
                device_info_qs = Device_Info.objects.filter(UID=UID).values('Type').order_by('Type').distinct()
                if not device_info_qs.exists():
                    continue
                device_info_qs = device_info_qs[0]['Type']
                order_type_list.append(device_info_qs)
            type_list = []
            for i in order_type_list:
                if i not in type_list:
                    type_list.append(i)

            return response.json(0, type_list)
        except Exception as e:
            print(e)
            return response.json(500)

    @classmethod
    def device_add(cls, request_dict, response):
        """
        查询设备增长数据
        @param request_dict:请求参数
        @request_dict starTime:开始时间
        @request_dict endTime:结束时间
        @param response:响应对象
        """
        start_time = request_dict.get('startTime', None)  # 时间戳
        end_time = request_dict.get('endTime', None)
        unit_time = request_dict.get('unitTime', None)
        order_type = request_dict.get('orderType', None)
        if not all([start_time, end_time, unit_time]):
            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, unit_time)
        try:
            device_info_qs = Device_Info.objects.filter(data_joined__range=(start_time, end_time))
            info_list = []
            count = device_info_qs.count()
            for item in time_list:
                device_info_date_qs = device_info_qs.filter(data_joined__range=item)
                start_time = CommonService.str_to_timestamp(item[0].strftime('%Y-%m-%d %H:%M:%S'))
                end_time = CommonService.str_to_timestamp(item[1].strftime('%Y-%m-%d %H:%M:%S'))
                info_dict = {
                    'count': device_info_date_qs.count(),
                    'startTime': start_time,
                    'endTime': end_time
                }
                info_list.append(info_dict)
            device_info_country_qs = device_info_qs.values('userID__region_country').annotate(
                count=Count('userID__region_country')).order_by('-count')
            region_list = []
            for item in device_info_country_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)
                country_dict = {
                    'countryName': country_name,
                    'count': item['count'],
                    'rate': rate
                }
                region_list.append(country_dict)
            device_type_qs = device_info_qs.values('Type').annotate(count=Count('Type')).order_by('-count')
            type_list = []
            for device_type in device_type_qs:
                type = device_type['type']
                device_type_qs = DeviceTypeModel.objects.filter(type=type).values('name')
                if not device_info_qs.exists():
                    continue
                total = Device_Info.objects.filter(Type=type).count()
                type_dict = {
                    'type': device_type_qs[0]['name'],
                    'total': total
                }
                type_list.append(type_dict)
            order_model_qs = Order_Model.objects.filter(order_type=order_type).values('UID')
            count = order_model_qs.count()
            clound_list = []
            for device_uid in order_model_qs:
                UID = device_uid['UID']
                order_model_qs = Device_Info.objects.filter(UID=UID).values('Type')
                # type_qs =
            res = {
                'info': info_list,
                'region': region_list,
                'type': type_list,
                'cloudStorage': clound_list
            }
            return response.json(0, res)
        except Exception as e:
            return response.json(500, repr(e))

    @classmethod
    def regional_statistics(cls, response):
        """
        统计地区设备数量
        @param response:响应对象
        """
        device_info_qs = Device_Info.objects.all()
        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:
            device_country_list = []
            for device_info in device_info_qs:
                UID = device_info['UID']
                if UID is '':
                    continue
                device_country_list.append(UID)
            device_region_qs = device_info_qs.filter(UID__in=device_country_list).values(
                'userID__region_country').annotate()
            region_list = []
            for device_region in device_region_qs:
                region = device_region['userID__region_country']
                region_list.append(region)
            device_country_qs = device_info_qs.values('userID__region_country').order_by(
                'userID__region_country').distinct()
            device_region_list = []
            for device_country in device_country_qs:
                country_id = device_country['userID__region_country']
                country_qs = CountryModel.objects.filter(id=country_id).values('country_name', 'id')
                countryName = country_qs[0]['country_name'] if country_qs.exists() else '未知区域'
                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
                }
                device_region_list.append(res)
            return response.json(0, device_region_list)
        except Exception as e:
            print(e)
            return response.json(500)

    @classmethod
    def type_statistics(cls, response):
        """
        统计设备类型
        @param response:响应对象
        @return:
        """
        device_info_qs = Device_Info.objects.all().values('Type').annotate(count=Count('Type')).order_by('-count')
        if not device_info_qs.exists():
            return response.json(444)
        try:
            device_info_list = []
            for device_info in device_info_qs:
                type = device_info['Type']
                name = DEVICE_TYPE.get(type, '未知类型')
                name = name if name != 'UNKOWN' else '未知类型'
                count = Device_Info.objects.filter(Type=device_info['Type']).values('UID').annotate(
                    count=Count('UID', distinct=True)).order_by('-count').count()
                device_info_list.append({
                    'type': name,
                    'total': count
                })
            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):
        """
        查询用户增长数据
        @param request_dict:请求参数
        @request_dict startTime:开始时间
        @request_dict endTime:结束时间
        @param response:响应对象
        @return:
        """
        start_time = request_dict.get('startTime', None)
        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))
            res = {
                'total': user_qs.count(),
                'region': []
            }
            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))