合并UID云分配项目

Ansjer/asgi.py

@@ -0,0 +1,16 @@
+"""
+ASGI config for AnsjerUIDManage project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/3.0/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'AnsjerUIDManage.settings')
+
+application = get_asgi_application()

Ansjer/config.py

@@ -1,5 +1,5 @@
-#!/usr/bin/env python3  
-# -*- coding: utf-8 -*-  
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 """
 @Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
 @AUTHOR: ASJRD018
@@ -184,4 +184,161 @@ IOT_HOST = {
     2: 'a2rqy12o004ad8-ats.iot.ap-southeast-1.amazonaws.com',
     3: 'a2rqy12o004ad8-ats.iot.eu-west-1.amazonaws.com',
     4: 'a2rqy12o004ad8-ats.iot.us-east-1.amazonaws.com'
-}
+}
+ONLINE_DEVICE = 1000000
+
+SALES = {
+    2020: [
+        {
+            'name': 'United States',
+            'value': [3768901, 23.337, '美国']
+        },
+        {
+            'name': 'Japan',
+            'value': [1886988, 9.027, '日本']
+        },
+        {
+            'name': 'Russia',
+            'value': [1940038, 7.923, '俄国']
+        },
+        {
+            'name': 'Germany',
+            'value': [1319651, 6.253, '德国']
+        },
+        {
+            'name': 'France',
+            'value': [1291157, 5.825, '法国']
+        },
+        {
+            'name': 'United Kingdom',
+            'value': [1041917, 4.567, '英国']
+        },
+        {
+            'name': 'Italy',
+            'value': [859811, 3.875, '意大利']
+        }
+    ],
+    2019: [
+        {
+            'name': 'United States',
+            'value': [2768900, 37.374, '美国']
+        },
+        {
+            'name': 'Japan',
+            'value': [1086988, 14.672, '日本']
+        },
+        {
+            'name': 'Russia',
+            'value': [940038, 12.689, '俄国']
+        },
+        {
+            'name': 'Germany',
+            'value': [919651, 12.413, '德国']
+        },
+        {
+            'name': 'France',
+            'value': [691157, 9.329, '法国']
+        },
+        {
+            'name': 'United Kingdom',
+            'value': [541917, 7.315, '英国']
+        },
+        {
+            'name': 'Italy',
+            'value': [459811, 6.206, '意大利']
+        }
+    ],
+    2018: [
+        {
+            'name': 'United States',
+            'value': [2068912, 32.329, '美国']
+        },
+        {
+            'name': 'Japan',
+            'value': [1007988, 15.751, '日本']
+        },
+        {
+            'name': 'Germany',
+            'value': [909653, 14.214, '德国']
+        },
+        {
+            'name': 'Russia',
+            'value': [900038, 14.064, '俄国']
+        },
+
+        {
+            'name': 'France',
+            'value': [601158, 9.394, '法国']
+        },
+        {
+            'name': 'United Kingdom',
+            'value': [501920, 7.843, '英国']
+        },
+        {
+            'name': 'Italy',
+            'value': [409813, 6.404, '意大利']
+        }
+    ],
+    2017: [
+        {
+            'name': 'United States',
+            'value': [1668900, 30.914, '美国']
+        },
+        {
+            'name': 'Japan',
+            'value': [906988, 16.800, '日本']
+        },
+        {
+            'name': 'Germany',
+            'value': [809651, 14.998, '德国']
+        },
+        {
+            'name': 'Russia',
+            'value': [800038, 14.820, '俄国']
+        },
+        {
+            'name': 'France',
+            'value': [501157, 9.283, '法国']
+        },
+        {
+            'name': 'United Kingdom',
+            'value': [401920, 7.445, '英国']
+        },
+        {
+            'name': 'Italy',
+            'value': [309822, 5.739, '意大利']
+        }
+    ],
+    2016: [
+        {
+            'name': 'United States',
+            'value': [1468900, 31.943, '美国']
+        },
+        {
+            'name': 'Japan',
+            'value': [806988, 17.549, '日本']
+        },
+        {
+            'name': 'Germany',
+            'value': [709651, 15.432, '德国']
+        },
+        {
+            'name': 'Russia',
+            'value': [700038, 15.223, '俄国']
+        },
+
+        {
+            'name': 'France',
+            'value': [401157, 8.724, '法国']
+        },
+        {
+            'name': 'United Kingdom',
+            'value': [301917, 6.566, '英国']
+        },
+        {
+            'name': 'Italy',
+            'value': [209811, 4.562, '意大利']
+        }
+    ]
+
+}

Ansjer/generacode.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import json
+
+import xlwt
+
+from Object.TokenObject import TokenObject
+import base64
+import requests
+
+token = TokenObject()
+token = token.generate({'userID': str(2)})
+
+file = open('./file/UID-2020-09-09-06-14-44.txt', mode='r', encoding='utf-8')
+content = file.read()
+content = content.replace(' ', '\t')
+
+file1 = open('./file/UID_2020_09_09_06_14_44.txt', mode='w', encoding='utf-8')
+file1.write(content)
+file1.close()
+
+tmps = content.split('\n')
+workbook = xlwt.Workbook(encoding='utf-8')
+sheet1 = workbook.add_sheet('UID')
+num = 0
+for tmp in tmps:
+    lines = tmp.split('\t')
+    for i in range(len(lines)):
+        sheet1.write(num, i, lines[i].strip())
+    num += 1
+
+workbook.save('./file/UID_2020_09_09_06_14_44.xls')
+
+
+file.close()
+
+# url = 'http://192.168.136.35:8000/upload'
+# postData = {
+#     'area': 0,
+#     'token': token['access_token'],
+#     'fileName': content
+# }
+# # postData = json.dumps(postData)
+# print(postData)
+# res = requests.post(url=url, data=postData)
+# print(res)

Ansjer/urls.py

@@ -1,3 +1,4 @@
+from django.contrib import admin
 from django.conf.urls import url
 from django.urls import path, re_path
 
@@ -13,7 +14,8 @@ from Controller import FeedBack, EquipmentOTA, EquipmentInfo, AdminManage, AppIn
     StatisticsController, Alexa, FAQController, AppLogController, EquipmentVersionLimit, VoicePromptController, \
     CDKController, \
     DeviceTypeController, CloudTest, Cloudsum, IotCoreController, OperatingLogs, ProcessInfo, RegionCountryController, \
-    VerifyCodeController
+    VerifyCodeController, FileController, UIDController, LogController, SalesController, \
+    OrderTaskController, HistoryUIDController, UIDManageUserController
 
 urlpatterns = [
     url(r'^testApi/(?P<operation>.*)$', TestApi.testView.as_view()),
@@ -274,6 +276,18 @@ urlpatterns = [
     #Iot Core
     url(r'iot/(?P<operation>.*)$', IotCoreController.IotCoreView.as_view()),
 
+    # 云分配UID
+    path('admin/', admin.site.urls),
+    re_path('user/(?P<operation>.*)', UIDManageUserController.UserView.as_view()),
+    re_path('uid/(?P<operation>.*)', UIDController.UIDView.as_view()),
+    re_path('history/(?P<operation>.*)', HistoryUIDController.HistoryUIDView.as_view()),
+    re_path('log/(?P<operation>.*)', LogController.LogView.as_view()),
+    re_path('orderTask/(?P<operation>.*)', OrderTaskController.OrderTaskView.as_view()),
+    path('upload', FileController.UploadUIDFileView.as_view()),
+    path('download', FileController.DownloadUIDFileView.as_view()),
+    path('sales', SalesController.SalesView.as_view()),
+    path('device/online', SalesController.DeviceOnlineView.as_view()),
+
     # 日志管理系统
     url(r'^OperatingLogs/(?P<operation>.*)$', OperatingLogs.OperatingLogsView.as_view()),
     url(r'^ProcessInfo/(?P<operation>.*)$', ProcessInfo.ProcessInfoView.as_view()),

Ansjer/wsgi.py

@@ -0,0 +1,16 @@
+"""
+WSGI config for AnsjerUIDManage project.
+
+It exposes the WSGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/3.0/howto/deployment/wsgi/
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'AnsjerUIDManage.settings')
+
+application = get_wsgi_application()

Controller/FileController.py

@@ -0,0 +1,528 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import base64
+import json
+import logging
+import os
+import time
+import zipfile
+
+import xlwt
+
+from django.http import StreamingHttpResponse, HttpResponse, QueryDict
+from django.utils.decorators import method_decorator
+from django.views import View
+from django.views.decorators.csrf import csrf_exempt
+from django.db import transaction
+
+from Ansjer.config import BASE_DIR
+from Model.models import UIDModel, UserUIDModel, UserModel, LogModel, MacModel, OrderTaskModel, OrderUIDModel
+from Object.RedisObject import RedisObject
+from Object.TokenObject import TokenObject
+from Object.uidManageResponseObject import uidManageResponseObject
+from Service.CommonService import CommonService
+
+
+class UploadUIDFileView(View):
+
+    @method_decorator(csrf_exempt)
+    def dispatch(self, request, *args, **kwargs):
+        return super(UploadUIDFileView, self).dispatch(request, *args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+        fileName = request.FILES.get('fileName', None)
+        return self.validate(fileName, request_dict, request)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+        fileName = request.FILES.get('fileName', None)
+        return self.validate(fileName, request_dict, request)
+
+    def validate(self, fileName, request_dict, request):
+        token = request_dict.get('token', None)
+        area = request_dict.get('area', None)
+        isReset = request_dict.get('isReset', 0)
+        content = request_dict.get('fileName', None)
+        print('content')
+        print(content)
+
+        content = base64.b64decode(content).decode().strip()
+        content = content[3:(len(content) - 3)]
+        uids = content.split('\n')
+        # print(uids)
+        # print(len(uids))
+
+        response = uidManageResponseObject()
+
+        tko = TokenObject(token)
+        if tko.code != 0:
+            return response.json(tko.code)
+
+        # if not fileName and not area:
+        #     return response.json(444, 'fileName,area')
+
+        data = {}
+        duplicate = []
+        for line in uids:
+
+            if len(line) < 20:
+                continue
+
+            if data.__contains__(line):
+                duplicate.append(line)
+            else:
+                data[line] = ''
+
+        if isReset == 0:
+            return self.do_insert(data, duplicate, area, response, request, tko)
+        else:
+            return self.do_reset(data, response, area, request, tko)
+
+    @transaction.atomic
+    def do_insert(self, data, duplicate, area, response, request, token):
+        bulk = []
+        count = 0
+        add_time = int(time.time())
+        update_time = int(time.time())
+        keys = data.keys()
+
+        # 获取最新的mac
+        mac = MacModel.objects.filter().values('id', 'value', 'is_active')[0]
+        if not mac['is_active']:
+            return response.json(175)
+        # redisObject = RedisObject(db=3)
+        key = ''
+        tmpMac = mac['value']
+        savePoint = None
+        for item in keys:
+            key = item.strip()
+            # value = redisObject.get_data(key)
+            # if value is False:
+            #     # redisObject.set_data(key, '1', 600)
+            # else:
+            #     duplicate.append(key)
+            #     continue
+            bulk.append(UIDModel(
+                uid=item.strip(),
+                uid_extra='',
+                status=0,
+                add_time=add_time,
+                update_time=update_time,
+                area=area,
+                mac=mac['value']
+            ))
+            try:
+                try:
+                    if (count % 5000) == 0:
+                        savePoint = transaction.savepoint()
+                        UIDModel.objects.bulk_create(bulk)
+                        bulk.clear()
+                        data = {
+                            'value': mac['value'],
+                            'is_active': tmpMac is not None
+                        }
+                        MacModel.objects.filter().update(**data)
+                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(174, str(e))
+                else:
+                    savePoint = None
+            except Exception as e:
+                # print('--------------------------error 5001')
+                # print(repr(e))
+                return response.json(174, str(e))
+            count += 1
+            tmpMac = CommonService.updateMac(mac['value'])
+            if tmpMac is None:
+                # 能分配的mac已用完
+                break
+            else:
+                mac['value'] = tmpMac
+
+        # 当bulk不足5000时，还有数据要插入
+        try:
+            try:
+                savePoint = transaction.savepoint()  # 事务保存点
+                if len(bulk) > 0:
+                    UIDModel.objects.bulk_create(bulk)
+                    bulk.clear()
+            except Exception as e:
+                # print('--------------------------error')
+                # print(repr(e))
+                if savePoint:
+                    transaction.rollback(savePoint)
+                return response.json(174)
+            else:
+                del data
+                del bulk
+                data = {
+                    'value': mac['value'],
+                    'is_active': tmpMac is not None
+                }
+                MacModel.objects.filter().update(**data)
+        except Exception as e:
+            # print('--------------------------error 1111')
+            # print(repr(e))
+            return response.json(174)
+
+        # print('重复：')
+        # print(duplicate)
+
+        operation = self.formatOperation(operation='上传', quantity=int(count), area=int(area))
+        print(operation)
+        self.add_log(request, operation, token)
+
+        if tmpMac is None:
+            return response.json(175, {'last_uid': key})
+        return response.json(0, {'count': count, 'duplicate_count': len(duplicate), 'data': duplicate})
+
+    def do_reset(self, data, response, area, request, token):
+        keys = data.keys()
+        uids = []
+        count = 0
+        for key in keys:
+            uids.append(key.strip())
+            if len(uids) % 5000 == 0:
+                count += self.do_update_uid_status(uids, area)
+                uids.clear()
+
+        if len(uids) > 0:
+            count += self.do_update_uid_status(uids, area)
+            uids.clear()
+
+        operation = self.formatOperation('重置', int(count), int(area))
+        self.add_log(request, operation, token)
+        return response.json(0)
+
+    def do_update_uid_status(self, uids, area):
+        uid_qs = UIDModel.objects.filter(uid__in=uids, area=area, status=2)
+        if uid_qs.exists():
+            uid_ids = []
+            for uid in uid_qs:
+                if uid.status == 2:
+                    uid.status = 1
+                    uid_ids.append(uid.id)
+            UIDModel.objects.bulk_update(uid_qs, fields=['status'])
+
+            try:
+                OrderUIDModel.objects.filter(uid__id__in=tuple(uid_ids)).delete()
+            except Exception as e:
+                print(e)
+
+            return uid_qs.count()
+        return 0
+
+    def add_log(self, request, operation, token):
+        ip = CommonService.get_ip_address(request)
+        now_time = time.time()
+        content = json.loads(json.dumps(request.POST))
+        user_qs = UserModel.objects.filter(id=token.userID)
+
+        if content.__contains__('fileName'):
+            del content['fileName']
+        log = {
+            'status': 200,
+            'content': json.dumps(content),
+            'ip': ip,
+            'time': now_time,
+            'url': 'upload',
+            'operation': operation,
+            'user': user_qs[0]
+        }
+
+        try:
+            LogModel.objects.create(**log)
+        except Exception as e:
+            print('出错')
+            print(repr(e))
+
+    def formatOperation(self, operation, quantity, area):
+        str = '{operation}{quantity}个{area}UID'
+        if area == 0:
+            return str.format(operation=operation, quantity=quantity, area='国内')
+        else:
+            return str.format(operation=operation, quantity=quantity, area='国外')
+
+
+class DownloadUIDFileView(View):
+
+    @method_decorator(csrf_exempt)
+    def dispatch(self, request, *args, **kwargs):
+        return super(DownloadUIDFileView, self).dispatch(request, *args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+        return self.validate(request_dict)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+        return self.validate(request_dict)
+
+    def validate(self, request_dict):
+        token = request_dict.get('token', None)
+        area = request_dict.get('area', None)
+        quantity = int(request_dict.get('quantity', None))
+        fileType = request_dict.get('fileType', None)
+        order_number = request_dict.get('order_number', None)
+        board = request_dict.get('board', None)
+        plan = request_dict.get('plan', None)
+        checksum = request_dict.get('checksum', None)
+        ic_model = request_dict.get('ic_model', None)
+        order_quantity = request_dict.get('order_quantity', None)
+        response = uidManageResponseObject()
+
+        # print(area)
+        # print(quantity)
+        token = TokenObject(token)
+        if token.code != 0:
+            return response.json(token.code)
+
+        if not area or not order_number or not board or not plan or not checksum or not ic_model or not order_quantity or not fileType:
+            return response.json(444)
+
+        area = int(area)
+
+        if area >= 0 and quantity > 0:
+
+            # 保存订单信息
+            now_time = int(time.time())
+            order = {
+                'order_number': order_number,
+                'board': board,
+                'plan': plan,
+                'checksum': checksum,
+                'ic_model': ic_model,
+                'quantity': order_quantity,
+                'add_time': now_time
+            }
+
+            tmp = OrderTaskModel.objects.create(**order)
+            print(tmp)
+
+            order = OrderTaskModel.objects.filter(order_number=order_number).order_by('-add_time')[0]
+
+            uid_qs = UserUIDModel.objects.filter(user__id=token.userID, uid__status=1, uid__area=area)
+
+            uid_values = uid_qs.values('uid__id', 'uid__uid', 'uid__mac', 'uid__uid_extra', 'uid__add_time', 'uid__update_time', 'uid__area')
+
+            count = uid_values.count()
+            if count < quantity:
+                return response.json(444, '设备UID不足')
+
+            if uid_values.exists():
+
+                uid_values = uid_values[0:quantity]
+                uid_qs = uid_qs[0: quantity]
+                if fileType == 'txt':
+                    # return self.download_txt(uid_values, uid_qs, order)
+                    # return self.download_excel(uid_values, order)
+                    return self.download_zip(uid_values, order)
+                elif fileType == 'excel':
+                    return self.download_excel(uid_values, order)
+                else:
+                    return response.json(444, 'fileType')
+            else:
+                return response.json(444, '111')
+        else:
+            return response.json(444, '222')
+
+    def download_txt(self, uid_values, uid_qs, order):
+        updates = []
+        updates_uid = []
+        content = ''
+        now_time = int(time.time())
+        for i in range(len(uid_values)):
+            # print(item)
+            item = uid_values[i]
+            mac: str = item['uid__mac']
+            index = mac.rfind(':')
+            tmp = mac[0:index] + '\t' + mac[index:]
+            content += tmp + '\t'
+            content += item['uid__uid'].strip()
+            content += '\r\n'
+            uidModel = UIDModel(
+                id=item['uid__id'],
+                uid=item['uid__uid'],
+                mac=item['uid__mac'],
+                uid_extra=item['uid__uid_extra'],
+                status=2,
+                add_time=item['uid__add_time'],
+                update_time=now_time,
+                area=item['uid__area']
+            )
+            updates.append(uidModel)
+
+            order_uid = OrderUIDModel(uid=uidModel, order=order, add_time=now_time, update_time=now_time)
+            updates_uid.append(order_uid)
+
+            if len(updates) % 5000 == 0:
+                UIDModel.objects.bulk_update(updates, fields=["status"])
+                OrderUIDModel.objects.bulk_create(updates_uid)
+                updates.clear()
+                updates_uid.clear()
+            # print(item['uid__uid'])
+
+        if len(updates) > 0:
+            UIDModel.objects.bulk_update(updates, fields=["status"])
+            OrderUIDModel.objects.bulk_create(updates_uid)
+            updates.clear()
+            updates_uid.clear()
+
+        del updates
+        del updates_uid
+        content = content[0:len(content) - 1]
+        response = StreamingHttpResponse(content)
+        response['Content-Type'] = 'application/octet-stream'
+        response['Content-Disposition'] = 'attachment;filename=UID'+time.strftime('-%Y-%m-%d-%H-%M-%S', time.localtime()) + '.txt'
+        return response
+
+    def download_excel(self, uid_qs, order):
+        response = HttpResponse(content_type='application/vnd.ms-excel')
+        response['Content-Disposition'] = 'attachment; filename=UID' + time.strftime('-%Y-%m-%d-%H-%M-%S',
+                                                                                     time.localtime()) + '.xls'
+        workbook = xlwt.Workbook(encoding='utf-8')
+        sheet1 = workbook.add_sheet('UID')
+        # row1 = [u'设备UID']
+        # for i in range(0, len(row1)):
+        #     sheet1.write(0, i, row1[i])
+
+        num = 1
+        updates = []
+        updates_uid = []
+        now_time = int(time.time())
+        for item in uid_qs:
+            uid = item['uid__uid']
+            mac = item['uid__mac']
+            index = mac.rfind(':')
+            sheet1.write(num, 0, mac[0:index])
+            sheet1.write(num, 1, mac[index:])
+            sheet1.write(num, 2, uid)
+            num += 1
+            uidModel = UIDModel(
+                id=item['uid__id'],
+                uid=item['uid__uid'],
+                mac=item['uid__mac'],
+                uid_extra=item['uid__uid_extra'],
+                status=2,
+                add_time=item['uid__add_time'],
+                update_time=now_time,
+                area=item['uid__area']
+            )
+            updates.append(uidModel)
+
+            order_uid = OrderUIDModel(uid=uidModel, order=order, add_time=now_time, update_time=now_time)
+            updates_uid.append(order_uid)
+
+            if len(updates) % 5000 == 0:
+                UIDModel.objects.bulk_update(updates, fields=["status"])
+                OrderUIDModel.objects.bulk_create(updates_uid)
+                updates.clear()
+                updates_uid.clear()
+            # print(item['uid__uid'])
+
+        if len(updates) > 0:
+            UIDModel.objects.bulk_update(updates, fields=["status"])
+            OrderUIDModel.objects.bulk_create(updates_uid)
+            updates.clear()
+            updates_uid.clear()
+
+        UIDModel.objects.bulk_update(updates, fields=["status"])
+        workbook.save(response)
+        return response
+
+    def download_zip(self, uid_qs, order):
+        dir_name = 'static/' + time.strftime('%Y_%m_%d_%H_%M_%S', time.localtime())
+        path = '/'.join((BASE_DIR, dir_name)).replace('\\', '/') + '/'
+        if not os.path.exists(path):
+            os.mkdir(path)
+
+        filename = time.strftime('_%Y_%m_%d_%H_%M_%S', time.localtime())
+        txt_filename = 'UID' + filename + '.txt'
+        excel_filename = 'UID' + filename + '.xls'
+
+        txt_file = open(path + txt_filename, 'w+')
+        workbook = xlwt.Workbook(encoding='utf-8')
+        sheet1 = workbook.add_sheet('UID')
+        num = 1
+
+        updates = []
+        updates_uid = []
+        content = ''
+        now_time = int(time.time())
+        for i in range(len(uid_qs)):
+            # print(item)
+            item = uid_qs[i]
+            uid = item['uid__uid']
+            mac = item['uid__mac']
+            index = mac.rfind(':')
+            tmp = mac[0:index] + '\t' + mac[index:]
+            content += tmp + '\t'
+            content += item['uid__uid'].strip()
+            content += '\r\n'
+
+            sheet1.write(num, 0, mac[0:index])
+            sheet1.write(num, 1, mac[index:])
+            sheet1.write(num, 2, uid)
+            num += 1
+
+            uidModel = UIDModel(
+                id=item['uid__id'],
+                uid=item['uid__uid'],
+                mac=item['uid__mac'],
+                uid_extra=item['uid__uid_extra'],
+                status=2,
+                add_time=item['uid__add_time'],
+                update_time=now_time,
+                area=item['uid__area']
+            )
+            updates.append(uidModel)
+
+            order_uid = OrderUIDModel(uid=uidModel, order=order, add_time=now_time, update_time=now_time)
+            updates_uid.append(order_uid)
+
+            if len(updates) % 5000 == 0:
+                UIDModel.objects.bulk_update(updates, fields=["status"])
+                OrderUIDModel.objects.bulk_create(updates_uid)
+                updates.clear()
+                updates_uid.clear()
+            # print(item['uid__uid'])
+
+        if len(updates) > 0:
+            UIDModel.objects.bulk_update(updates, fields=["status"])
+            OrderUIDModel.objects.bulk_create(updates_uid)
+            updates.clear()
+            updates_uid.clear()
+
+        del updates
+        del updates_uid
+        content = content[0:len(content) - 1]
+        txt_file.write(content)
+        txt_file.close()
+
+        workbook.save(path + excel_filename)
+
+        zip_name = path[0:path.rfind('/')] + '.zip'
+        return self.get_zip(path, os.listdir(path), zip_name)
+
+    def get_zip(self, path, files, zip_name):
+        zp = zipfile.ZipFile(zip_name, 'w', zipfile.ZIP_DEFLATED)
+        for file in files:
+            zp.write(filename=(path + file), arcname=str(file))
+        zp.close()
+
+        response = StreamingHttpResponse(open(zip_name, 'rb'))
+        response['content_type'] = "application/octet-stream"
+        response['Content-Disposition'] = 'attachment; filename=UID' + time.strftime('_%Y_%m_%d_%H_%M_%S',
+                                                                                     time.localtime()) + '.zip'
+        return response
+

Controller/HistoryUIDController.py

@@ -0,0 +1,402 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import json
+import logging
+import time
+
+from django.db import transaction
+from django.http import StreamingHttpResponse
+from django.utils.decorators import method_decorator
+from django.views import View
+from django.views.decorators.csrf import csrf_exempt
+from django.db.models import Avg,Max,Min,Count,Sum, Q  #   引入函数
+
+from Model.models import UIDModel, UserModel, UserUIDModel, HistoryUIDModel
+from Object.RedisObject import RedisObject
+from Object.uidManageResponseObject import uidManageResponseObject
+from Object.TokenObject import TokenObject
+from Service.ModelService import ModelService
+
+
+class HistoryUIDView(View):
+
+    @method_decorator(csrf_exempt)
+    def dispatch(self, request, *args, **kwargs):
+        return super(HistoryUIDView, self).dispatch(request, *args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+        operation = kwargs.get('operation')
+        return self.validate(request_dict, operation)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+        operation = kwargs.get('operation')
+        return self.validate(request_dict, operation)
+
+    def validate(self, request_dict, operation):
+        token = request_dict.get('token', None)
+        response = uidManageResponseObject()
+
+        token = TokenObject(token)
+        if token.code != 0:
+            return response.json(token.code)
+
+        if operation == 'quantity':
+            return self.do_quantity(request_dict, response)
+        elif operation == 'remove':
+            return self.do_remove(request_dict, response)
+        elif operation == 'download':
+            return self.download_txt(token, response)
+        elif operation == 'list':
+            return self.do_list(request_dict, response)
+        elif operation == 'delete':
+            return self.do_delete(token.userID, request_dict, response)
+        elif operation == 'batchDelete':
+            return self.do_batch_delete(token.userID, request_dict, response)
+        elif operation == 'adminUpdate':
+            return self.do_admin_update(token.userID, request_dict, response)
+        else:
+            return response.json(309)
+
+    # 查询当前可用的UID的数量
+    def do_quantity(self, request_dict, response):
+        token = request_dict.get('token', None)
+
+        token = TokenObject(token)
+        if token.code != 0:
+            return response.json(token.code)
+
+        user_qs = UserModel.objects.filter(id=token.userID)
+        if user_qs.exists():
+            user = user_qs[0]
+            if user.permission == '0':
+                return self.do_admin_quantity(request_dict, response, user.username)
+            else:
+                return self.do_not_admin_quantity(request_dict, response, user.username)
+        else:
+            return response.json(9)
+
+    # 管理员的查询UID数量操作
+    def do_admin_quantity(self, request_dict, response, admin):
+        datas = []
+        domestic = HistoryUIDModel.objects.filter(area=0, status=0).count()
+        foreign = HistoryUIDModel.objects.filter(area=1, status=0).count()
+        item = {}
+        item['isAdmin'] = 1
+        item['domestic'] = domestic
+        item['foreign'] = foreign
+        item['username'] = admin
+        datas.append(item)
+
+        user_qs = UserModel.objects.filter(~Q(Q(permission='0')))
+        for user in user_qs:
+            item = {'isAdmin': 0}
+            result = UserUIDModel.objects.filter(user__id=user.id, uid__status=1, uid__area=0).aggregate(num=Count('uid__status'))
+            item['domestic'] = result['num']
+            result = UserUIDModel.objects.filter(user__id=user.id, uid__status=1, uid__area=1).aggregate(num=Count('uid__status'))
+            item['foreign'] = result['num']
+            item['username'] = user.username
+            datas.append(item)
+
+        return response.json(0, {'data': datas})
+
+    # 非管理员的查询UID数量操作
+    def do_not_admin_quantity(self, request_dict, response, username):
+        user_qs = UserModel.objects.filter(username=username)
+        if user_qs.exists():
+            user = user_qs[0]
+            datas = []
+            item = {'isAdmin': 0}
+            result = UserUIDModel.objects.filter(user__id=user.id, uid__status=1, uid__area=0).aggregate(num=Count('uid__status'))
+            item['domestic'] = result['num']
+            result = UserUIDModel.objects.filter(user__id=user.id, uid__status=1, uid__area=1).aggregate(num=Count('uid__status'))
+            item['foreign'] = result['num']
+            item['username'] = user.username
+            datas.append(item)
+            return response.json(0, {'data': datas})
+        else:
+            return response.json(444)
+
+    # 分配UID
+    @transaction.atomic
+    def do_allot(self, request_dict, response):
+        username = request_dict.get('username', None)
+        quantity = int(request_dict.get('quantity', None))
+        area = request_dict.get('area', None)
+        token = request_dict.get('token', None)
+
+        token = TokenObject(token)
+        if token.code != 0:
+            return response.json(token.code)
+        user = UserModel.objects.get(id=token.userID)
+
+        if not user or '0' not in user.permission:
+            return response.json(404)
+
+        # 要分配的对象
+        allot_user_qs = UserModel.objects.filter(username=username)
+        if not allot_user_qs.exists():
+            return response.json(444, 'username')
+
+        # 取出对应区域可用的UID分配给allot_user
+        uid_qs = HistoryUIDModel.objects.filter(area=area, status=0)
+        count = uid_qs.count()
+        if count < quantity:
+            return response.json(444, '设备UID不足')
+
+        updates = []
+        datas = []
+        count = 0
+        if uid_qs.exists():
+            uid_qs = uid_qs[0:quantity]
+            now_time = int(time.time())
+            savePoint = transaction.savepoint()
+            for item in uid_qs:
+                item.status = 1
+                item.update_time = time.time()
+                user_uid = UserUIDModel()
+                user_uid.uid = item
+                user_uid.user = allot_user_qs[0]
+                user_uid.add_time = now_time
+                user_uid.update_time = now_time
+                datas.append(user_uid)
+                updates.append(item)
+
+                if len(datas) % 5000 == 0:
+                    result = self.do_update(datas, updates, savePoint)
+                    if result != 0:
+                        return response.json(result)
+
+            if len(datas) > 0:
+                result = self.do_update(datas, updates, savePoint)
+                if result != 0:
+                    return response.json(result)
+            redisObject = RedisObject()
+            values = uid_qs.values('uid')
+            print(values)
+            redisObject.set_data(key=token.token, val=json.dumps(list(values)), expire=3600)
+            del datas
+            del updates
+            return response.json(0)
+        else:
+            return response.json(444)
+
+    def do_update(self, datas, updates, savePoint, count=0):
+        try:
+            try:
+                if count == 2:
+                    raise Exception("Invalid level!")
+                UserUIDModel.objects.bulk_create(datas)
+                HistoryUIDModel.objects.bulk_update(updates, fields=['status', 'update_time'])
+                datas.clear()
+                updates.clear()
+            except Exception as e:
+                if savePoint:
+                    transaction.savepoint_rollback(savePoint)
+                djangoLogger = logging.getLogger('django')
+                djangoLogger.exception(repr(e))
+                return 174
+        except Exception as e:
+            return 174
+        return 0
+
+    # 把UID表中的数据移动到HistoryUID表中
+    def do_remove(self, request_dict, response):
+        token = TokenObject(request_dict.get('token', None))
+        id = request_dict.get('id', None)
+        start = request_dict.get('start', None)
+        stop = request_dict.get('stop', None)
+
+        if token.code != 0:
+            return response.json(token.code)
+
+        # 通过userID查找用户，判断是否是管理员
+        user_qs = UserModel.objects.filter(id=token.userID)
+        if user_qs.exists():
+            user = user_qs[0]
+            if user.permission != '0':
+                return response.json(404)
+        else:
+            return response.json(9)
+
+        if id:
+            return self.do_remove_by_id(id, response)
+        elif start and stop:
+            return self.do_bulk_remove(int(start), int(stop), response)
+        else:
+            return response.json(444, 'id,start,stop')
+
+    # 移除单条UID记录，id：记录id
+    def do_remove_by_id(self, id, response):
+        id = int(id)
+        uid_qs = HistoryUIDModel.objects.filter(id=id)
+        if not uid_qs.exists():
+            return response.json(173)
+
+        uid = uid_qs[0]
+        if uid:
+            data = {
+                'uid': uid.uid,
+                'uid_extra': uid.uid_extra,
+                'status': uid.status,
+                'add_time': uid.add_time,
+                'update_time': uid.update_time,
+                'area': uid.area
+            }
+            HistoryUIDModel.objects.create(**data)
+            uid.delete()
+            return response.json(0)
+        else:
+            return response.json(444, 'id')
+
+    # 批量移除UID记录。start：开始的UID记录的id；stop：结束的UID记录的id
+    def do_bulk_remove(self, start, stop, response):
+        uid_qs = UIDModel.objects.filter(id__range=(start, stop))
+        histories = []
+        if uid_qs.exists():
+            for item in uid_qs:
+                histories.append(HistoryUIDModel(
+                    uid=item.uid,
+                    uid_extra=item.uid_extra,
+                    status=item.status,
+                    add_time=item.add_time,
+                    update_time=item.update_time,
+                    area=item.area
+                ))
+                if len(histories) % 5000 == 0:
+                    HistoryUIDModel.objects.bulk_create(histories)
+                    histories.clear()
+            if len(histories) > 0:
+                HistoryUIDModel.objects.bulk_create(histories)
+                histories.clear()
+            uid_qs.delete()
+            return response.json(0)
+        else:
+            return response.json(173)
+
+    def download_txt(self, token, response):
+
+        redisObject = RedisObject()
+        uid_qs = redisObject.get_data(key=token.token)
+
+        if uid_qs is False:
+            return response.json(308)
+
+        uid_qs = json.loads(uid_qs)
+        content = ''
+        for item in uid_qs:
+            # print(item)
+            content += item['uid']
+            content += '\r\n'
+
+        redisObject.del_data(key=token.token)
+
+        content = content[0:len(content) - 1]
+        response = StreamingHttpResponse(content)
+        response['Content-Type'] = 'application/octet-stream'
+        filename = 'uid_need_to_set_up_push.txt'
+        response['Content-Disposition'] = 'attachment;filename=' + filename
+
+        return response
+
+    def do_list(self, request_dict, response):
+        page = request_dict.get('page', None)
+        line = request_dict.get('limit', None)
+        status = request_dict.get('status', None)
+        area = request_dict.get('area', None)
+        start_time = request_dict.get('starttime', None)
+        stop_time = request_dict.get('endtime', None)
+        uid = request_dict.get('uid', None)
+
+        if page and line:
+
+            uid_qs = HistoryUIDModel.objects.filter()
+            res = {
+                'count': 0,
+                'data': []
+            }
+
+            if uid_qs.exists():
+                page = int(page)
+                line = int(line)
+
+                start = (page - 1) * line
+                end = start + line
+
+                if uid:
+                    uid_qs = uid_qs.filter(uid=uid)
+
+                if status:
+                    uid_qs = uid_qs.filter(status=status)
+
+                if area:
+                    uid_qs = uid_qs.filter(area=area)
+
+                if start_time:
+                    uid_qs = uid_qs.filter(update_time__gte=start_time)
+
+                if stop_time:
+                    if stop_time > start:
+                        uid_qs = uid_qs.filter(update_time__lte=stop_time)
+
+                res['count'] = uid_qs.count()
+                uid_qs = uid_qs.values()[start:end]
+
+                res['data'] = list(uid_qs)
+
+            print(res)
+            return response.json(0, res)
+        else:
+            return response.json(444)
+
+    def do_delete(self, userID, request_dict, response):
+        uid = request_dict.get('uid', None)
+        user_qs = UserModel.objects.filter(id=userID)
+
+        if user_qs.exists():
+            user = user_qs[0]
+            if int(user.permission) != 0:
+                return response.json(309)
+
+            HistoryUIDModel.objects.filter(uid=uid).delete()
+            return response.json(0)
+        else:
+            return response.json(309)
+
+    def do_batch_delete(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        uids = request_dict.get('uidlist', None)
+
+        if uids:
+            uids = json.loads(uids)
+            HistoryUIDModel.objects.filter(uid__in=uids).delete()
+            return response.json(0)
+        else:
+            return response.json(444)
+
+    def do_admin_update(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        uid = request_dict.get('uid', None)
+        content = request_dict.get('content', None)
+
+        if uid and content:
+            content = json.loads(content)
+            print(content)
+            content['update_time'] = int(time.time())
+            uid_qs = HistoryUIDModel.objects.filter(uid=uid)
+            if uid_qs.exists():
+                uid_qs.update(**content)
+                return response.json(0)
+            else:
+                return response.json(173)
+        else:
+            return response.json(444)

Controller/LogController.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from django.utils.decorators import method_decorator
+from django.views import View
+from django.views.decorators.csrf import csrf_exempt
+
+from Model.models import LogModel
+from Object.uidManageResponseObject import uidManageResponseObject
+from Object.TokenObject import TokenObject
+
+
+class LogView(View):
+
+    @method_decorator(csrf_exempt)
+    def dispatch(self, request, *args, **kwargs):
+        return super(LogView, self).dispatch(request, *args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+        operation = kwargs.get('operation')
+        return self.validate(request_dict, operation)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+        operation = kwargs.get('operation')
+        return self.validate(request_dict, operation)
+
+    def validate(self, request_dict, operation):
+        token = TokenObject(request_dict.get('token', None))
+        response = uidManageResponseObject()
+
+        if token.code != 0:
+            return response.json(token.code)
+
+        if operation == 'query':
+            return self.do_query(request_dict, token, response)
+        elif operation == 'queryAll':
+            return self.do_query_all(request_dict, token, response)
+        elif operation == 'delete':
+            return self.do_delete(request_dict, response)
+        elif operation == 'adminQuery':
+            return self.do_admin_query(request_dict, token, response)
+        else:
+            return response.json(404)
+
+    def do_query(self, request_dict, token: TokenObject, response):
+        page = request_dict.get('page', None)
+        line = request_dict.get('line', None)
+
+        if page and line:
+            log_qs = LogModel.objects.filter(user__id=token.userID).values('id', 'operation', 'time', 'ip', 'user__username')
+            if log_qs.exists():
+                page = int(page)
+                line = int(line)
+                start = (page - 1) * line
+                count = log_qs.count()
+                data = log_qs[start:(start + line)]
+                return response.json(0, {'count': count, 'data': list(data)})
+            else:
+                return response.json(0, {'count': 0, 'data': []})
+        else:
+            return response.json(444)
+
+    def do_query_all(self, request_dict, token: TokenObject, response: uidManageResponseObject):
+        log_qs = LogModel.objects.filter(user__id=token.userID).values('id', 'operation', 'time', 'ip')
+        if log_qs.exists():
+            count = log_qs.count()
+            return response.json(0, {'count': count, 'data': list(log_qs)})
+        else:
+            return response.json(0, {'count': 0, 'data': []})
+
+    def do_delete(self, request_dict, response):
+        id = request_dict.get('id', None)
+
+        if id:
+            LogModel.objects.filter(id=id).delete()
+            return response.json(0)
+        else:
+            return response.json(444)
+
+    def do_admin_query(self, request_dict, token: TokenObject, response):
+        page = request_dict.get('page', None)
+        line = request_dict.get('limit', None)
+
+        if page and line:
+            log_qs = LogModel.objects.filter().values('id', 'operation', 'time', 'ip', 'user__username')
+            if log_qs.exists():
+                page = int(page)
+                line = int(line)
+                start = (page - 1) * line
+                count = log_qs.count()
+                data = log_qs[start:(start + line)]
+                return response.json(0, {'count': count, 'data': list(data)})
+            else:
+                return response.json(0, {'count': 0, 'data': []})
+        else:
+            return response.json(444)

Controller/OrderTaskController.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import json
+
+from django.views import View
+
+from Model.models import OrderTaskModel
+from Object.uidManageResponseObject import uidManageResponseObject
+from Object.TokenObject import TokenObject
+from Service.ModelService import ModelService
+
+
+class OrderTaskView(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 = request_dict.get('token', None)
+
+        response = uidManageResponseObject()
+        token = TokenObject(token)
+
+        if token.code != 0:
+            return response.json(0)
+
+        if operation == 'query':
+            return self.do_query(token.userID, request_dict, response)
+        elif operation == 'update':
+            return self.do_update(token.userID, request_dict, response)
+        elif operation == 'delete':
+            return self.do_delete(token.userID, request_dict, response)
+        else:
+            return response.json(404)
+
+    def do_query(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)
+
+        if page and line:
+
+            order_task_qs = OrderTaskModel.objects.filter()
+            res = {
+                'count': 0,
+                'data': []
+            }
+            if order_task_qs.exists():
+                page = int(page)
+                line = int(line)
+
+                res['count'] = order_task_qs.count()
+                start = (page - 1) * line
+                end = start + line
+
+                order_task_qs = order_task_qs[start:end].values()
+                res['data'] = list(order_task_qs)
+
+            return response.json(0, res)
+        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)
+        content = request_dict.get('content', None)
+        print(content)
+
+        if id and content:
+            content = json.loads(content)
+            print(content)
+            OrderTaskModel.objects.filter(id=id).update(**content)
+            return response.json(0)
+        else:
+            return response.json(444)
+
+    def do_delete(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)
+
+        if id:
+            OrderTaskModel.objects.filter(id=id).delete()
+            return response.json(0)
+        else:
+            return response.json(444)

Controller/SalesController.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import datetime
+import json
+import random
+
+from django.utils.decorators import method_decorator
+from django.views import View
+from django.views.decorators.csrf import csrf_exempt
+
+from Ansjer.config import SALES, ONLINE_DEVICE
+from Object.uidManageResponseObject import uidManageResponseObject
+
+
+class SalesView(View):
+
+    @method_decorator(csrf_exempt)
+    def dispatch(self, request, *args, **kwargs):
+        return super(SalesView, self).dispatch(request, *args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request_dict = request.GET
+        return self.validate(request_dict)
+
+    def post(self, request, *args, **kwargs):
+        request_dict = request.POST
+        return self.validate(request_dict)
+
+    def validate(self, request_dict):
+        year = request_dict.get('year', 0)
+        response = uidManageResponseObject()
+        if year:
+            year = int(year)
+            if year == 0:
+                data = SALES.copy()
+                data[2020] = self.get_last_year_data(SALES[2020])
+                return response.json(0, {'data': self.format_data(data)})
+            elif 2015 < year < 2020:
+                data = {year: SALES[year]}
+                return response.json(0, {'data': self.format_data(data)})
+            elif year == 2020:
+                data = {year: self.get_last_year_data(SALES[year])}
+                return response.json(0, {'data': self.format_data(data)})
+            else:
+                return response.json(444)
+        else:
+            return response.json(444)
+
+    def get_last_year_data(self, data):
+        result = []
+        month = datetime.datetime.now().month
+        print(month)
+        sum = 0
+        for item in data:
+            value = item['value']
+            sale = int(value[0] / 12 * month)
+            sum += sale
+
+        for item in data:
+            tmp = {}
+            tmp['name'] = item['name']
+            value = item['value']
+            sale = int(value[0] / 12 * month)
+            percent = round(sale * 100 / sum, 3)
+
+            tmpValue = []
+            tmpValue.append(sale)
+            tmpValue.append(percent)
+            tmpValue.append(value[2])
+            tmp['value'] = tmpValue
+            result.append(tmp)
+        print(result)
+        return result
+
+    def format_data(self, data: dict):
+        result = []
+        keys = data.keys()
+        for key in keys:
+            tmp = {
+                'time': key,
+                'data': data[key]
+            }
+            result.append(tmp)
+        return result
+
+
+class DeviceOnlineView(View):
+
+    @method_decorator(csrf_exempt)
+    def dispatch(self, request, *args, **kwargs):
+        return super(DeviceOnlineView, self).dispatch(request, *args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request_dict = request.GET
+        return self.validate(request_dict)
+
+    def post(self, request, *args, **kwargs):
+        request_dict = request.POST
+        return self.validate(request_dict)
+
+    def validate(self, request_dict):
+        response = uidManageResponseObject()
+        return response.json(0,{'online': random.randint((0.9 * ONLINE_DEVICE), ONLINE_DEVICE)})
+
+
+
+

Controller/UIDController.py

@@ -0,0 +1,479 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import json
+import logging
+import time
+
+from django.db import transaction
+from django.http import StreamingHttpResponse
+from django.utils.decorators import method_decorator
+from django.views import View
+from django.views.decorators.csrf import csrf_exempt
+from django.db.models import Avg,Max,Min,Count,Sum, Q  #   引入函数
+
+from Model.models import UIDModel, UserModel, UserUIDModel, HistoryUIDModel
+from Object.RedisObject import RedisObject
+from Object.uidManageResponseObject import uidManageResponseObject
+from Object.TokenObject import TokenObject
+from Service.ModelService import ModelService
+
+
+class UIDView(View):
+
+    @method_decorator(csrf_exempt)
+    def dispatch(self, request, *args, **kwargs):
+        return super(UIDView, self).dispatch(request, *args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+        operation = kwargs.get('operation')
+        return self.validate(request_dict, operation)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+        operation = kwargs.get('operation')
+        return self.validate(request_dict, operation)
+
+    def validate(self, request_dict, operation):
+        token = request_dict.get('token', None)
+        response = uidManageResponseObject()
+
+        token = TokenObject(token)
+        if token.code != 0:
+            return response.json(token.code)
+
+        if operation == 'quantity':
+            return self.do_quantity(request_dict, response)
+        elif operation == 'allot':
+            return self.do_allot(request_dict, response)
+        elif operation == 'remove':
+            return self.do_remove(request_dict, response)
+        elif operation == 'download':
+            return self.download_txt(token, response)
+        elif operation == 'download_1':
+            return self.download_txt_two(token, response)
+        elif operation == 'list':
+            return self.do_list(request_dict, response)
+        elif operation == 'delete':
+            return self.do_delete(token.userID, request_dict, response)
+        elif operation == 'batchDelete':
+            return self.do_batch_delete(token.userID, request_dict, response)
+        elif operation == 'adminUpdate':
+            return self.do_admin_update(token.userID, request_dict, response)
+        elif operation == 'history':
+            return self.do_history(token.userID, request_dict, response)
+        elif operation == 'statistics':
+            return self.do_admin_statistics(token.userID, request_dict, response)
+        else:
+            return response.json(309)
+
+    # 查询当前可用的UID的数量
+    def do_quantity(self, request_dict, response):
+        token = request_dict.get('token', None)
+
+        token = TokenObject(token)
+        if token.code != 0:
+            return response.json(token.code)
+
+        user_qs = UserModel.objects.filter(id=token.userID)
+        if user_qs.exists():
+            user = user_qs[0]
+            if user.permission == '0':
+                return self.do_admin_quantity(request_dict, response, user.username)
+            else:
+                return self.do_not_admin_quantity(request_dict, response, user.username)
+        else:
+            return response.json(9)
+
+    # 管理员的查询UID数量操作
+    def do_admin_quantity(self, request_dict, response, admin):
+        datas = []
+        domestic = UIDModel.objects.filter(area=0, status=0).count()
+        foreign = UIDModel.objects.filter(area=1, status=0).count()
+        item = {}
+        item['isAdmin'] = 1
+        item['domestic'] = domestic
+        item['foreign'] = foreign
+        item['username'] = admin
+        datas.append(item)
+
+        user_qs = UserModel.objects.filter(~Q(Q(permission='0')))
+        for user in user_qs:
+            item = {'isAdmin': 0}
+            result = UserUIDModel.objects.filter(user__id=user.id, uid__status=1, uid__area=0).aggregate(num=Count('uid__status'))
+            item['domestic'] = result['num']
+            result = UserUIDModel.objects.filter(user__id=user.id, uid__status=1, uid__area=1).aggregate(num=Count('uid__status'))
+            item['foreign'] = result['num']
+            item['username'] = user.username
+            datas.append(item)
+
+        return response.json(0, {'data': datas})
+
+    # 非管理员的查询UID数量操作
+    def do_not_admin_quantity(self, request_dict, response, username):
+        user_qs = UserModel.objects.filter(username=username)
+        if user_qs.exists():
+            user = user_qs[0]
+            datas = []
+            item = {'isAdmin': 0}
+            result = UserUIDModel.objects.filter(user__id=user.id, uid__status=1, uid__area=0).aggregate(num=Count('uid__status'))
+            item['domestic'] = result['num']
+            result = UserUIDModel.objects.filter(user__id=user.id, uid__status=1, uid__area=1).aggregate(num=Count('uid__status'))
+            item['foreign'] = result['num']
+            item['username'] = user.username
+            datas.append(item)
+            return response.json(0, {'data': datas})
+        else:
+            return response.json(444)
+
+    # 分配UID
+    @transaction.atomic
+    def do_allot(self, request_dict, response):
+        username = request_dict.get('username', None)
+        quantity = int(request_dict.get('quantity', None))
+        area = request_dict.get('area', None)
+        token = request_dict.get('token', None)
+
+        token = TokenObject(token)
+        if token.code != 0:
+            return response.json(token.code)
+        user = UserModel.objects.get(id=token.userID)
+
+        if not user or '0' not in user.permission:
+            return response.json(404)
+
+        # 要分配的对象
+        allot_user_qs = UserModel.objects.filter(username=username)
+        if not allot_user_qs.exists():
+            return response.json(444, 'username')
+
+        # 取出对应区域可用的UID分配给allot_user
+        uid_qs = UIDModel.objects.filter(area=area, status=0)
+        count = uid_qs.count()
+        if count < quantity:
+            return response.json(444, '设备UID不足')
+
+        updates = []
+        datas = []
+        count = 0
+        if uid_qs.exists():
+            uid_qs = uid_qs[0:quantity]
+            now_time = int(time.time())
+            savePoint = transaction.savepoint()
+            for item in uid_qs:
+                item.status = 1
+                item.update_time = time.time()
+                user_uid = UserUIDModel()
+                user_uid.uid = item
+                user_uid.user = allot_user_qs[0]
+                user_uid.add_time = now_time
+                user_uid.update_time = now_time
+                datas.append(user_uid)
+                updates.append(item)
+
+                if len(datas) % 5000 == 0:
+                    result = self.do_update(datas, updates, savePoint)
+                    if result != 0:
+                        return response.json(result)
+
+            if len(datas) > 0:
+                result = self.do_update(datas, updates, savePoint)
+                if result != 0:
+                    return response.json(result)
+            redisObject = RedisObject()
+            values = uid_qs.values('uid')
+            print(values)
+            redisObject.set_data(key=token.token, val=json.dumps(list(values)), expire=3600)
+            del datas
+            del updates
+            return response.json(0)
+        else:
+            return response.json(444)
+
+    def do_update(self, datas, updates, savePoint, count=0):
+        try:
+            try:
+                UserUIDModel.objects.bulk_create(datas)
+                UIDModel.objects.bulk_update(updates, fields=['status', 'update_time'])
+                datas.clear()
+                updates.clear()
+            except Exception as e:
+                if savePoint:
+                    transaction.savepoint_rollback(savePoint)
+                djangoLogger = logging.getLogger('django')
+                djangoLogger.exception(repr(e))
+                return 174
+        except Exception as e:
+            return 174
+        return 0
+
+    # 把UID表中的数据移动到HistoryUID表中
+    def do_remove(self, request_dict, response):
+        token = TokenObject(request_dict.get('token', None))
+        id = request_dict.get('id', None)
+        start = request_dict.get('start', None)
+        stop = request_dict.get('stop', None)
+
+        if token.code != 0:
+            return response.json(token.code)
+
+        # 通过userID查找用户，判断是否是管理员
+        user_qs = UserModel.objects.filter(id=token.userID)
+        if user_qs.exists():
+            user = user_qs[0]
+            if user.permission != '0':
+                return response.json(404)
+        else:
+            return response.json(9)
+
+        if id:
+            return self.do_remove_by_id(id, response)
+        elif start and stop:
+            return self.do_bulk_remove(int(start), int(stop), response)
+        else:
+            return response.json(444, 'id,start,stop')
+
+    # 移除单条UID记录，id：记录id
+    def do_remove_by_id(self, id, response):
+        id = int(id)
+        uid_qs = UIDModel.objects.filter(id=id)
+        if not uid_qs.exists():
+            return response.json(173)
+
+        uid = uid_qs[0]
+        if uid:
+            data = {
+                'uid': uid.uid,
+                'uid_extra': uid.uid_extra,
+                'status': uid.status,
+                'add_time': uid.add_time,
+                'update_time': uid.update_time,
+                'area': uid.area
+            }
+            HistoryUIDModel.objects.create(**data)
+            uid.delete()
+            return response.json(0)
+        else:
+            return response.json(444, 'id')
+
+    # 批量移除UID记录。start：开始的UID记录的id；stop：结束的UID记录的id
+    def do_bulk_remove(self, start, stop, response):
+        uid_qs = UIDModel.objects.filter(id__range=(start, stop))
+        histories = []
+        if uid_qs.exists():
+            for item in uid_qs:
+                histories.append(HistoryUIDModel(
+                    uid=item.uid,
+                    uid_extra=item.uid_extra,
+                    status=item.status,
+                    add_time=item.add_time,
+                    update_time=item.update_time,
+                    area=item.area
+                ))
+                if len(histories) % 5000 == 0:
+                    HistoryUIDModel.objects.bulk_create(histories)
+                    histories.clear()
+            if len(histories) > 0:
+                HistoryUIDModel.objects.bulk_create(histories)
+                histories.clear()
+            uid_qs.delete()
+            return response.json(0)
+        else:
+            return response.json(173)
+
+    def download_txt(self, token, response):
+
+        redisObject = RedisObject()
+        uid_qs = redisObject.get_data(key=token.token)
+
+        if uid_qs is False:
+            return response.json(308)
+
+        uid_qs = json.loads(uid_qs)
+        content = ''
+        for item in uid_qs:
+            # print(item)
+            content += item['uid']
+            content += '\r\n'
+
+        redisObject.del_data(key=token.token)
+
+        content = content[0:len(content) - 1]
+        response = StreamingHttpResponse(content)
+        response['Content-Type'] = 'application/octet-stream'
+        filename = 'uid_need_to_set_up_push.txt'
+        response['Content-Disposition'] = 'attachment;filename=' + filename
+
+        return response
+
+    def download_txt_two(self, token, response):
+
+        uid_qs = UIDModel.objects.filter(status=1)
+
+        if not uid_qs.exists():
+            return response.json(308)
+
+        uid_qs = uid_qs.values()
+        content = ''
+        for item in uid_qs:
+            # print(item)
+            content += item['uid']
+            content += '\r\n'
+
+        content = content[0:len(content) - 1]
+        response = StreamingHttpResponse(content)
+        response['Content-Type'] = 'application/octet-stream'
+        filename = 'uid_need_to_set_up_push.txt'
+        response['Content-Disposition'] = 'attachment;filename=' + filename
+
+        return response
+
+    def do_list(self, request_dict, response):
+        page = request_dict.get('page', None)
+        line = request_dict.get('limit', None)
+        status = request_dict.get('status', None)
+        area = request_dict.get('area', None)
+        start_time = request_dict.get('starttime', None)
+        stop_time = request_dict.get('endtime', None)
+        uid = request_dict.get('uid', None)
+
+        if page and line:
+
+            uid_qs = UIDModel.objects.filter()
+            res = {
+                'count': 0,
+                'data': []
+            }
+
+            if uid_qs.exists():
+                page = int(page)
+                line = int(line)
+
+                start = (page - 1) * line
+                end = start + line
+
+                if uid:
+                    uid_qs = uid_qs.filter(uid=uid)
+
+                if status:
+                    uid_qs = uid_qs.filter(status=status)
+
+                if area:
+                    uid_qs = uid_qs.filter(area=area)
+
+                if start_time:
+                    uid_qs = uid_qs.filter(update_time__gte=start_time)
+
+                if stop_time:
+                    if stop_time > start:
+                        uid_qs = uid_qs.filter(update_time__lte=stop_time)
+
+                res['count'] = uid_qs.count()
+                uid_qs = uid_qs.values()[start:end]
+
+                res['data'] = list(uid_qs)
+
+            print(res)
+            return response.json(0, res)
+        else:
+            return response.json(444)
+
+    def do_delete(self, userID, request_dict, response):
+        uid = request_dict.get('uid', None)
+        user_qs = UserModel.objects.filter(id=userID)
+
+        if user_qs.exists():
+            user = user_qs[0]
+            if int(user.permission) != 0:
+                return response.json(309)
+
+            UIDModel.objects.filter(uid=uid).delete()
+            return response.json(0)
+        else:
+            return response.json(309)
+
+    def do_batch_delete(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        uids = request_dict.get('uidlist', None)
+
+        if uids:
+            uids = json.loads(uids)
+            UIDModel.objects.filter(uid__in=uids).delete()
+            return response.json(0)
+        else:
+            return response.json(444)
+
+    def do_admin_update(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        uid = request_dict.get('uid', None)
+        content = request_dict.get('content', None)
+        print(content)
+
+        if uid and content:
+            content = json.loads(content)
+            print(content)
+            content['update_time'] = int(time.time())
+            uid_qs = UIDModel.objects.filter(uid=uid)
+            if uid_qs.exists():
+                uid_qs.update(**content)
+                return response.json(0)
+            else:
+                return response.json(173)
+        else:
+            return response.json(444)
+
+    def do_history(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        uid_qs = UIDModel.objects.filter(status=2)
+
+        if uid_qs.exists():
+
+            uids = []
+            for uid in uid_qs:
+                uids.append(uid)
+
+                if (len(uids) % 5000) == 0:
+                    HistoryUIDModel.objects.bulk_create(uids)
+                    uids.clear()
+
+            if len(uids) > 0:
+                HistoryUIDModel.objects.bulk_create(uids)
+                uids.clear()
+
+        uid_qs.delete()
+
+        return response.json(0)
+
+    def do_admin_statistics(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        uid_not_use = UIDModel.objects.filter(status=0).count()
+
+        uid_allocated = UIDModel.objects.filter(status=1).count()
+
+        uid_has_use = UIDModel.objects.filter(status=2).count()
+
+        total = uid_not_use + uid_allocated + uid_has_use
+
+        res = {
+            'uid_not_use': uid_not_use,
+            'uid_allocated': uid_allocated,
+            'uid_has_use': uid_has_use,
+            'total': total
+        }
+
+        return response.json(0, res)
+

Controller/UIDManageUserController.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import time
+
+from django.db.models import Q
+from django.utils.decorators import method_decorator
+from django.views import View
+from django.views.decorators.csrf import csrf_exempt
+
+from Model.models import UserModel
+from Object.uidManageResponseObject import uidManageResponseObject
+from Object.TokenObject import TokenObject
+from Service.ModelService import ModelService
+
+
+class UserView(View):
+
+    @method_decorator(csrf_exempt)
+    def dispatch(self, request, *args, **kwargs):
+        return super(UserView, self).dispatch(request, *args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        # print('get')
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+        operation = kwargs.get('operation')
+        return self.validation(request_dict, operation)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+        operation = kwargs.get('operation')
+        return self.validation(request_dict, operation)
+
+    def validation(self, request_dict, operation):
+
+        if operation == 'login':
+            return self.login(request_dict)
+        elif operation == 'logout':
+            return self.logout(request_dict)
+        else:
+            token = request_dict.get('token', None)
+
+            token = TokenObject(token)
+            response = uidManageResponseObject()
+            if token.code != 0:
+                return response.json(token.code)
+
+            if operation == 'query':
+                return self.do_query(request_dict)
+            elif operation == 'modify':
+                return self.do_modify_password(request_dict)
+            elif operation == 'list':
+                return self.do_list(request_dict)
+            elif operation == 'adminAdd':
+                return self.do_admin_add(token.userID, request_dict, response)
+            elif operation == 'adminDelete':
+                return self.do_admin_delete(token.userID, request_dict, response)
+            elif operation == 'adminUpdate':
+                return self.do_admin_update(token.userID, request_dict, response)
+            elif operation == 'adminReset':
+                return self.do_admin_reset(token.userID, request_dict, response)
+            else:
+                return uidManageResponseObject().json(309)
+
+    def login(self, request_dict):
+        username = request_dict.get('username', None)
+        password = request_dict.get('password', None)
+
+        response = uidManageResponseObject()
+
+        if username is None or password is None:
+            return response.json(444)
+
+        user = UserModel.objects.filter(username=username)
+        if user.exists():
+            if user[0].password != password:
+                return response.json(99)
+            else:
+                token = TokenObject()
+                res = token.generate({'userID': user[0].id})
+                res['permission'] = user[0].permission
+                res['username'] = user[0].username
+                user[0].online = 1
+                update = {
+                    'online': 1
+                }
+                user.update(**update)
+                return response.json(0, res)
+        else:
+            return response.json(99)
+
+    def do_query(self, request_dict):
+        # print('do_query')
+        token = TokenObject(request_dict.get('token', None))
+        # page = request_dict.get('page', None)
+        # line = request_dict.get('line', None)
+        # username = request_dict.get('username', None)
+        response = uidManageResponseObject()
+
+        if token.code != 0:
+            return response.json(token.code)
+
+        # if username:
+        #     user_qs = UserModel.objects.filter(username__icontains=username)
+        #     if user_qs.exists():
+        #         users = list(user_qs.values('username'))
+        #         return response.json(0, {'data': users})
+        #     else:
+        #         return response.json(0, {'data': []})
+        # elif page and line:
+        #     print('query_page')
+        #     user_qs = UserModel.objects.filter(id=token.userID)
+        #     if user_qs.exists():
+        #         user = user_qs[0]
+        #         if user.permission == '0':
+        #             return self.do_query_pagination(int(page), int(line), response)
+        #         else:
+        #             return response.json(404)
+        #     else:
+        #         return response.json(9)
+
+        user_qs = UserModel.objects.filter(~Q(Q(permission='0'))).values('id', 'username')
+
+        return response.json(0, {'data': list(user_qs)})
+
+    def do_query_pagination(self, page, line, response):
+        # print('query start')
+        user_qs = UserModel.objects.filter().values()
+        if user_qs.exists():
+            count = user_qs.count()
+            start = (page - 1) * line
+            end = start + line
+            users = list(user_qs[start:end])
+            # print('query end')
+            return response.json(0, {'count': count, 'data': users})
+        else:
+            return response.json(0, {'count': 0, 'data': []})
+
+    def do_modify_password(self, request_dict):
+        token = request_dict.get('token', None)
+        old_password = request_dict.get('oldPassword', None)
+        new_password = request_dict.get('newPassword', None)
+        token = TokenObject(token)
+
+        response = uidManageResponseObject()
+        if token.code != 0:
+            return response.json(token.code)
+
+        if old_password and new_password:
+            user_qs = UserModel.objects.filter(id=token.userID)
+            if user_qs.exists():
+                if user_qs[0].password != old_password:
+                    return response.json(47)
+                user = {
+                    'password': new_password
+                }
+                user_qs.update(**user)
+                return response.json(0)
+            else:
+                return response.json(9)
+        else:
+            return response.json(444)
+
+    def logout(self, request_dict):
+        token = request_dict.get('token', None)
+        token = TokenObject(token)
+        response = uidManageResponseObject()
+        if token.code != 0:
+            return response.json(0)
+
+        user_qs = UserModel.objects.filter(id=token.userID)
+        if user_qs.exists():
+            user = {
+                'online': 0
+            }
+            user_qs.update(**user)
+            return response.json(0)
+        else:
+            return response.json(0)
+
+    def do_list(self, request_dict):
+        token = request_dict.get('token', None)
+
+        response = uidManageResponseObject()
+        token = TokenObject(token)
+        if token.code != 0:
+            return response.json(token.code)
+
+        page = request_dict.get('page', None)
+        line = request_dict.get('limit', None)
+
+        if page and line:
+            user_qs = UserModel.objects.filter()
+
+            res = {
+                'count': user_qs.count(),
+                'data': []
+            }
+            if user_qs.exists():
+                page = int(page)
+                line = int(line)
+
+                start = (page - 1) * line
+                end = start + line
+
+                user_qs = user_qs[start:end].values('id', 'username', 'permission', 'phone', 'login_time', 'add_time')
+
+                res['data'] = list(user_qs)
+            return response.json(0, res)
+        else:
+            return response.json(444)
+
+    def do_admin_add(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        print(request_dict)
+        username = request_dict.get('username', None)
+        password = request_dict.get('password', None)
+        phone = request_dict.get('phone', None)
+        role = request_dict.get('role', None)
+
+        if username and password and role:
+            user = UserModel()
+            user.username = username
+            user.password = password
+            user.permission = role
+            user.phone = phone
+            user.add_time = int(time.time())
+            user.save()
+            return response.json(0)
+        else:
+            return response.json(444)
+
+    def do_admin_delete(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        username = request_dict.get('username', None)
+
+        if username:
+            user_qs = UserModel.objects.filter(username=username)
+            if user_qs.exists():
+                user_qs.delete()
+                return response.json(0)
+            else:
+                return response.json(9)
+        else:
+            return response.json(444)
+
+    def do_admin_update(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        username = request_dict.get('username', None)
+        role = request_dict.get('role', None)
+        password = request_dict.get('password', None)
+        phone = request_dict.get('phone', None)
+
+        if username:
+            update_data = {}
+
+            if role:
+                update_data['permission'] = role
+
+            if password:
+                update_data['password'] = password
+
+            if phone:
+                update_data['phone'] = phone
+
+            UserModel.objects.filter(username=username).update(**update_data)
+            return response.json(0)
+        else:
+            return response.json(444)
+
+    def do_admin_reset(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        username = request_dict.get('username', None)
+
+        if username:
+            user_qs = UserModel.objects.filter(username=username)
+            if user_qs.exists():
+                user_qs.update(password='123456')
+                return response.json(0)
+            else:
+                return response.json(9)
+        else:
+            return response.json(444)

Model/models.py

@@ -1288,4 +1288,136 @@ class EquipmentLogModel(models.Model):
     class Meta:
         db_table = 'equipment_log'
         verbose_name = '设备日志表'
-        verbose_name_plural = verbose_name
+        verbose_name_plural = verbose_name
+
+
+class UserModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    username = models.CharField(unique=True, max_length=128, null=False, verbose_name='用户名')
+    password = models.CharField(max_length=128, null=False, verbose_name='密码')
+    permission = models.CharField(max_length=24, null=False, verbose_name='权限')
+    login_time = models.IntegerField(blank=True, default=0, verbose_name='登录时间')
+    online = models.SmallIntegerField(default=0, verbose_name='是否在线')
+    phone = models.CharField(max_length=11, default='', verbose_name='手机号')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+
+    class Meta:
+        verbose_name = '用户表'
+        verbose_name_plural = verbose_name
+        db_table = 'user'
+
+
+class UIDModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    uid = models.CharField(max_length=20, null=False, db_index=True, unique=True, verbose_name='设备id')
+    mac = models.CharField(max_length=17, null=False, default='', verbose_name='设备id对应的mac地址')
+    uid_extra = models.TextField(default='', verbose_name='uid的额外描述')
+    status = models.SmallIntegerField(default=0, verbose_name='使用状态')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+    update_time = models.IntegerField(default=0, verbose_name='更新时间')
+    area = models.SmallIntegerField(default=0, verbose_name='区域')  #0：国内；1：国外
+
+    class Meta:
+        ordering = ('-add_time',)
+        verbose_name = 'uid表'
+        verbose_name_plural = verbose_name
+        db_table = 'uid'
+
+
+class UserUIDModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    user = models.ForeignKey(UserModel, to_field='id', on_delete=models.CASCADE, verbose_name='关联用户表id')
+    uid = models.ForeignKey(UIDModel, to_field='id', on_delete=models.CASCADE, verbose_name='关联uid表id')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+    update_time = models.IntegerField(default=0, verbose_name='更新时间')
+
+    class Meta:
+        verbose_name = '用户与UID的关联表'
+        verbose_name_plural = verbose_name
+        db_table = 'user_uid'
+
+
+class PermissionModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    type = models.SmallIntegerField(null=False, verbose_name='权限枚举')
+    description = models.TextField(default='', verbose_name='权限描述')
+
+    class Meta:
+        verbose_name = '权限表'
+        verbose_name_plural = verbose_name
+        db_table = 'permission'
+
+
+class LogModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    operation = models.CharField(max_length=100, default='', verbose_name='操作描述')
+    time = models.IntegerField(default=0, verbose_name='操作时间')
+    ip = models.CharField(default='', max_length=24, verbose_name='用户ip')
+    user = models.ForeignKey(UserModel, to_field='id', on_delete=models.CASCADE, verbose_name='关联用户id')
+    content = models.TextField(default='', verbose_name='请求参数')
+    status = models.IntegerField(default=0, verbose_name='请求状态')
+    url = models.CharField(max_length=150, default='', verbose_name='请求路径')
+
+    class Meta:
+        ordering = ('-time',)
+        verbose_name = '日志表'
+        verbose_name_plural = verbose_name
+        db_table = 'log'
+
+
+class HistoryUIDModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    uid = models.CharField(max_length=20, null=False, db_index=True, verbose_name='设备id')
+    uid_extra = models.TextField(default='', verbose_name='uid的额外描述')
+    status = models.SmallIntegerField(default=0, verbose_name='使用状态')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+    update_time = models.IntegerField(default=0, verbose_name='更新时间')
+    area = models.SmallIntegerField(default=0, verbose_name='区域')  # 0：国内；1：国外
+
+    class Meta:
+        verbose_name = '历史UID表'
+        verbose_name_plural = verbose_name
+        db_table = 'history_uid'
+
+
+class MacModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    value = models.CharField(max_length=17, null=False, verbose_name='最新的mac地址')
+    is_active = models.BooleanField(default=True, verbose_name='当前mac地址是否可用')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+    update_time = models.IntegerField(default=0, verbose_name='更新时间')
+
+    class Meta:
+        verbose_name = '最新的mac地址表'
+        verbose_name_plural = verbose_name
+        db_table = 'tb_mac'
+
+
+class OrderTaskModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    order_number = models.CharField(max_length=32, verbose_name='订单号')
+    board = models.CharField(max_length=32, verbose_name='主板')
+    plan = models.CharField(max_length=32, verbose_name='配置方案')
+    checksum = models.CharField(max_length=32, verbose_name='校验和')
+    ic_model = models.CharField(max_length=32, verbose_name='ic型号')
+    quantity = models.IntegerField(default=0, verbose_name='通知单上的生成数量')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+
+    class Meta:
+        db_table = 'order_task'
+        verbose_name = '订单任务表'
+        verbose_name_plural = verbose_name
+
+
+class OrderUIDModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    uid = models.ForeignKey(UIDModel, to_field='id', on_delete=models.CASCADE, verbose_name='关联uid表')
+    order = models.ForeignKey(OrderTaskModel, to_field='id', on_delete=models.CASCADE, verbose_name='关联订单任务表')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+    update_time = models.IntegerField(default=0, verbose_name='更新时间')
+
+    class Meta:
+        db_table = 'order_uid'
+        verbose_name = '订单与uid关联表'
+        verbose_name_plural = verbose_name
+

Model/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

Model/views.py

@@ -0,0 +1,3 @@
+from django.shortcuts import render
+
+# Create your views here.

Object/TokenObject.py

@@ -43,10 +43,10 @@ class TokenObject:
             self.lang = res.get('lang', None)
             self.user = res.get('user', '')
             # 刷新登录时间
-            if self.userID:
-                print(self.user)
-                redisObj = RedisObject(db=3)
-                redisObj.set_data(key=self.userID, val=self.user, expire=300)
+            # if self.userID:
+            #     print(self.user)
+            #     redisObj = RedisObject(db=3)
+            #     redisObj.set_data(key=self.userID, val=self.user, expire=300)
 
         except jwt.ExpiredSignatureError as e:
             print('过期')

Object/uidManageResponseObject.py

@@ -0,0 +1,105 @@
+from django.shortcuts import HttpResponse
+import simplejson as json
+
+
+class uidManageResponseObject(object):
+
+    def __init__(self, lang='cn'):
+        self.lang = lang
+
+    def data(self, code, res={}):
+        data_cn = {
+            0: '成功',
+            5: '请一分钟后再尝试',
+            8: '用户账号已存在',
+            9: '用户账号不存在',
+            10: res,
+            42: '两次输入的新密码错误',
+            43: '客户端服务器已关闭，请下载新版本使用',
+            44: '系统错误,发送邮件失败',
+            45: '系统错误，生成令牌出错!',
+            46: '系统错误，发送短信失败!',
+            47: '旧密码不正确',
+            74: '关联旧用户失败!',
+            79: '您已经申请过重置密码，请到邮箱进行确认！',
+            89: '您已经获得了验证码，请在10分钟后检查或再次确认。',
+            99: '账户或密码错误',
+            101: '手机的用户账号已经存在！',
+            102: '手机的用户账号不存在！',
+            103: '邮箱用户帐户已经存在！',
+            104: '邮箱用户帐户不存在！',
+            107: '用户名格式不符合规则！',
+            108: '邮箱格式不符合规则！',
+            110: '因为用户未激活，用户是无效用户！',
+            111: '您输入的密码不正确！',
+            120: '验证码已过期或不存在、请重新获得验证码！',
+            121: '验证码错了！',
+            138: '手机格式不符合规则！',
+            173: '数据不存在！',
+            174: '数据已存在',
+            175: 'mac地址已用完',
+            305: '令牌格式是错误的，相关参数是不存在的！',
+            307: '令牌已过期!',
+            308: '此次下载已失效',
+            309: '你没有权限访问',
+            404: 'You don not have permission to access this!',
+            444: '请确认参数的正确性！',
+            1112: '您输入的两次密码不一致！',
+            208: '只能预定当天的或者以后的！',
+        }
+        data_en = {
+            0: 'Success',
+            5: 'Please try again one minute later！',
+            8: 'User accounts already exist',
+            9: 'User accounts is not exist',
+            10: res,
+            42: 'The new password entered twice is incorrect',
+            43: 'The client server is closed. Please download the new version for use',
+            44: 'System error,send email fail!',
+            45: 'System error,generate token fail！',
+            46: 'System error, sending SMS failed！',
+            47: 'Old password is incorrect',
+            74: 'Failed to connect old users！',
+            79: 'You have applied for reset password, please go to email for confirmation!',
+            89: 'You have already obtained the verification code, please check it or get it again after 10 minutes.',
+            99: ' ERROR Incorrect account or password',
+            101: 'The user account of the mobile phone has already existed!',
+            102: 'The user account of the mobile phone does not exist!',
+            103: 'The mailbox user account has already existed!',
+            104: 'The mailbox user account does not exist!',
+            107: 'The username format does not conform to the rules!',
+            108: 'The mailbox format does not conform to the rules! ',
+            110: 'Because the user is not activated, the user is an invalid user!',
+            111: 'The password you entered is incorrect！',
+            120: 'The captcha has expired or does not exist, please obtain the captcha again!',
+            121: 'The verification code is wrong!',
+            138: 'The phone format does not conform to the rules! ',
+            173: 'Data does not exists!',
+            174: 'Data already exists',
+            175: 'MAC address has been used up',
+            305: 'The Token format is wrong and the related parameter is None!',
+            307: 'The Token has expired!',
+            308: 'This download has expired!',
+            309: 'You have no access',
+            404: 'You don not have permission to access this!',
+            444: 'Please confirm the correctness of the parameters!',
+            1112: 'The two passwords you entered do not match！',
+        }
+
+        if self.lang == 'cn':
+            msg = data_cn
+        else:
+            msg = data_en
+        try:
+            message = msg[code]
+        except Exception as e:
+            message = '系统错误，code不存在'
+        return {'code': code, 'msg': message, 'res': res}
+
+    def formal(self, code, res={}):
+        formal_data = self.data(code, res)
+        return json.dumps(formal_data,ensure_ascii=False)
+
+    def json(self, code, res={}):
+        result = self.formal(code, res)
+        return HttpResponse(result)

Service/CommonService.py

@@ -324,3 +324,41 @@ class CommonService:
                 if str(e) == 'day is out of range for month':
                     now_day = now_day - 1
         return timestamps
+
+    @staticmethod
+    def updateMac(mac: str):
+        macArray = mac.split(':')
+
+        macArray[0] = int(macArray[0], 16)
+        macArray[1] = int(macArray[1], 16)
+        macArray[2] = int(macArray[2], 16)
+        first = int(macArray[5], 16)
+        second = int(macArray[4], 16)
+        three = int(macArray[3], 16)
+
+        # print(macArray)
+        # print(first)
+        # print(second)
+        # print(three)
+
+        if first == 255 and second == 255 and three == 255:
+            return None
+
+        first += 1
+
+        if first / 256 == 1:
+            second += 1
+            first = first % 256
+
+        if second / 256 == 1:
+            three += 1
+            second = second % 256
+
+        macArray[3] = three
+        macArray[4] = second
+        macArray[5] = first
+        # print(macArray)
+
+        tmp = ':'.join(map(lambda x: "%02x" % x, macArray))
+        # print(tmp)
+        return tmp.upper()

Service/LogMiddleware.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import json
+import threading
+import time
+
+from django.utils.deprecation import MiddlewareMixin
+
+from Model.models import UserModel, LogModel
+from Object import TokenObject
+from Object.TokenObject import TokenObject
+from Service.CommonService import CommonService
+
+
+class LogMiddleware(MiddlewareMixin):
+
+    # def process_request(self, request):
+        # if request.path == '/upload':
+        #     request.encoding = 'utf-8'
+        #     request_dict = request.POST
+        #     print(request.POST)
+        #     request.POST = request_dict
+
+    def process_response(self, request, response):
+
+        if request.path != '/favicon.ico':
+            self.start_log_thread(request, response)
+        return response
+
+    def start_log_thread(self, request, response):
+        print('start_log_thread')
+        asy = threading.Thread(target=add_log, args=(request, response))
+        asy.start()
+
+
+def add_log(request, response):
+    request.encoding = 'utf-8'
+    if request.method == 'GET':
+        request_dict = request.GET
+    elif request.method == 'POST':
+        request_dict = request.POST
+    else:
+        return
+
+    # print(response.content.decode().strip())
+    request_path = request.path.strip().strip('/')
+    print(request_path)
+    jsonObject = {}
+    if request_path == 'download' or request_path == 'uid/download':
+        if response.status_code != 200:
+            return
+    else:
+        try:
+            jsonObject = json.loads(response.content.decode().strip())
+            code = jsonObject.get('code')
+        except Exception as e:
+            print(repr(e))
+            return
+
+        if code is None or code != 0 and response.status_code != 200:
+            print('code is {code}'.format(code=code))
+            return
+
+    token = request_dict.get('token', None)
+    # print(token)
+    token = TokenObject(token)
+
+    status = response.status_code
+    # 去除密码
+    contentDict = dict(request_dict)
+    # print(contentDict)
+    password = contentDict.get('password')
+    if password:
+        contentDict.pop('password')
+
+    content = json.dumps(contentDict)
+    ip = CommonService.get_ip_address(request)
+    now_time = time.time()
+
+    if token.code == 0:
+        user_qs = UserModel.objects.filter(id=token.userID)
+    else:
+        # print(token.code)
+        username = request_dict.get('username', None)
+        if username is None:
+            print('username')
+            return
+        user_qs = UserModel.objects.filter(username=username)
+
+    if not user_qs.exists():
+        # print('exists')
+        return
+
+    user = user_qs[0]
+    operation = ''
+    # print(request_path)
+    if request_path == 'user/login':
+        operation = '登录账号'
+    elif request_path == 'user/logout':
+        operation = '退出登录'
+    elif request_path == 'user/modify':
+        operation = '修改密码'
+    elif request_path == 'upload':
+        area = request_dict.get('area', None)
+        count = jsonObject['res']['count']
+        operation = formatOperation('上传', int(count), int(area))
+    elif request_path == 'uid/allot':
+        area = request_dict.get('area', None)
+        quantity = request_dict.get('quantity', None)
+        if area and quantity:
+            operation = formatOperation('分配', int(quantity), int(area))
+    elif request_path == 'download':
+        area = request_dict.get('area', None)
+        quantity = request_dict.get('quantity', None)
+        if area and quantity:
+            operation = formatOperation('下载', int(quantity), int(area))
+    else:
+        return
+
+    log = {
+        'status': status,
+        'content': content,
+        'ip': ip,
+        'time': now_time,
+        'url': request_path,
+        'operation': operation,
+        'user': user
+    }
+
+    try:
+        LogModel.objects.create(**log)
+    except Exception as e:
+        print(repr(e))
+
+
+def formatOperation(operation, quantity, area):
+    str = '{operation}{quantity}个{area}UID'
+    if area == 0:
+        return str.format(operation=operation, quantity=quantity, area='国内')
+    else:
+        return str.format(operation=operation, quantity=quantity, area='国外')

Service/ModelService.py

@@ -11,6 +11,22 @@ from django.db.models import Q
 
 # 针对模型封装的复用性代码
 class ModelService:
+    # UID Manage检测权限
+    @staticmethod
+    def check_perm_uid_manage(userID, permID):
+        try:
+            user_qs = UserModel.objects.filter(id=userID)
+            if user_qs.exists():
+                user = user_qs[0]
+                if int(user.permission) != 0:
+                    return False
+                else:
+                    return True
+            else:
+                return False
+        except Exception as e:
+            print(repr(e))
+
     # 获取当前用户角色名
     @staticmethod
     def getRole(rid):