UID云分配新的代码

Ansjer/push_element_into_redis.py

@@ -0,0 +1,27 @@
+import _thread
+
+from Object.RedisObject import RedisObject
+
+key = 'serial_lock'
+key1 = 'create_serial_lock'
+key2 = 'company_serial_lock'
+redisObject = RedisObject()
+
+value = redisObject.lrange(key, 0, 1)
+if len(value) == 0:
+    redisObject.rpush(key, 1)
+
+value = redisObject.lrange(key1, 0, 1)
+if len(value) == 0:
+    redisObject.rpush(key1, 1)
+
+value = redisObject.lrange(key2, 0, 1)
+if len(value) == 0:
+    redisObject.rpush(key2, 1)
+
+
+
+
+
+
+

Ansjer/urls.py

@@ -15,7 +15,8 @@ from Controller import FeedBack, EquipmentOTA, EquipmentInfo, AdminManage, AppIn
     CDKController, \
     DeviceTypeController, CloudTest, Cloudsum, IotCoreController, OperatingLogs, ProcessInfo, RegionCountryController, \
     VerifyCodeController, FileController, UIDController, LogController, SalesController, \
-    OrderTaskController, HistoryUIDController, UIDManageUserController
+    OrderTaskController, HistoryUIDController, UIDManageUserController, SerialNumberController, CompanyController, \
+    RegionController, VPGController, LanguageController, TestController
 
 urlpatterns = [
     url(r'^testApi/(?P<operation>.*)$', TestApi.testView.as_view()),
@@ -287,7 +288,14 @@ urlpatterns = [
     path('download', FileController.DownloadUIDFileView.as_view()),
     path('sales', SalesController.SalesView.as_view()),
     path('device/online', SalesController.DeviceOnlineView.as_view()),
+    re_path('serialNumber/(?P<operation>.*)', SerialNumberController.SerialNumberView.as_view()),
+    re_path('company/(?P<operation>.*)', CompanyController.CompanyView.as_view()),
+    re_path('region/(?P<operation>.*)', RegionController.RegionView.as_view()),
+    re_path('vpg/(?P<operation>.*)', VPGController.VPGView.as_view()),
+    re_path('language/(?P<operation>.*)', LanguageController.LanguageView.as_view()),
 
+
+    re_path('test/(?P<operation>.*)', TestController.TestView.as_view()),
     # 日志管理系统
     url(r'^OperatingLogs/(?P<operation>.*)$', OperatingLogs.OperatingLogsView.as_view()),
     url(r'^ProcessInfo/(?P<operation>.*)$', ProcessInfo.ProcessInfoView.as_view()),

Controller/CompanyController.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import logging
+import time
+
+from django.db import transaction
+from django.views import View
+
+from Model.models import CompanyModel, UserModel, SerialNumberModel, CompanySerialModel
+from Object.uidManageResponseObject import uidManageResponseObject
+from Object.TokenObject import TokenObject
+from Service.CommonService import CommonService
+from Service.ModelService import ModelService
+
+
+class CompanyView(View):
+
+    def get(self, request, *arg, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+        operation = kwargs.get('operation', None)
+        return self.validate(request_dict, operation)
+
+    def post(self, request, *arg, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+        operation = kwargs.get('operation', None)
+        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 == 'create':
+            return self.do_create(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)
+        elif operation == 'list':
+            return self.do_list(token.userID, request_dict, response)
+        elif operation == 'createSerial':
+            return self.do_create_serial(token.userID, request_dict, response)
+        else:
+            return response.json(404)
+
+    def do_create(self, userID, request_dict, response):
+
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        name = request_dict.get('name', None)
+        mark = request_dict.get('mark', None)
+
+        if name and mark:
+            now_time = int(time.time())
+            company_qs = CompanyModel.objects.filter(mark=mark)
+            if company_qs.exists():
+                return response.json(174)
+
+            secret = self.create_secret(mark)
+            print(secret)
+
+            company = CompanyModel(
+                name=name,
+                mark=mark,
+                secret=secret,
+                quantity=0,
+                add_time=now_time,
+                update_time=now_time
+            )
+            company.save()
+            return response.json(0)
+        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)
+
+        if id:
+            name = request_dict.get('name', None)
+            quantity = request_dict.get('quantity', None)
+
+            update = {}
+
+            if name:
+                update['name'] = name
+
+            if quantity:
+                update['quantity'] = quantity
+
+            company_qs = CompanyModel.objects.filter(id=id)
+            if company_qs.exists():
+                company_qs.update(**update)
+                return response.json(0)
+            else:
+                return response.json(173)
+
+        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:
+            CompanyModel.objects.filter(id=id).delete()
+            return response.json(0)
+        else:
+            return response.json(444)
+
+    @transaction.atomic
+    def do_create_serial(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)
+        quantity = request_dict.get('quantity', None)
+
+        if id and quantity:
+            company_qs = CompanyModel.objects.filter(id=id)
+
+            if not company_qs.exists():
+                return response.json(444)
+
+            savePoint = transaction.savepoint()
+            try:
+                try:
+
+                    company = company_qs[0]
+                    start = company.quantity
+                    end = start + int(quantity)
+                    serial_qs = SerialNumberModel.objects.filter()[start:end]
+                    if serial_qs.exists():
+                        data = []
+                        now_time = int(time.time())
+                        for item in serial_qs:
+                            data.append(CompanySerialModel(
+                                company_id=company.id,
+                                serial_number_id=item.id,
+                                add_time=now_time,
+                                update_time=now_time
+                            ))
+
+                            if len(data) == 5000:
+                                CompanySerialModel.objects.bulk_create(data)
+                                data.clear()
+                        if len(data) > 0:
+                            CompanySerialModel.objects.bulk_create(data)
+                            data.clear()
+
+                        company.quantity = company.quantity + end - start
+                        company.save()
+                        return response.json(0)
+                    else:
+                        return response.json(173)
+                except Exception as e:
+                    # print('--------------------------error 5000')
+                    # print(repr(e))
+                    if savePoint:
+                        transaction.rollback(savePoint)
+                    djangoLogger = logging.getLogger('django')
+                    djangoLogger.exception(repr(e))
+                    return response.json(176, str(e))
+            except Exception as e:
+                # print('--------------------------error 5001')
+                # print(repr(e))
+                djangoLogger = logging.getLogger('django')
+                djangoLogger.exception(repr(e))
+                return response.json(176, str(e))
+        else:
+            return response.json(444)
+
+    def do_list(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        page = request_dict.get('page', None)
+        line = request_dict.get('limit', None)
+        if page and line:
+            page = int(page)
+            line = int(line)
+
+            start = (page - 1) * line
+            end = start + line
+
+            company_qs = CompanyModel.objects.filter()
+            count = company_qs.count()
+
+            company_qs = company_qs[start: end].values()
+            print(company_qs)
+
+            res = {
+                'count': count,
+                'data': list(company_qs)
+            }
+            return response.json(0, res)
+        else:
+            return response.json(444)
+
+    def create_secret(self, mark):
+        len1 = len(mark)
+        secret = ''
+        for i in range(len1):
+            secret += CommonService.RandomStr(randomlength=1)
+            secret += mark[i]
+
+        print(mark)
+        return CommonService.encode_data_without_salt(secret)

Controller/FileController.py

@@ -46,6 +46,8 @@ class UploadUIDFileView(View):
         area = request_dict.get('area', None)
         isReset = request_dict.get('isReset', 0)
         content = request_dict.get('fileName', None)
+        vpg_id = request_dict.get('vpg_id', None)
+
         print('content')
         print(content)
 
@@ -77,12 +79,12 @@ class UploadUIDFileView(View):
                 data[line] = ''
 
         if isReset == 0:
-            return self.do_insert(data, duplicate, area, response, request, tko)
+            return self.do_insert(data, duplicate, vpg_id, 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):
+    def do_insert(self, data, duplicate, vpg_id, area, response, request, token):
         bulk = []
         count = 0
         add_time = int(time.time())
@@ -112,7 +114,8 @@ class UploadUIDFileView(View):
                 add_time=add_time,
                 update_time=update_time,
                 area=area,
-                mac=mac['value']
+                mac=mac['value'],
+                vpg_id=vpg_id
             ))
             try:
                 try:
@@ -138,6 +141,8 @@ class UploadUIDFileView(View):
             except Exception as e:
                 # print('--------------------------error 5001')
                 # print(repr(e))
+                djangoLogger = logging.getLogger('django')
+                djangoLogger.exception(repr(e))
                 return response.json(174, str(e))
             count += 1
             tmpMac = CommonService.updateMac(mac['value'])
@@ -159,6 +164,8 @@ class UploadUIDFileView(View):
                 # print(repr(e))
                 if savePoint:
                     transaction.rollback(savePoint)
+                djangoLogger = logging.getLogger('django')
+                djangoLogger.exception(repr(e))
                 return response.json(174)
             else:
                 del data
@@ -171,14 +178,20 @@ class UploadUIDFileView(View):
         except Exception as e:
             # print('--------------------------error 1111')
             # print(repr(e))
+            djangoLogger = logging.getLogger('django')
+            djangoLogger.exception(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)
+        try:
+            operation = self.formatOperation(operation='上传', quantity=int(count), area=int(area))
+            print(operation)
+            self.add_log(request, operation, token)
+        except Exception as e:
+            djangoLogger = logging.getLogger('django')
+            djangoLogger.exception(repr(e))
 
         if tmpMac is None:
             return response.json(175, {'last_uid': key})

Controller/LanguageController.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import time
+
+from django.views import View
+
+from Model.models import LanguageModel
+from Object.uidManageResponseObject import uidManageResponseObject
+from Object.TokenObject import TokenObject
+from Service.ModelService import ModelService
+
+
+class LanguageView(View):
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        operation = kwargs.get('operation', None)
+        request_dict = request.GET
+        return self.validate(request_dict, operation)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        operation = kwargs.get('operation', None)
+        request_dict = request.POST
+        return self.validate(request_dict, operation)
+
+    def validate(self, request_dict, operation):
+        token = TokenObject(request_dict.get('token', None))
+
+        response = uidManageResponseObject()
+
+        if token.code != 0:
+            return response.json(token.code)
+
+        if operation == 'add':
+            return self.do_add(token.userID, request_dict, response)
+        elif operation == 'update':
+            return self.do_update(token.userID, request_dict, response)
+        elif operation == 'getLanguage':
+            return self.do_get(request_dict, response)
+        else:
+            return response.json(404)
+
+    def do_add(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        lang = request_dict.get('lang', None)
+        lang_youdao = request_dict.get('lang_youdao', None)
+
+        if lang:
+            now_time = int(time.time())
+
+            language = LanguageModel(lang=lang, lang_youdao=lang_youdao, add_time=now_time, update_time=now_time)
+            language.save()
+            return response.json(0)
+        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)
+        if id:
+            lang = request_dict.get('lang', None)
+            lang_youdao = request_dict.get('lang_youdao', None)
+
+            update = {
+
+            }
+            if lang:
+                update['lang'] = lang
+
+            if lang_youdao:
+                update['lang_youdao'] = lang_youdao
+
+            LanguageModel.objects.filter(id=id).update(**update)
+            return response.json(0)
+        else:
+            return response.json(444)
+
+    def do_get(self, request_dict, response):
+        type = request_dict.get('type', None)
+
+        if type:
+            lang_qs = LanguageModel.objects.filter(lang=type)
+            if lang_qs.exists():
+                lang = lang_qs.values('id', 'lang', 'lang_youdao')
+
+                return response.json(0, lang)
+            else:
+                return response.json(173)
+        else:
+            return response.json(444)

Controller/RegionController.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import json
+import time
+
+from django.views import View
+
+from Model.models import RegionModel, CountryModel, LanguageModel, CountryLanguageModel
+from Object.uidManageResponseObject import uidManageResponseObject
+from Object.TokenObject import TokenObject
+from Service.CommonService import CommonService
+from Service.ModelService import ModelService
+
+
+class RegionView(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, *arg, **kwargs):
+        request.encoding = 'utf-8'
+        operation = kwargs.get('operation', None)
+        request_dict = request.POST
+        return self.validate(request_dict, operation)
+
+    def validate(self, request_dict, operation):
+        token = TokenObject(request_dict.get('token', None))
+
+        response = uidManageResponseObject()
+
+        if operation == 'getCountry':
+            return self.get_country(request_dict, response)
+        else:
+            if token.code != 0:
+                return response.json(token.code)
+
+            if operation == 'add':
+                return self.do_add(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)
+            elif operation == 'list':
+                return self.do_list(token.userID, request_dict, response)
+            elif operation == 'addCountry':
+                return self.do_add_country(token.userID, request_dict, response)
+            elif operation == 'updateCountry':
+                return self.do_update_country(token.userID, request_dict, response)
+            elif operation == 'deleteCountry':
+                return self.do_delete_country(token.userID, request_dict, response)
+            elif operation == 'listCountry':
+                return self.do_list_country(token.userID, request_dict, response)
+            else:
+                return response.json(404)
+
+    def do_add(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        name = request_dict.get('region', None)
+
+        if name:
+            region = RegionModel(name=name)
+            region.save()
+
+            return response.json(0)
+        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)
+        name = request_dict.get('region', None)
+
+        if id and name:
+            region_qs = RegionModel.objects.filter(id=id)
+            if region_qs.exists():
+                region = region_qs[0]
+                region.name = name
+                region.save()
+                return response.json(0)
+            else:
+                return response.json(173)
+        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:
+            region_qs = RegionModel.objects.filter(id=id)
+            if region_qs.exists():
+                region_qs.delete()
+                return response.json(0)
+            else:
+                return response.json(173)
+        else:
+            return response.json(444)
+
+    def do_list(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        page = request_dict.get('page', None)
+        line = request_dict.get('limit', None)
+
+        if page and line:
+            page = int(page)
+            line = int(line)
+
+            start = (page - 1) * line
+            end = start + line
+
+            region_qs = RegionModel.objects.filter()
+            count = region_qs.count()
+
+            region_qs = region_qs[start: end].values()
+
+            res = {
+                'count': count,
+                'data': list(region_qs)
+            }
+
+            return response.json(0, res)
+        else:
+            return response.json(444)
+
+    def do_add_country(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        number = request_dict.get('number', None)
+        region_id = request_dict.get('region_id', None)
+        countries = request_dict.get('countries', None)
+
+        if number and region_id and countries:
+
+            now_time = int(time.time())
+            countries = json.loads(countries)
+
+            country_qs =CountryModel.objects.filter(number=number)
+            if not country_qs.exists():
+                country = CountryModel(number=number, region_id=region_id, add_time=now_time, update_time=now_time)
+                country.save()
+            else:
+                country = country_qs[0]
+
+            for item in countries:
+                country_language_qs = CountryLanguageModel.objects.filter(language_id=item, country_id=country.id)
+                if not country_language_qs.exists():
+                    countryLanguage = CountryLanguageModel(
+                        country_name=countries[item], language_id=item, country_id=country.id, add_time=now_time, update_time=now_time)
+                    countryLanguage.save()
+            return response.json(0)
+        else:
+            return response.json(444)
+
+    def do_update_country(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        id = request_dict.get('country_id', None)
+        number = request_dict.get('number', None)
+        region_id = request_dict.get('region_id', None)
+        countries = request_dict.get('countries', None)
+
+        if id and number and region_id and countries:
+
+            country_qs = CountryModel.objects.filter(id=id)
+            if not country_qs.exists():
+                return response.json(173)
+
+            now_time = int(time.time())
+            countries = json.loads(countries)
+            country = {
+                'number': number,
+                'region_id': region_id,
+                'update_time': now_time,
+            }
+
+            country_qs.update(**country)
+
+            return response.json(0)
+        else:
+            return response.json(444)
+
+    def do_delete_country(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:
+            country_qs = CountryModel.objects.filter(id=id)
+            if country_qs.exists():
+                country_qs.delete()
+                return response.json(0)
+            else:
+                return response.json(173)
+        else:
+            return response.json(444)
+
+    def do_list_country(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        region_id = request_dict.get('region_id', None)
+        page = request_dict.get('page', None)
+        line = request_dict.get('limit', None)
+
+        if page and line:
+            page = int(page)
+            line = int(line)
+
+            start = (page - 1) * line
+            end = start + line
+
+            region_qs = CountryLanguageModel.objects.filter(language_id=1)
+            if region_id:
+                region_qs = region_qs.filter(country__region__id=region_id)
+
+            count = region_qs.count()
+
+            if region_qs.exists():
+                region_qs = region_qs[start: end].values('country_id', 'country_name', 'country__number', 'country__region__name', 'add_time', 'update_time')
+            else:
+                region_qs = []
+            res = {
+                'count': count,
+                'data': list(region_qs)
+            }
+
+            return response.json(0, res)
+        else:
+            return response.json(444)
+
+    def get_country(self, request_dict, response):
+        type = request_dict.get('type', None)
+        token = request_dict.get('token', None)
+        time_stamp = request_dict.get('time_stamp', None)
+
+        if token and time_stamp and type:
+            token = int(CommonService.decode_data(token))
+            time_stamp = int(time_stamp)
+
+            now_time = int(time.time())
+            distance = now_time - time_stamp
+
+            if token != time_stamp or distance > 300 or distance < 0:
+                return response.json(404)
+
+            lang_qs = LanguageModel.objects.filter(lang=type)
+
+            if not lang_qs.exists():
+                lang_qs = LanguageModel.objects.filter(lang='en')
+
+            lang = lang_qs[0]
+            country_qs = CountryLanguageModel.objects.filter(language_id=lang.id).values('country_name', 'country__number')
+
+            return response.json(0, list(country_qs))
+        else:
+            return response.json(444)
+
+    def get_country_info(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        country_number = request_dict.get('country_number', None)
+
+        if country_number:
+            country_language_qs = CountryLanguageModel.objects.filter(country__number=country_number)
+            if country_language_qs.exists():
+                country_language_qs = country_language_qs
+        pass

Controller/SerialNumberController.py

@@ -0,0 +1,371 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import logging
+import random
+import time
+
+from django.db import transaction
+from django.views import View
+
+from Model.models import SerialNumberModel, CompanySerialModel, UIDCompanySerialModel, CompanyModel, RegionModel, \
+    CountryModel, UIDModel
+from Object.RedisObject import RedisObject
+from Object.uidManageResponseObject import uidManageResponseObject
+from Object.TokenObject import TokenObject
+from Service.AlgorithmService import AlgorithmBaseOn35
+from Service.CommonService import CommonService
+from Service.ModelService import ModelService
+
+
+class SerialNumberView(View):
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        operation = kwargs.get('operation', None)
+        request_dict = request.GET
+        return self.validate(request_dict, operation)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        operation = kwargs.get('operation', None)
+        request_dict = request.POST
+        return self.validate(request_dict, operation)
+
+    def validate(self, request_dict, operation):
+        token = TokenObject(request_dict.get('token', None))
+        response = uidManageResponseObject()
+
+        if operation == 'getUID':
+            return self.do_get_uid(request_dict, response)
+        elif operation == 'getSerial':
+            return self.do_get_serial_number(request_dict, response)
+        else:
+            if token.code != 0:
+                return response.json(token.code)
+
+            if operation == 'create':
+                return self.do_create(request_dict, response)
+            elif operation == 'list':
+                return self.do_list(token.userID, request_dict, response)
+            elif operation == 'update':
+                return self.do_update(token.userID, request_dict, response)
+            elif operation == 'attachUID':
+                return self.do_attach_uid(request_dict, response)
+            elif operation == 'detachUID':
+                return self.do_detach_uid(token.userID, request_dict, response)
+            else:
+                return response.json(404)
+
+    def do_create(self, request_dict, response):
+        quantity = request_dict.get('quantity', None)
+
+        if quantity:
+            start_time = time.strftime('%Y-%m-%d %H:%M:%S')
+            print('start create ' + start_time)
+            quantity = int(quantity)
+            tmp = []
+            algorithm = AlgorithmBaseOn35()
+
+            sum = SerialNumberModel.objects.count()
+
+            for i in range(quantity):
+                serial_number = algorithm.getLetter(sum)
+                tmp_len = 6 - len(serial_number)
+                # 前面补0
+                for j in range(tmp_len):
+                    serial_number = '0' + serial_number
+
+                tmp.append(serial_number)
+                sum += 1
+
+            # 把序列号的顺序打乱
+            random.shuffle(tmp)
+
+            data = []
+            now_time = int(time.time())
+            for item in tmp:
+                data.append(SerialNumberModel(serial_number=item, add_time=now_time))
+
+                if len(data) == 10000:
+                    SerialNumberModel.objects.bulk_create(data)
+                    data.clear()
+
+            if len(data) > 0:
+                SerialNumberModel.objects.bulk_create(data)
+                data.clear()
+            start_time = time.strftime('%Y-%m-%d %H:%M:%S')
+            print('start create ' + start_time)
+
+            redis = RedisObject()
+            redis.del_data(key='serial_number_count')
+            return response.json(0)
+        else:
+            return response.json(444)
+
+    # 提供给pc端获取序列号
+    def do_get_serial_number(self, request_dict, response):
+        quantity = request_dict.get('quantity', None)
+        company_id = request_dict.get('company_id', None)
+        token = request_dict.get('token', None)
+        time_stamp = request_dict.get('time_stamp', None)
+
+        if token and time_stamp and quantity and company_id:
+
+            token = int(CommonService.decode_data(token))
+            time_stamp = int(time_stamp)
+
+            now_time = int(time.time())
+            distance = now_time - time_stamp
+
+            if token != time_stamp or distance > 300 or distance < 0:
+                return response.json(404)
+
+            redisObject = RedisObject()
+            key = 'serial_lock'
+            value = redisObject.lpop(key)
+            count = 0
+            while value is False and count < 5:
+                time.sleep(1)
+                value = redisObject.lpop(key)
+                count += 1
+
+            if count == 5 and value is False:
+                return response.json(5)
+
+            quantity = int(quantity)
+
+            company_serial_qs = CompanySerialModel.objects.filter(company__secret=company_id, status=0)
+            if not company_serial_qs.exists():
+                redisObject.rpush(key, value)
+                return response.json(373)
+
+            # 存在对应的企业
+            company_serial_qs = company_serial_qs[0:quantity]
+
+            company_serial_qs = company_serial_qs.values('id', 'serial_number__serial_number', 'company__mark')
+            data = []
+            ids = []
+            for serial in company_serial_qs:
+                ids.append(serial['id'])
+                data.append(serial['serial_number__serial_number'] + serial['company__mark'])
+            CompanySerialModel.objects.filter(id__in=ids).update(status=1)
+            redisObject.rpush(key, value)
+            return response.json(0, data)
+        else:
+            return response.json(444)
+
+    def do_list(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        page = request_dict.get('page', None)
+        line = request_dict.get('limit', None)
+        serial_number = request_dict.get('serial_number', None)
+        status = request_dict.get('status', None)
+
+        if page and line:
+            page = int(page)
+            line = int(line)
+
+            serial_qs = SerialNumberModel.objects.filter()
+
+            if serial_number:
+                serial_qs = serial_qs.filter(serial_number__contains=serial_number)
+
+            if status:
+                serial_qs = serial_qs.filter(status=status)
+
+            count = serial_qs.count()
+
+            start = (page - 1) * line
+            end = start + line
+
+            serial_qs = serial_qs[start: end].values()
+            res = {
+                'count': count,
+                'data': list(serial_qs)
+            }
+
+            return response.json(0, res)
+        else:
+            return response.json(444)
+
+    @transaction.atomic
+    def do_attach_uid(self, request_dict, response):
+        serial_number = request_dict.get('serial_number', None)
+        country_id = request_dict.get('country_id', None)
+        company_id = request_dict.get('company_id', None)
+
+        if serial_number and len(serial_number) == 9 and country_id and company_id:
+            mark = serial_number[6:9]
+            serial = serial_number[0:6]
+
+            savePoint = transaction.savepoint()
+            try:
+                try:
+
+                    # 判断序列号是否已和UID关联
+                    company_serial_qs = CompanySerialModel.objects.filter(company__secret=company_id,
+                                                                          serial_number__serial_number=serial)
+                    if not company_serial_qs.exists():
+                        return response.json(173)
+
+                    # 当序列号已关联UID
+                    company_serial = company_serial_qs[0]
+
+                    if company_serial.status == 0:
+                        # 该序列号未绑定企业
+                        return response.json(173)
+                    elif company_serial.status == 1:
+                        # 确定所在区域
+                        country_qs = CountryModel.objects.filter(number=country_id)
+                        if not country_qs.exists():
+                            return response.json(374)
+
+                        region = country_qs.values('region_id')[0]
+
+                        count = 0
+                        while count < 3:
+                            uid_qs = UIDModel.objects.filter(vpg__company_id=company_serial.company.id, vpg__region_id=region['region_id'],
+                                                             status=0)
+                            if uid_qs.exists():
+                                uid = uid_qs[0]
+                                print(uid)
+                                # uid.status = 2
+                                # uid.update_time = int(time.time())
+                                result = UIDModel.objects.filter(id=uid.id, status=0).update(**{
+                                    'status': 2, 'update_time': int(time.time())
+                                })
+
+                                if int(result) <= 0:
+                                    count += 1
+                                    continue
+
+                                now_time = int(time.time())
+                                uid_serial = UIDCompanySerialModel(uid_id=uid.id, company_serial_id=company_serial.id,
+                                                                   add_time=now_time, update_time=now_time)
+                                uid_serial.save()
+
+                                company_serial.status = 2
+                                company_serial.save()
+
+                                res = {
+                                    'uid': CommonService.encode_data(uid.uid),
+                                    'mac': CommonService.encode_data(uid.mac),
+                                    'extra': uid.uid_extra
+                                }
+                                return response.json(0, res)
+                            else:
+                                return response.json(375)
+
+                        return response.json(5)
+                    else:
+                        uid_qs = UIDCompanySerialModel.objects.filter(company_serial_id=company_serial.id)
+                        if uid_qs.exists():
+                            uid = uid_qs.values('uid__uid', 'uid__mac', 'uid__uid_extra')[0]
+                            res = {
+                                'uid': CommonService.encode_data(uid['uid__uid']),
+                                'mac': CommonService.encode_data(uid['uid__mac']),
+                                'extra': uid['uid__uid_extra']
+                            }
+                            return response.json(0, res)
+                        else:
+                            return response.json(173)
+                except Exception as e:
+                    # print('--------------------------error 5000')
+                    # print(repr(e))
+                    if savePoint:
+                        transaction.rollback(savePoint)
+                    djangoLogger = logging.getLogger('django')
+                    djangoLogger.exception(repr(e))
+                    return response.json(176, str(e))
+            except Exception as e:
+                # print('--------------------------error 5001')
+                # print(repr(e))
+                djangoLogger = logging.getLogger('django')
+                djangoLogger.exception(repr(e))
+                return response.json(176, str(e))
+
+        else:
+            return response.json(444)
+
+    def do_get_uid(self, request_dict, response):
+        serial_number = request_dict.get('serial_number', None)
+        token = request_dict.get('token', None)
+        time_stamp = request_dict.get('time_stamp', None)
+
+        if token and time_stamp and serial_number and len(serial_number) == 9:
+
+            token = int(CommonService.decode_data(token))
+            time_stamp = int(time_stamp)
+
+            now_time = int(time.time())
+            distance = now_time - time_stamp
+
+            if token != time_stamp or distance > 300 or distance < 0:
+                return response.json(404)
+
+            mark = serial_number[6:9]
+            serial = serial_number[0:6]
+            uid_company_serial_qs = UIDCompanySerialModel.objects.filter(company_serial__company__mark=mark, company_serial__serial_number__serial_number=serial)
+
+            if uid_company_serial_qs.exists():
+                uid = uid_company_serial_qs.values('uid__uid', 'uid__mac', 'uid__uid_extra')[0]
+
+                res = {
+                    'uid': CommonService.encode_data(uid['uid__uid']),
+                    'mac': CommonService.encode_data(uid['uid__mac']),
+                    'extra': uid['uid__uid_extra']
+                }
+
+                return response.json(0, res)
+            else:
+                return response.json(173)
+        else:
+            return response.json(444)
+
+    def do_detach_uid(self, userID, request_dict, response):
+        uid = request_dict.get('uid', None)
+
+        if uid:
+            uid = CommonService.decode_data(uid)
+            uid_serial_qs = UIDCompanySerialModel.objects.filter(uid__uid=uid)
+            if uid_serial_qs.exists():
+                uid_serial = uid_serial_qs[0]
+
+                company_serial_qs = CompanySerialModel.objects.filter(id=uid_serial.company_serial.id)
+                if company_serial_qs.exists():
+                    company_serial = company_serial_qs[0]
+                    company_serial.status = 1
+                    company_serial.save()
+
+                uid_qs = UIDModel.objects.filter(uid=uid)
+                if uid_qs.exists():
+                    uid = uid_qs[0]
+                    uid.status = 0
+                    uid.save()
+                uid_serial.delete()
+                return response.json(0)
+            else:
+                return response.json(173)
+        else:
+            return response.json(444)
+
+    def do_update(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        id = request_dict.get('id', None)
+        status = request_dict.get('status', None)
+
+        if id and status:
+            serial_number_qs = SerialNumberModel.objects.filter(id=id)
+            if serial_number_qs.exists():
+                serial_number_qs.update(**{'status': status})
+                return response.json(0)
+            else:
+                return response.json(173)
+        else:
+            return response.json(444)

Controller/TestController.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import hashlib
+
+from django.contrib.auth.hashers import make_password, check_password
+from django.views import View
+
+from Object.uidManageResponseObject import uidManageResponseObject
+
+
+class TestView(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):
+
+        response = uidManageResponseObject()
+
+        if operation == 'createPassword':
+            return self.do_create_password(request_dict, response)
+        elif operation == 'checkPassword':
+            return self.do_check_password(request_dict, response)
+        else:
+            return response.json(404)
+
+    def do_create_password(self, request_dict, response):
+        password = request_dict.get('password', None)
+        print(password)
+        result = make_password(password)
+        print(result)
+        print(check_password(password, result))
+        return response.json(0, result)
+
+    def do_check_password(self, request_dict, response):
+        password = request_dict.get('password', None)
+        password2 = request_dict.get('password2', None)
+        print(password)
+        print(password2)
+        check = check_password(password, password2)
+
+        return response.json(0, check)
+
+    # def make_password(self, password):
+    #     md5 = hashlib.md5()
+    #     md5.update(str(password).encode('utf-8'))
+    #     return md5.hexdigest()
+    #
+    # def check_password(self, password, encryp):
+    #     print(password)
+    #     print(encryp)
+    #     password1 = self.make_password(password)
+    #     print(password1)
+    #     return encryp == self.make_password(password)

Controller/VPGController.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import time
+
+from django.views import View
+
+from Model.models import RegionModel, CompanyModel, VPGModel, UIDModel
+from Object.uidManageResponseObject import uidManageResponseObject
+from Object.TokenObject import TokenObject
+from Service.ModelService import ModelService
+
+
+class VPGView(View):
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        operation = kwargs.get('operation', None)
+        request_dict = request.GET
+        return self.validate(request_dict, operation)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        operation = kwargs.get('operation', None)
+        request_dict = request.POST
+        return self.validate(request_dict, operation)
+
+    def validate(self, request_dict, operation):
+        token = TokenObject(request_dict.get('token', None))
+        response = uidManageResponseObject()
+
+        if token.code != 0:
+            return response.json(token.code)
+
+        if operation == 'add':
+            return self.do_add(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)
+        elif operation == 'list':
+            return self.do_list(token.userID, request_dict, response)
+        else:
+            return response.json(404)
+
+    def do_add(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        name = request_dict.get('vpg', None)
+        region_id = request_dict.get('region_id', None)
+        company_id = request_dict.get('company_id', None)
+
+        if name and region_id and company_id:
+            region_qs = RegionModel.objects.filter(id=region_id)
+            if not region_qs.exists():
+                return response.json(374)
+
+            company_qs = CompanyModel.objects.filter(secret=company_id)
+            if not company_qs.exists():
+                return response.json(373)
+
+            company = company_qs[0]
+            now_time = int(time.time())
+            vpgModel = VPGModel(name=name, region_id=region_id, company_id=company.id, add_time=now_time, update_time=now_time)
+            vpgModel.save()
+            return response.json(0)
+        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)
+        name = request_dict.get('vpg', None)
+        region_id = request_dict.get('region_id', None)
+        company_id = request_dict.get('company_id', None)
+
+        if id:
+            vpg_qs = VPGModel.objects.filter(id=id)
+
+            if vpg_qs.exists():
+
+                now_time = int(time.time())
+                update = {
+                    'update_time': now_time
+                }
+
+                if name:
+                    update['name'] = name
+
+                if region_id:
+                    update['region_id'] = region_id
+
+                if company_id:
+                    update['company_id'] = company_id
+
+                vpg_qs.update(**update)
+                return response.json(0)
+            else:
+                return response.json(173)
+        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:
+            vpg_qs = VPGModel.objects.filter(id=id)
+
+            if vpg_qs.exists():
+                vpg_qs.delete()
+                return response.json(0)
+            else:
+                return response.json(173)
+        else:
+            return response.json(444)
+
+    def do_list(self, userID, request_dict, response):
+        perm = ModelService.check_perm_uid_manage(userID, 0)
+        if not perm:
+            return response.json(309)
+
+        company_id = request_dict.get('company_id', None)
+        region_id = request_dict.get('region_id', None)
+        page = request_dict.get('page', None)
+        line = request_dict.get('limit', None)
+
+        if page and line:
+            page = int(page)
+            line = int(line)
+
+            start = (page - 1) * line
+            end = start + line
+
+            vpg_qs = VPGModel.objects.filter()
+
+            if company_id:
+                vpg_qs.filter(company_id=company_id)
+
+            if region_id:
+                vpg_qs.filter(region_id=region_id)
+
+            count = vpg_qs.count()
+            vpg_qs = vpg_qs[start: end]
+            vpg_qs = vpg_qs.values('id', 'name', 'region__name', 'region_id', 'company__name', 'add_time', 'update_time', 'company__secret')
+            for vpg in vpg_qs:
+                vpg['uid_count'] = UIDModel.objects.filter(vpg_id=vpg['id']).count()
+
+            res = {
+                'count': count,
+                'data': list(vpg_qs)
+            }
+
+            return response.json(0, res)
+        else:
+            return response.json(444)

Model/models.py

@@ -1308,6 +1308,45 @@ class UserModel(models.Model):
         db_table = 'user'
 
 
+class CompanyModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    name = models.CharField(max_length=64, unique=True, default='', verbose_name='企业名称')
+    mark = models.CharField(max_length=3, unique=True, default='', verbose_name='企业标志，用于序列号的后三位')
+    secret = models.CharField(max_length=10, db_index=True, default='', verbose_name='企业秘钥')
+    quantity = models.IntegerField(default=0, verbose_name='已购买的序列号的数量')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+    update_time = models.IntegerField(default=0, verbose_name='更新时间')
+
+    class Meta:
+        db_table = 'tb_company'
+        verbose_name = '企业表'
+        verbose_name_plural = verbose_name
+
+
+class RegionModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    name = models.CharField(max_length=32, default='', verbose_name='区域名称')
+
+    class Meta:
+        db_table = 'tb_region'
+        verbose_name = '区域表'
+        verbose_name_plural = verbose_name
+
+
+class VPGModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    name = models.CharField(max_length=32, default='', verbose_name='群组名称')
+    region = models.ForeignKey(RegionModel, to_field='id', on_delete=models.DO_NOTHING, verbose_name='群组用于的地区')
+    company = models.ForeignKey(CompanyModel, to_field='id', on_delete=models.DO_NOTHING, verbose_name='关联企业表')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+    update_time = models.IntegerField(default=0, verbose_name='更新时间')
+
+    class Meta:
+        db_table = 'tb_vpg'
+        verbose_name = 'vpg表'
+        verbose_name_plural = verbose_name
+
+
 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')
@@ -1317,6 +1356,7 @@ class UIDModel(models.Model):
     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：国外
+    vpg = models.ForeignKey(VPGModel, to_field='id', default=1, on_delete=models.DO_NOTHING, verbose_name='关联VPG表的id')
 
     class Meta:
         ordering = ('-add_time',)
@@ -1423,6 +1463,83 @@ class OrderUIDModel(models.Model):
         verbose_name_plural = verbose_name
 
 
+class CountryModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    number = models.IntegerField(unique=True, verbose_name='区号')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+    update_time = models.IntegerField(default=0, verbose_name='更新时间')
+    region = models.ForeignKey(RegionModel, to_field='id', on_delete=models.DO_NOTHING, verbose_name='关联区域表')
+
+    class Meta:
+        db_table = 'tb_country'
+        verbose_name = '地区表'
+        verbose_name_plural = verbose_name
+
+
+class LanguageModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    lang = models.CharField(max_length=16, default='', verbose_name='语种')
+    lang_youdao = models.CharField(max_length=16, default='', verbose_name='有道的语种')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+    update_time = models.IntegerField(default=0, verbose_name='更新时间')
+
+    class Meta:
+        db_table = 'tb_language'
+        verbose_name = '语言表'
+        verbose_name_plural = verbose_name
+
+
+class CountryLanguageModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    country_name = models.CharField(max_length=64, default='', verbose_name='国家名称')
+    language = models.ForeignKey(LanguageModel, to_field='id', on_delete=models.CASCADE, verbose_name='关联语言表的id')
+    country = models.ForeignKey(CountryModel, to_field='id', on_delete=models.CASCADE, verbose_name='关联地区表的id')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+    update_time = models.IntegerField(default=0, verbose_name='更新时间')
+
+    class Meta:
+        db_table = 'tb_country_language'
+        verbose_name = '不同语言的地区名称表'
+        verbose_name_plural = verbose_name
+
+
+class SerialNumberModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    serial_number = models.CharField(max_length=9, db_index=True, verbose_name='序列号')
+    status = models.SmallIntegerField(default=1, verbose_name='可用状态。0：不可用，1：可用')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+
+    class Meta:
+        db_table = 'tb_serial_number'
+        verbose_name = '序列号表'
+        verbose_name_plural = verbose_name
+
+
+class CompanySerialModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    company = models.ForeignKey(CompanyModel, to_field='id', on_delete=models.CASCADE, verbose_name='关联企业表的id')
+    serial_number = models.ForeignKey(SerialNumberModel, to_field='id', on_delete=models.CASCADE, verbose_name='关联序列号表的id')
+    status = models.SmallIntegerField(default=0, verbose_name='序列号的状态。0：未使用，1：已使用，2：已和UID关联')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+    update_time = models.IntegerField(default=0, verbose_name='更新时间')
+
+    class Meta:
+        db_table = 'tb_company_serial'
+        verbose_name = '企业关联序列号表'
+        verbose_name_plural = verbose_name
+
+
+class UIDCompanySerialModel(models.Model):
+    id = models.AutoField(primary_key=True)
+    uid = models.ForeignKey(UIDModel, to_field='id', on_delete=models.CASCADE, verbose_name='关联UID表')
+    company_serial = models.ForeignKey(CompanySerialModel, to_field='id', on_delete=models.CASCADE, verbose_name='关联【企业关联序列号表】的id')
+    add_time = models.IntegerField(default=0, verbose_name='添加时间')
+    update_time = models.IntegerField(default=0, verbose_name='更新时间')
+
+    class Meta:
+        db_table = 'tb_uid_company_serial'
+        verbose_name = 'UID关联【企业关联序列号】表'
+        verbose_name_plural = verbose_name
 
 
 class iotdeviceInfoModel(models.Model):

Object/uidManageResponseObject.py

@@ -38,10 +38,14 @@ class uidManageResponseObject(object):
             173: '数据不存在！',
             174: '数据已存在',
             175: 'mac地址已用完',
+            176: '数据库异常',
             305: '令牌格式是错误的，相关参数是不存在的！',
             307: '令牌已过期!',
             308: '此次下载已失效',
             309: '你没有权限访问',
+            373: '没有相应的公司',
+            374: '没有相应的地区',
+            375: 'uid不足',
             404: 'You don not have permission to access this!',
             444: '请确认参数的正确性！',
             1112: '您输入的两次密码不一致！',
@@ -77,10 +81,14 @@ class uidManageResponseObject(object):
             173: 'Data does not exists!',
             174: 'Data already exists',
             175: 'MAC address has been used up',
+            176: 'Database exception',
             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',
+            373: 'No corresponding company',
+            374: 'Region does not exist',
+            375: 'uid不足',
             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！',
@@ -94,7 +102,7 @@ class uidManageResponseObject(object):
             message = msg[code]
         except Exception as e:
             message = '系统错误，code不存在'
-        return {'code': code, 'msg': message, 'res': res}
+        return {'result_code': code, 'reason': message, 'result': res, 'error_code': code}
 
     def formal(self, code, res={}):
         formal_data = self.data(code, res)

Service/AlgorithmService.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import math
+
+
+class AlgorithmBaseOn35:
+
+    letters = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+               'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+               'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T',
+               'U', 'V', 'W', 'X', 'Y', 'Z']
+
+    len1 = len(letters)
+
+    def getLetter(self, number):
+        tmp = int(number / self.len1)
+        current = number % self.len1
+
+        if tmp >= self.len1:
+            return self.getLetter(tmp) + self.letters[current]
+        else:
+            return self.letters[tmp] + self.letters[current]
+
+    def add(self, a, b):
+        sum = a + b
+        serial_number = self.getLetter(sum)
+        return serial_number
+
+    def __findLetter(self, char):
+        for i in range(self.len1):
+            if char == self.letters[i]:
+                return i
+        return -1
+
+    def __drop0(self, text):
+        char = text[0]
+        if char == '0':
+            return self.__drop0(text[1:])
+        else:
+            return text
+
+    def to10(self, serial):
+        serial = self.__drop0(serial)
+        print(serial)
+        len1 = len(serial)
+        print(len1)
+        sum = 0
+        for char in serial:
+            tmp = self.__findLetter(char)
+            if tmp == -1:
+                return None
+            print(tmp)
+            sum += (tmp * math.pow(35, len1 - 1))
+            len1 -= 1
+        return sum

Service/CommonService.py

@@ -362,3 +362,46 @@ class CommonService:
         tmp = ':'.join(map(lambda x: "%02x" % x, macArray))
         # print(tmp)
         return tmp.upper()
+
+    @staticmethod
+    def decode_data(content, start=1, end=4):
+        try:
+            for i in range(start, end):
+                if i == 1:
+                    content = base64.b64decode(content)
+                    content = content.decode('utf-8')
+                    content = content[1:-1]
+                if i == 2:
+                    content = base64.b64decode(content)
+                    content = content.decode('utf-8')
+                    content = content[2:-2]
+                if i == 3:
+                    content = base64.b64decode(content)
+                    content = content.decode('utf-8')
+                    content = content[3:-3]
+                    print(content)
+
+            return content
+        except Exception as e:
+            print(e)
+            return None
+
+    @staticmethod
+    def encode_data(content, start=1, end=4):
+        for i in range(start, end):
+            if i == 1:
+                content = CommonService.RandomStr(3, False) + content + CommonService.RandomStr(3, False)
+                content = base64.b64encode(str(content).encode("utf-8")).decode('utf8')
+            if i == 2:
+                content = CommonService.RandomStr(2, False) + str(content) + CommonService.RandomStr(2, False)
+                content = base64.b64encode(str(content).encode("utf-8")).decode('utf8')
+            if i == 3:
+                content = CommonService.RandomStr(1, False) + str(content) + CommonService.RandomStr(1, False)
+                content = base64.b64encode(str(content).encode("utf-8")).decode('utf8')
+        return content
+
+    @staticmethod
+    def encode_data_without_salt(content):
+        return base64.b64encode(str(content).encode("utf-8")).decode('utf8')
+
+