ASJServer/AdminController/SerialManageController.py

#!/usr/bin/python3.6
# -*- coding: utf-8 -*-
#
# Copyright (C) 2022 #
# @Time    : 2022/3/9 9:20
# @Author  : ming
# @Email   : zhangdongming@asj6.wecom.work
# @File    : SurveysManageController.py
# @Software: PyCharm

from django.utils.decorators import method_decorator
from django.views.decorators.csrf import csrf_exempt
from django.views.generic.base import View

from Model.models import CompanyModel, SerialNumberModel, VPGModel, UIDModel, UIDCompanySerialModel, CompanySerialModel
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject


class SerialView(View):
    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(SerialView, self).dispatch(*args, **kwargs)

    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 = TokenObject(request.META.get('HTTP_AUTHORIZATION'))
        response = ResponseObject()
        if token.code != 0:
            return response.json(token.code)
        response = ResponseObject(returntype='pc')
        if operation == 'company-page':
            return self.company_page(request_dict, response)
        if operation == 'number/page':
            return self.serial_page(request_dict, response)
        if operation == 'vpg-info/page':
            return self.vpg_page(request_dict, response)
        if operation == 'uid-info/page':
            return self.uid_page(request_dict, response)
        return response.json(0)

    @classmethod
    def company_page(cls, request_dict, response):
        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:
            request_qs = CompanyModel.objects.all()
            if not request_qs.exists():
                return response.json(0, {'list': '', 'total': 0})
            total = request_qs.count()
            company_page = request_qs.order_by('-add_time')[(page - 1) * line:page * line].values()
            return response.json(0, {'list': list(company_page), 'total': total})
        except Exception as e:
            print(e)
            return response.json(500, repr(e))

    @classmethod
    def serial_page(cls, request_dict, response):
        pageNo = request_dict.get('pageNo', None)
        pageSize = request_dict.get('pageSize', None)
        serial_number = request_dict.get('serialNumber', None)
        status = request_dict.get('status', None)
        use_status = request_dict.get('useStatus', None)
        if not all([pageNo, pageSize]):
            return response.json(444)
        page = int(pageNo)
        line = int(pageSize)
        try:
            query = SerialNumberModel.objects.filter()
            if serial_number:
                query = query.filter(serial_number__contains=serial_number)
            if status:
                status = int(status)
                query = query.filter(status=status)
            if use_status:
                use_status = int(use_status)
                query = query.filter(use_status=use_status)
            if not query.exists():
                return response.json(0, {'list': '', 'total': 0})
            total = query.count()
            serial_number_page = query.order_by('-add_time')[(page - 1) * line:page * line].values()
            if serial_number_page.exists():
                return response.json(0, {'list': list(serial_number_page), 'total': total})
            return response.json(173)
        except Exception as e:
            print(e)
            return response.json(500, repr(e))

    @classmethod
    def vpg_page(cls, request_dict, response):
        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:
            query = VPGModel.objects.filter()
            if not query.exists():
                return response.json(0, {'list': '', 'total': 0})
            total = query.count()
            vpg_page = query.order_by('-add_time')[(page - 1) * line:page * line] \
                .values('id', 'name',
                        'region__name',
                        'region_id',
                        'company__name',
                        'add_time',
                        'update_time',
                        'company__secret',
                        'uid_count')
            if vpg_page.exists():
                return response.json(0, {'list': list(vpg_page), 'total': total})
            return response.json(173)
        except Exception as e:
            print(e)
            return response.json(500, repr(e))

    @classmethod
    def uid_page(cls, request_dict, response):
        pageNo = request_dict.get('pageNo', None)
        pageSize = request_dict.get('pageSize', None)
        status = request_dict.get('status', None)
        serial_number = request_dict.get('serialNumber', None)
        uid = request_dict.get('uid', None)
        p2p_type = request_dict.get('p2pType', None)
        if not all([pageNo, pageSize]):
            return response.json(444)
        page = int(pageNo)
        line = int(pageSize)
        try:
            query = UIDModel.objects.filter()
            if serial_number:
                company_serial_qs = CompanySerialModel.objects.filter(serial_number=serial_number).values()
                if company_serial_qs.exists():
                    cs_id = str(company_serial_qs[0]['id'])
                    uid_company_serial_qs = UIDCompanySerialModel.objects.filter(company_serial_id=cs_id).values(
                        'uid_id')
                    if uid_company_serial_qs.exists():
                        uid_id = uid_company_serial_qs[0]['uid_id']
                        query = query.filter(id=uid_id)
            if status:
                query = query.filter(status=int(status))
            if uid:
                query = query.filter(uid__contains=uid)
            if p2p_type:
                query = query.filter(p2p_type=int(p2p_type))
            if not query.exists():
                return response.json(0, {'list': '', 'total': 0})
            total = query.count()
            uid_page = query.order_by('-add_time')[(page - 1) * line:page * line]
            result_list = []
            if not uid_page.exists():
                return response.json(0, {'list': '', 'total': 0})
            for vo in uid_page:
                uid_company_serial_qs = UIDCompanySerialModel.objects.filter(uid_id=vo.id).values('uid_id',
                                                                                                  'company_serial_id')
                serial = None
                if uid_company_serial_qs.exists():
                    company_serial_id = uid_company_serial_qs[0]['company_serial_id']
                    company_serial_qs = CompanySerialModel.objects.filter(id=company_serial_id).values()
                    if company_serial_qs.exists():
                        serial = str(company_serial_qs[0]['serial_number'])
                result_list.append({
                    'id': vo.id,
                    'uid': vo.uid,
                    'mac': vo.mac,
                    'extra': vo.uid_extra,
                    'serial': serial,
                    'status': vo.status,
                    'area': vo.area,
                    'p2pType': vo.p2p_type,
                    'fullUidCode': vo.full_uid_code,
                    'updateTime': vo.update_time,
                    'addTime': vo.add_time
                })
            return response.json(0, {'list': result_list, 'total': total})

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