ASJServer/AdminController/LogManagementController.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-


import requests
from django.views.generic.base import View
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject
from Service.CommonService import CommonService
from Model.models import Device_Info, RequestRecordModel, iotdeviceInfoModel, Access_Log, DeviceLogModel


class LogManagementView(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):
        language = request_dict.get('language', 'en')
        response = ResponseObject(language, 'pc')
        if operation == '??':
            return 0
        else:
            tko = TokenObject(
                request.META.get('HTTP_AUTHORIZATION'),
                returntpye='pc')
            # if tko.code != 0:
            #     return response.json(tko.code)
            response.lang = tko.lang
            userID = tko.userID
            if operation == 'getRequestList':
                return self.getRequestList(request_dict, response)
            elif operation == 'getDeviceIotInfoList':
                return self.getDeviceIotInfoList(request_dict, response)
            elif operation == 'requestPublishMqtt':
                return self.requestPublishMqtt(request_dict, response)
            elif operation == 'getAccessLogList':
                return self.getAccessLogList(request_dict, response)
            elif operation == 'getDeviceLogList':
                return self.getDeviceLogList(request_dict, response)
            else:
                return response.json(404)

    def getRequestList(self, request_dict, response):
        pageNo = request_dict.get('pageNo', None)
        pageSize = request_dict.get('pageSize', None)
        method = request_dict.get('method', None)
        url = request_dict.get('url', None)
        parameter = request_dict.get('parameter', None)
        status_code = request_dict.get('status_code', None)
        reason_phrase = request_dict.get('reason_phrase', None)
        if not all([pageNo, pageSize]):
            return response.json(444)

        page = int(pageNo)
        line = int(pageSize)
        try:
            request_qs = RequestRecordModel.objects.all()
            if method:
                request_qs = request_qs.filter(method=method)
            if url:
                request_qs = request_qs.filter(url__contains=url)
            if parameter:
                request_qs = request_qs.filter(parameter__contains=parameter)
            if status_code:
                request_qs = request_qs.filter(status_code=status_code)
            if reason_phrase:
                request_qs = request_qs.filter(reason_phrase=reason_phrase)

            count = request_qs.count()

            request_qs = request_qs[(page - 1) * line:page * line]
            qs_list = []
            for requsetobj in request_qs:
                qs_list.append({
                    'id': requsetobj.id,
                    'method': requsetobj.method,
                    'url': requsetobj.url,
                    'parameter': requsetobj.parameter,
                    'execute_time': round(requsetobj.execute_time, 2),  # 时间保留小数点后两位
                    'status_code': requsetobj.status_code,
                    'reason_phrase': requsetobj.reason_phrase,
                    'add_time': requsetobj.add_time.strftime("%Y-%m-%d %H:%M:%S"),
                })
            return response.json(
                0, {'list': qs_list, 'total': count})
        except Exception as e:
            print(e)
            return response.json(500, repr(e))

    def getDeviceIotInfoList(self, request_dict, response):
        serial_number = request_dict.get('serial_number', None)
        uid = request_dict.get('uid', None)
        pageNo = request_dict.get('pageNo', None)
        pageSize = request_dict.get('pageSize', None)

        if not all([pageNo, pageSize]):
            return response.json(444)

        page = int(pageNo)
        line = int(pageSize)
        try:
            if serial_number or uid:
                if serial_number:
                    iot_device_info_qs = iotdeviceInfoModel.objects.filter(serial_number__contains=serial_number)
                if uid:
                    iot_device_info_qs = iotdeviceInfoModel.objects.filter(uid__contains=uid)
                if not iot_device_info_qs.exists():
                    return response.json(0)
                total = len(iot_device_info_qs)
                iot_device_info_qs = iot_device_info_qs.values('serial_number', 'uid', 'thing_name', 'thing_groups',
                                                               'add_time', 'update_time')[(page - 1) * line:page * line]
            else:
                total = iotdeviceInfoModel.objects.filter().count()
                iot_device_info_qs = iotdeviceInfoModel.objects.filter().values('serial_number', 'uid', 'thing_name',
                                                                                'thing_groups', 'add_time', 'update_time')[(page - 1) * line:page * line]

            iot_device_info_list = CommonService.qs_to_list(iot_device_info_qs)
            # 获取序列号的uid
            for iot_device_info in iot_device_info_list:
                if not iot_device_info['uid']:
                    device_info_qs = Device_Info.objects.filter(serial_number__contains=iot_device_info['serial_number']).values('UID')
                    if device_info_qs.exists():
                        iot_device_info['uid'] = device_info_qs[0]['UID']
            return response.json(0, {'list': iot_device_info_list, 'total': total})
        except Exception as e:
            print(e)
            return response.json(500, repr(e))

    def requestPublishMqtt(self, request_dict, response):
        # 通用发布MQTT主题通知
        msg = request_dict.get('msg', None)
        thing_name = request_dict.get('thing_name', None)
        topic_name = request_dict.get('topic_name', None)
        if not all([msg, thing_name, topic_name]):
            return response.json(444)

        try:
            # 获取数据组织将要请求的url
            iot = iotdeviceInfoModel.objects.filter(thing_name=thing_name).values('endpoint', 'token_iot_number')
            if not iot.exists():
                return response.json(10043)
            endpoint = iot[0]['endpoint']
            Token = iot[0]['token_iot_number']

            # api doc: https://docs.aws.amazon.com/zh_cn/iot/latest/developerguide/http.html
            # url: https://IoT_data_endpoint/topics/url_encoded_topic_name?qos=1
            # post请求url发布MQTT消息
            url = 'https://{}/topics/{}'.format(endpoint, topic_name)
            authorizer_name = 'Ansjer_Iot_Auth'
            signature = CommonService.rsa_sign(Token)  # Token签名
            headers = {'x-amz-customauthorizer-name': authorizer_name, 'Token': Token,
                       'x-amz-customauthorizer-signature': signature}
            msg = eval(msg)
            r = requests.post(url=url, headers=headers, json=msg, timeout=2)
            if r.status_code == 200:
                res = r.json()
                if res['message'] == 'OK':
                    return response.json(0)
                return response.json(10044)
            else:
                return response.json(10044)
        except Exception as e:
            return response.json(500, repr(e))

    def getAccessLogList(self, request_dict, response):
        user = request_dict.get('user', None)
        operation = request_dict.get('operation', None)
        status = request_dict.get('status', None)
        pageNo = request_dict.get('pageNo', None)
        pageSize = request_dict.get('pageSize', None)

        if not all([pageNo, pageSize]):
            return response.json(444)

        page = int(pageNo)
        line = int(pageSize)
        try:
            if user or operation or status:
                if user:
                    access_log_qs = Access_Log.objects.filter(user__contains=user)
                if operation:
                    access_log_qs = Access_Log.objects.filter(operation__contains=operation)
                if status:
                    access_log_qs = Access_Log.objects.filter(status=status)
                if not access_log_qs.exists():
                    return response.json(0)
                total = access_log_qs.count()
                access_log_qs = access_log_qs.values('user', 'operation', 'ip', 'status', 'content', 'time')[(page - 1) * line:page * line]
            else:
                total = Access_Log.objects.count()
                access_log_qs = Access_Log.objects.filter().values('user', 'operation', 'ip', 'status', 'content', 'time')[(page - 1) * line:page * line]
            access_log_list = CommonService.qs_to_list(access_log_qs)
            return response.json(0, {'list': access_log_list, 'total': total})
        except Exception as e:
            print(e)
            return response.json(500, repr(e))

    def getDeviceLogList(self, request_dict, response):
        uid = request_dict.get('uid', None)
        serial_number = request_dict.get('serial_number', None)
        pageNo = request_dict.get('pageNo', None)
        pageSize = request_dict.get('pageSize', None)

        if not all([pageNo, pageSize]):
            return response.json(444)

        page = int(pageNo)
        line = int(pageSize)
        try:
            if uid or serial_number:
                if uid:
                    device_log_qs = DeviceLogModel.objects.filter(uid__contains=uid)
                if serial_number:
                    device_log_qs = DeviceLogModel.objects.filter(serial_number__contains=serial_number)
                if not device_log_qs.exists():
                    return response.json(0)
                total = device_log_qs.count()
                device_log_qs = device_log_qs.order_by('-add_time').values()[(page - 1) * line:page * line]
            else:
                total = DeviceLogModel.objects.count()
                device_log_qs = DeviceLogModel.objects.filter().order_by('-add_time').values()[(page - 1) * line:page * line]
            device_log_list = CommonService.qs_to_list(device_log_qs)
            return response.json(0, {'list': device_log_list, 'total': total})
        except Exception as e:
            print(e)
            return response.json(500, repr(e))