ASJServer/Controller/SerialNumberController.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import logging
import random
import time

from django.db import transaction
from django.views import View

from Model.models import SerialNumberModel, CompanySerialModel, UIDCompanySerialModel, CompanyModel, RegionModel, \
    CountryModel, UIDModel, RegionCountryModel, Device_Info, iotdeviceInfoModel
from Object.RedisObject import RedisObject
from Object.uidManageResponseObject import uidManageResponseObject
from Object.TokenObject import TokenObject
from Service.AlgorithmService import AlgorithmBaseOn35
from Service.CommonService import CommonService
from Service.ModelService import ModelService


class SerialNumberView(View):

    def get(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        operation = kwargs.get('operation', None)
        request_dict = request.GET
        return self.validate(request_dict, operation)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        operation = kwargs.get('operation', None)
        request_dict = request.POST
        return self.validate(request_dict, operation)

    def validate(self, request_dict, operation):
        token = TokenObject(request_dict.get('token', None))
        response = uidManageResponseObject()

        if operation == 'getUID':
            return self.do_get_uid(request_dict, response)
        elif operation == 'getSerial':
            return self.do_get_serial_number(request_dict, response)
        else:
            if token.code != 0:
                return response.json(token.code)

            if operation == 'create':
                return self.do_create(request_dict, response)
            elif operation == 'list':
                return self.do_list(token.userID, request_dict, response)
            elif operation == 'update':
                return self.do_update(token.userID, request_dict, response)
            elif operation == 'attachUID':
                return self.do_attach_uid(request_dict, response)
            elif operation == 'detachUID':
                return self.do_detach_uid(token.userID, request_dict, response)
            else:
                return response.json(404)

    def do_create(self, request_dict, response):
        quantity = int(request_dict.get('quantity', None))

        if not quantity:
            return response.json(444)
        start_time = time.strftime('%Y-%m-%d %H:%M:%S')
        print('start create ' + start_time)
        tmp = []
        algorithm = AlgorithmBaseOn35()

        sum = SerialNumberModel.objects.count()

        for i in range(quantity):
            serial_number = algorithm.getLetter(sum)
            tmp_len = 6 - len(serial_number)
            # 前面补0
            for j in range(tmp_len):
                serial_number = '0' + serial_number

            tmp.append(serial_number)
            sum += 1

        # 把序列号的顺序打乱
        random.shuffle(tmp)

        data = []
        now_time = int(time.time())
        for item in tmp:
            data.append(SerialNumberModel(serial_number=item, add_time=now_time))

            if len(data) == 10000:
                SerialNumberModel.objects.bulk_create(data)
                data.clear()

        if len(data) > 0:
            SerialNumberModel.objects.bulk_create(data)
            data.clear()
        start_time = time.strftime('%Y-%m-%d %H:%M:%S')
        print('start create ' + start_time)

        redis = RedisObject()
        redis.del_data(key='serial_number_count')
        return response.json(0)

    # 提供给pc端获取序列号
    def do_get_serial_number(self, request_dict, response):
        quantity = request_dict.get('quantity', None)
        company_id = request_dict.get('company_id', None)
        token = request_dict.get('token', None)
        time_stamp = request_dict.get('time_stamp', None)

        if token and time_stamp and quantity and company_id:

            token = int(CommonService.decode_data(token))
            time_stamp = int(time_stamp)

            now_time = int(time.time())
            distance = now_time - time_stamp

            if token != time_stamp or distance > 60000 or distance < 0:
                return response.json(404)

            redisObject = RedisObject()
            key = 'serial_lock'
            value = redisObject.lpop(key)
            count = 0
            while value is False and count < 5:
                time.sleep(1)
                value = redisObject.lpop(key)
                count += 1

            if count == 5 and value is False:    #暂时注释
                return response.json(5)

            quantity = int(quantity)

            company_serial_qs = CompanySerialModel.objects.filter(company__secret=company_id, status=0)
            if not company_serial_qs.exists():
                redisObject.rpush(key, value)
                return response.json(373)

            # 存在对应的企业
            company_serial_qs = company_serial_qs[0:quantity]

            #company_serial_qs = company_serial_qs.values('id', 'serial_number__serial_number', 'company__mark')
            data = []
            ids = []
            for serial in company_serial_qs:
                ids.append(serial.id)
                data.append(serial.serial_number.serial_number + serial.company.mark)
            CompanySerialModel.objects.filter(id__in=ids).update(status=1)
            redisObject.rpush(key, value)
            return response.json(0, data)
        else:
            return response.json(444)

    def do_list(self, userID, request_dict, response):
        # perm = ModelService.check_perm_uid_manage(userID, 0)
        # if not perm:
        #     return response.json(309)

        page = request_dict.get('page', None)
        line = request_dict.get('limit', None)
        serial_number = request_dict.get('serial_number', None)
        status = request_dict.get('status', None)

        if page and line:
            page = int(page)
            line = int(line)

            serial_qs = SerialNumberModel.objects.filter()

            if serial_number:
                serial_qs = serial_qs.filter(serial_number__contains=serial_number)

            if status:
                serial_qs = serial_qs.filter(status=status)

            count = serial_qs.count()

            start = (page - 1) * line
            end = start + line

            serial_qs = serial_qs[start: end].values()
            res = {
                'count': count,
                'data': list(serial_qs)
            }

            return response.json(0, res)
        else:
            return response.json(444)

    @transaction.atomic
    def do_attach_uid(self, request_dict, response):
        serial_number = request_dict.get('serial_number', None)
        country_id = request_dict.get('country_id', None)
        company_id = request_dict.get('company_id', None)

        if serial_number and len(serial_number) == 9 and country_id and company_id:
            mark = serial_number[6:9]
            serial = serial_number[0:6]

            savePoint = transaction.savepoint()
            try:
                try:

                    # 判断序列号是否已和企业关联
                    company_serial_qs = CompanySerialModel.objects.filter(company__secret=company_id,
                                                                          serial_number__serial_number=serial)
                    if not company_serial_qs.exists():
                        return response.json(173)

                    region_country_qs = RegionCountryModel.objects.filter(number=country_id)
                    endpoint = 'a2rqy12o004ad8-ats.iot.us-east-1.amazonaws.com'
                    if region_country_qs.exists():
                        user_region = region_country_qs[0]
                        if user_region.region_id == 1:
                            endpoint = 'a250bbr0p9u7as-ats.iot.cn-northwest-1.amazonaws.com.cn'
                        elif user_region.region_id == 2:
                            endpoint = 'a2rqy12o004ad8-ats.iot.ap-southeast-1.amazonaws.com'
                        elif user_region.region_id == 3:
                            endpoint = 'a2rqy12o004ad8-ats.iot.eu-west-1.amazonaws.com'

                    # 当序列号已关联UID
                    company_serial = company_serial_qs[0]

                    if company_serial.status == 0:
                        # 该序列号未绑定企业
                        return response.json(173)
                    elif company_serial.status == 1:
                        # 确定所在区域
                        country_qs = CountryModel.objects.filter(number=country_id)
                        if not country_qs.exists():
                            return response.json(374)

                        region = country_qs.values('region_id')[0]

                        count = 0
                        while count < 3:
                            uid_qs = UIDModel.objects.filter(vpg__company_id=company_serial.company.id, vpg__region_id=region['region_id'],
                                                             status=0)
                            if uid_qs.exists():
                                uid = uid_qs[0]
                                print(uid)
                                # uid.status = 2
                                # uid.update_time = int(time.time())
                                result = UIDModel.objects.filter(id=uid.id, status=0).update(**{
                                    'status': 2, 'update_time': int(time.time())
                                })

                                if int(result) <= 0:
                                    count += 1
                                    continue

                                now_time = int(time.time())
                                uid_serial = UIDCompanySerialModel(uid_id=uid.id, company_serial_id=company_serial.id,
                                                                   add_time=now_time, update_time=now_time)
                                uid_serial.save()

                                company_serial.status = 2
                                company_serial.save()

                                res = {
                                    'uid': CommonService.encode_data(uid.uid),
                                    'mac': CommonService.encode_data(uid.mac),
                                    'extra': uid.uid_extra,
                                    'endpoint': endpoint
                                }
                                return response.json(0, res)
                            else:
                                return response.json(375)

                        return response.json(5)
                    else:
                        uid_qs = UIDCompanySerialModel.objects.filter(company_serial_id=company_serial.id)
                        if uid_qs.exists():
                            uid = uid_qs.values('uid__uid', 'uid__mac', 'uid__uid_extra')[0]
                            res = {
                                'uid': CommonService.encode_data(uid['uid__uid']),
                                'mac': CommonService.encode_data(uid['uid__mac']),
                                'extra': uid['uid__uid_extra'],
                                'endpoint': endpoint
                            }
                            return response.json(0, res)
                        else:
                            return response.json(173)
                except Exception as e:
                    # print('--------------------------error 5000')
                    # print(repr(e))
                    if savePoint:
                        transaction.rollback(savePoint)
                    djangoLogger = logging.getLogger('django')
                    djangoLogger.exception(repr(e))
                    return response.json(176, str(e))
            except Exception as e:
                # print('--------------------------error 5001')
                # print(repr(e))
                djangoLogger = logging.getLogger('django')
                djangoLogger.exception(repr(e))
                return response.json(176, str(e))

        else:
            return response.json(444)

    def do_get_uid(self, request_dict, response):
        serial_number = request_dict.get('serial_number', None)
        token = request_dict.get('token', None)
        time_stamp = request_dict.get('time_stamp', None)

        if token and time_stamp and serial_number and len(serial_number) == 9:

            token = int(CommonService.decode_data(token))
            time_stamp = int(time_stamp)

            now_time = int(time.time())
            distance = now_time - time_stamp

            if token != time_stamp or distance > 300 or distance < 0:
                return response.json(404)

            mark = serial_number[6:9]
            serial = serial_number[0:6]
            uid_company_serial_qs = UIDCompanySerialModel.objects.filter(company_serial__company__mark=mark, company_serial__serial_number__serial_number=serial)

            if uid_company_serial_qs.exists():
                uid = uid_company_serial_qs.values('uid__uid', 'uid__mac', 'uid__uid_extra')[0]

                res = {
                    'uid': CommonService.encode_data(uid['uid__uid']),
                    'mac': CommonService.encode_data(uid['uid__mac']),
                    'extra': uid['uid__uid_extra']
                }

                return response.json(0, res)
            else:
                return response.json(173)
        else:
            return response.json(444)

    def do_detach_uid(self, userID, request_dict, response):
        serial_number = request_dict.get('serial_number', None)

        if serial_number:
            serial = serial_number[0:6]

            uid_serial_qs = UIDCompanySerialModel.objects.filter(company_serial__serial_number=serial)
            if uid_serial_qs.exists():
                uid_serial = uid_serial_qs[0]

                Device_Info.objects.filter(UID=uid_serial.uid).update(endpoint='',
                                                           token_iot_number='')
                iotdeviceInfoModel.objects.filter(uid=uid_serial.uid).delete()

                company_serial_qs = CompanySerialModel.objects.filter(id=uid_serial.company_serial.id)
                if company_serial_qs.exists():
                    company_serial = company_serial_qs[0]
                    company_serial.status = 1
                    company_serial.save()

                uid_qs = UIDModel.objects.filter(uid=uid_serial.uid)
                if uid_qs.exists():
                    uid = uid_qs[0]
                    uid.status = 0
                    uid.save()
                uid_serial.delete()
                return response.json(0)
            else:
                return response.json(173)
        else:
            return response.json(444)

    def do_update(self, userID, request_dict, response):
        # perm = ModelService.check_perm_uid_manage(userID, 0)
        # if not perm:
        #     return response.json(309)

        id = request_dict.get('id', None)
        status = request_dict.get('status', None)

        if id and status:
            serial_number_qs = SerialNumberModel.objects.filter(id=id)
            if serial_number_qs.exists():
                serial_number_qs.update(**{'status': status})
                return response.json(0)
            else:
                return response.json(173)
        else:
            return response.json(444)