Merge remote-tracking branch 'origin/bin' into bin

Controller/CloudStorage.py

@@ -40,7 +40,7 @@ from Ansjer.config import OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET, OSS_ROLE_AR
     JPUSH_CONFIG, FCM_CONFIG, OAUTH_ACCESS_TOKEN_SECRET
 from Model.models import Device_Info, Order_Model, Store_Meal, VodHlsModel, OssCrdModel, UID_Bucket, StsCrdModel, \
     ExperienceContextModel, Pay_Type, CDKcontextModel, Device_User, SysMassModel, SysMsgModel, UidPushModel, \
-    Unused_Uid_Meal, RegionCountryModel
+    Unused_Uid_Meal
 from Object.AliPayObject import AliPayObject
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
@@ -185,9 +185,6 @@ class CloudStorageView(View):
         qs = Store_Meal.objects
         eq = ExperienceContextModel.objects.filter(uid=uid, experience_type=0).values('id')
 
-        #userObj = Device_User.objects.get(userID=userID)
-        #regionObj = RegionCountryModel.objects.get(number=userObj.region_country)
-
         if mold:
             qs = qs.filter(bucket__mold=mold,lang__lang=lang)
         else:

Controller/DeviceConfirmRegion.py

@@ -49,7 +49,7 @@ class ConfirmRegion(TemplateView):
     def dispatch(self, *args, **kwargs):
         return super(ConfirmRegion, self).dispatch(*args, **kwargs)
 
-    def post(self, request, *args, **kwargs):
+    def get(self, request, *args, **kwargs):
         response = ResponseObject()
         request.encoding = 'utf-8'
         # number = request.POST.get('number', None)
@@ -68,8 +68,22 @@ class ConfirmRegion(TemplateView):
             if device_request_url.exists():
                 return response.json(0,{"request_api_url":device_request_url[0]['region__api']})
 
-        # 不存在默认返回美洲地区api
+        # 不存在默认返回美洲地区api。
         api = RegionModel.objects.filter(continent_code='NA').values("api")
         return response.json(0,{"request_api_url":api[0]['api']})
 
+#确认设备所在地区
+class Device_Region(object):
+
+    def get_device_region(self, ip):
+
+        ipInfo = CommonService.getIpIpInfo(ip, "CN")
+        if ipInfo['country_code']:
+            device_request_url = CountryModel.objects.filter(country_code=ipInfo['country_code']).values("region__api","region__id")
+            if device_request_url.exists():
+                return device_request_url[0]['region__id']
+        # 不存在默认返回美洲地区api
+        api = RegionModel.objects.filter(continent_code='NA').values("id")
+        return api[0]['id']
+
 

Controller/EquipmentManager.py

@@ -7,7 +7,8 @@ import logging
 import requests
 import simplejson as json
 from django.utils import timezone
-from Model.models import Device_User, Device_Info, UID_Bucket, UID_Preview, UidSetModel, UidPushModel
+from Model.models import Device_User, Device_Info, UID_Bucket, UID_Preview, UidSetModel, UidPushModel, \
+    UIDCompanySerialModel, iotdeviceInfoModel
 from django.db.models import Q
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
@@ -466,9 +467,18 @@ def addInterface(request):
                                              View_Password=View_Password, Type=Type, ChannelIndex=ChannelIndex,
                                              version=version, vodPrimaryUserID=vodPrimaryUserID, vodPrimaryMaster=vodPrimaryMaster)
                     userDevice.save()
-                    Device_Info.objects.filter(UID=UID).update(vodPrimaryUserID=vodPrimaryUserID,
-                                                               vodPrimaryMaster=vodPrimaryMaster)
-                    # redisObj = RedisObject(db=8)
+                    uid_serial_qs = UIDCompanySerialModel.objects.filter(
+                        uid__uid=UID)
+                    if uid_serial_qs.exists():
+                        uid_serial = uid_serial_qs[0]
+                        Device_Info.objects.filter(UID=UID).update(vodPrimaryUserID=vodPrimaryUserID,
+                                                                   vodPrimaryMaster=vodPrimaryMaster,
+                                                                   serial_number=uid_serial.company_serial.serial_number.serial_number + uid_serial.company_serial.company.mark)
+                    else:
+                        Device_Info.objects.filter(UID=UID).update(vodPrimaryUserID=vodPrimaryUserID,
+                                                                   vodPrimaryMaster=vodPrimaryMaster)
+
+                # redisObj = RedisObject(db=8)
                     # redisObj.del_data(key='uid_qs_' + userID)
                 except Exception as e:
                     return response.json(10, repr(e))
@@ -479,12 +489,25 @@ def addInterface(request):
                                                                     'isShare',
                                                                     'primaryUserID', 'primaryMaster', 'vodPrimaryUserID', 'vodPrimaryMaster', 'userID__userEmail',
                                                                     'data_joined', 'version',
-                                                                    'isVod', 'isExist', 'isCameraOpenCloud', 'endpoint', 'token_iot_number')
+                                                                    'isVod', 'isExist', 'isCameraOpenCloud', 'serial_number')
                     dvql = CommonService.qs_to_list(dvqs)
                     ubqs = UID_Bucket.objects.filter(uid=UID). \
                         values('bucket__content', 'status', 'channel', 'endTime', 'uid')
                     res = dvql[0]
                     res['vod'] = list(ubqs)
+
+
+                    # 新增获取IOT证书内容
+                    iotqs = iotdeviceInfoModel.objects.filter(serial_number__serial_number=dvql[0]['serial_number'])
+                    if iotqs.exists():
+                        res['iot'].append(
+                            {
+                                'endpoint': iotqs[0].endpoint,
+                                'token_iot_number': iotqs[0].endpoint
+
+                            }
+                        )
+
                     if isMainUserExists:
                         res['isMainUserExists'] = 1
                     return response.json(0, res)
@@ -816,17 +839,22 @@ def queryInterface(request):
         dvql = dvqs[(page - 1) * line:page * line].values('id', 'userID', 'NickName', 'UID', 'View_Account',
                                                           'View_Password', 'ChannelIndex', 'Type', 'isShare',
                                                           'primaryUserID', 'primaryMaster', 'data_joined', 'version', 'vodPrimaryUserID', 'vodPrimaryMaster', 'userID__userEmail',
-                                                          'isVod', 'isExist', 'NotificationMode', 'isCameraOpenCloud', 'endpoint', 'token_iot_number')
+                                                          'isVod', 'isExist', 'NotificationMode', 'isCameraOpenCloud', 'serial_number')
         dvls = CommonService.qs_to_list(dvql)
         uid_list = []
+        serial_number_list = []
         for dvl in dvls:
             if dvl['primaryUserID'] and dvl['id'] == dvl['primaryUserID']:
                 dvl['isPrimaryUser'] = 1
             else:
                 dvl['isPrimaryUser'] = 0
             uid_list.append(dvl['UID'])
-            # if dvl['isShare'] is False:
-            #     uid_list.append(dvl['UID'])
+            serial_number_list.append(dvl['serial_number'][0:6])
+
+
+        #新增获取IOT证书内容
+        iotqs = iotdeviceInfoModel.objects.filter(serial_number__serial_number__in=serial_number_list)
+
         ubqs = UID_Bucket.objects.filter(uid__in=uid_list). \
             values('bucket__content', 'status', 'channel', 'endTime', 'uid')
         upqs = UID_Preview.objects.filter(uid__in=uid_list).order_by('channel').values('id', 'uid', 'channel')
@@ -842,7 +870,20 @@ def queryInterface(request):
             uv_dict[us['uid']] = {'version': us['version'],
                                   'nickname': us['nickname'],
                                   'detect_interval': us['detect_interval']}
+
         for p in dvls:
+            #新增IOT
+            p['iot'] = []
+            for iot in iotqs:
+                if p['serial_number'][0:6] == iot.serial_number.serial_number:
+                        p['iot'].append(
+                            {
+                                'endpoint':iot.endpoint,
+                                'token_iot_number':iot.token_iot_number
+
+                            }
+                        )
+
             p['vod'] = []
             for dm in ubqs:
                 if p['UID'] == dm['uid']:

Controller/EquipmentManagerV2.py

@@ -8,7 +8,8 @@ from django.db.models import Q
 from django.views.generic.base import View
 
 from Ansjer.config import OSS_STS_ACCESS_SECRET, OSS_STS_ACCESS_KEY
-from Model.models import Device_Info, UID_Bucket, UID_Preview, UidSetModel, UidPushModel, UidChannelSetModel
+from Model.models import Device_Info, UID_Bucket, UID_Preview, UidSetModel, UidPushModel, UidChannelSetModel, \
+    iotdeviceInfoModel
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
 from Service.CommonService import CommonService
@@ -148,18 +149,22 @@ class EquipmentManagerV2(View):
                        'View_Password', 'ChannelIndex', 'Type', 'isShare',
                        'primaryUserID', 'primaryMaster', 'data_joined', 'vodPrimaryUserID', 'vodPrimaryMaster', 'userID__userEmail',
                        'version',
-                       'isVod', 'isExist', 'NotificationMode', 'isOpenCloud', 'endpoint')
+                       'isVod', 'isExist', 'NotificationMode', 'isOpenCloud', 'serial_number')
             dvls = CommonService.qs_to_list(dvql)
+
             uid_list = []
+            serial_number_list = []
             for dvl in dvls:
                 if dvl['primaryUserID'] and dvl['id'] == dvl['primaryUserID']:
                     dvl['isPrimaryUser'] = 1
                 else:
                     dvl['isPrimaryUser'] = 0
-
                 uid_list.append(dvl['UID'])
-                # if dvl['isShare'] is False:
-                #     uid_list.append(dvl['UID'])
+                serial_number_list.append(dvl['serial_number'][0:6])
+
+            # 新增获取IOT证书内容
+            iotqs = iotdeviceInfoModel.objects.filter(serial_number__serial_number__in=serial_number_list)
+
             ubqs = UID_Bucket.objects.filter(uid__in=uid_list). \
                 values('bucket__content', 'status', 'channel', 'endTime', 'uid')
             upqs = UID_Preview.objects.filter(uid__in=uid_list).order_by('channel').values('id', 'uid', 'channel')
@@ -180,6 +185,18 @@ class EquipmentManagerV2(View):
                     'is_custom_voice': us['is_custom_voice'],
                 }
             for p in dvls:
+                # 新增云分配UID
+                p['iot'] = []
+                for iot in iotqs:
+                    if p['serial_number'][0:6] == iot.serial_number.serial_number:
+                        p['iot'].append(
+                            {
+                                'endpoint': iot.endpoint,
+                                'token_iot_number': iot.token_iot_number
+
+                            }
+                        )
+
                 p['vod'] = []
                 for dm in ubqs:
                     if p['UID'] == dm['uid']:
@@ -220,16 +237,20 @@ class EquipmentManagerV2(View):
                            'View_Password', 'ChannelIndex', 'Type', 'isShare',
                            'primaryUserID', 'primaryMaster', 'data_joined', 'vodPrimaryUserID', 'vodPrimaryMaster',
                            'userID__userEmail',
-                           'version', 'isVod', 'isExist', 'NotificationMode', 'isCameraOpenCloud', 'endpoint', 'token_iot_number')
+                           'version', 'isVod', 'isExist', 'NotificationMode', 'isCameraOpenCloud', 'serial_number')
         dvls = CommonService.qs_to_list(dvql)
         uid_list = []
+        serial_number_list = []
         for dvl in dvls:
             if dvl['primaryUserID'] and dvl['id'] == dvl['primaryUserID']:
                 dvl['isPrimaryUser'] = 1
             else:
                 dvl['isPrimaryUser'] = 0
-
             uid_list.append(dvl['UID'])
+            serial_number_list.append(dvl['serial_number'])
+
+        # 新增获取IOT证书内容
+        iotqs = iotdeviceInfoModel.objects.filter(serial_number__serial_number__in=serial_number_list)
 
         ubqs = UID_Bucket.objects.filter(uid__in=uid_list). \
             values('bucket__content', 'status', 'channel', 'endTime', 'uid')
@@ -302,6 +323,18 @@ class EquipmentManagerV2(View):
             uv_dict[us['uid']]['channels'] = channels
 
         for p in dvls:
+            # 新增IOT
+            p['iot'] = []
+            for iot in iotqs:
+                if p['serial_number'][0:6] == iot.serial_number:
+                    p['iot'].append(
+                        {
+                            'endpoint': iot.endpoint,
+                            'token_iot_number': iot.token_iot_number
+
+                        }
+                    )
+
             p['vod'] = []
             for dm in ubqs:
                 if p['UID'] == dm['uid']:

Controller/EquipmentManagerV3.py

@@ -12,7 +12,7 @@ from django.views.generic.base import View
 from Object.RedisObject import RedisObject
 from Ansjer.config import OSS_STS_ACCESS_SECRET, OSS_STS_ACCESS_KEY, BASE_DIR
 from Model.models import Device_Info, UID_Bucket, UID_Preview, UidSetModel, UidPushModel, UidChannelSetModel, \
-    Device_User
+    Device_User, iotdeviceInfoModel, UIDCompanySerialModel
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
 from Service.CommonService import CommonService
@@ -172,7 +172,15 @@ class EquipmentManagerV3(View):
                                                  version=version,
                                                  vodPrimaryUserID=vodPrimaryUserID, vodPrimaryMaster=vodPrimaryMaster)
                         userDevice.save()
-                        Device_Info.objects.filter(UID=UID).update(vodPrimaryUserID=vodPrimaryUserID,
+                        uid_serial_qs = UIDCompanySerialModel.objects.filter(
+                            uid__uid=UID)
+                        if uid_serial_qs.exists():
+                            uid_serial = uid_serial_qs[0]
+                            Device_Info.objects.filter(UID=UID).update(vodPrimaryUserID=vodPrimaryUserID,
+                                                                       vodPrimaryMaster=vodPrimaryMaster,
+                                                                       serial_number=uid_serial.company_serial.serial_number.serial_number + uid_serial.company_serial.company.mark)
+                        else:
+                            Device_Info.objects.filter(UID=UID).update(vodPrimaryUserID=vodPrimaryUserID,
                                                                        vodPrimaryMaster=vodPrimaryMaster)
 
                         if not us_qs.exists():
@@ -196,13 +204,23 @@ class EquipmentManagerV3(View):
                                                                         'vodPrimaryUserID', 'vodPrimaryMaster',
                                                                         'userID__userEmail',
                                                                         'data_joined', 'version',
-                                                                        'isVod', 'isExist', 'isCameraOpenCloud', 'endpoint', 'token_iot_number')
+                                                                        'isVod', 'isExist', 'isCameraOpenCloud', 'serial_number')
                         dvql = CommonService.qs_to_list(dvqs)
                         ubqs = UID_Bucket.objects.filter(uid=UID). \
                             values('bucket__content', 'status', 'channel', 'endTime', 'uid')
                         res = dvql[0]
                         res['vod'] = list(ubqs)
 
+                        iotqs = iotdeviceInfoModel.objects.filter(serial_number__serial_number=dvql[0]['serial_number'])
+                        if iotqs.exists():
+                            res['iot'].append(
+                                {
+                                    'endpoint': iotqs[0].endpoint,
+                                    'token_iot_number': iotqs[0].endpoint
+
+                                }
+                            )
+
                         return response.json(0, res)
 
                 else:
@@ -307,16 +325,20 @@ class EquipmentManagerV3(View):
                                'primaryUserID', 'primaryMaster', 'data_joined', 'vodPrimaryUserID', 'vodPrimaryMaster',
                                'userID__userEmail',
                                'version', 'isVod', 'isExist', 'NotificationMode', 'isCameraOpenCloud',
-                               'endpoint', 'token_iot_number')
+                               'serial_number')
             dvls = CommonService.qs_to_list(dvql)
             uid_list = []
+            serial_number_list = []
             for dvl in dvls:
                 if dvl['primaryUserID'] and dvl['id'] == dvl['primaryUserID']:
                     dvl['isPrimaryUser'] = 1
                 else:
                     dvl['isPrimaryUser'] = 0
-
                 uid_list.append(dvl['UID'])
+                serial_number_list.append(dvl['serial_number'][0:6])
+
+            # 新增获取IOT证书内容
+            iotqs = iotdeviceInfoModel.objects.filter(serial_number__serial_number__in=serial_number_list)
 
             ubqs = UID_Bucket.objects.filter(uid__in=uid_list). \
                 values('bucket__content', 'status', 'channel', 'endTime', 'uid')
@@ -391,6 +413,18 @@ class EquipmentManagerV3(View):
                 uv_dict[us['uid']]['channels'] = channels
 
             for p in dvls:
+                # 新增IOT
+                p['iot'] = []
+                for iot in iotqs:
+                    if p['serial_number'][0:6] == iot.serial_number.serial_number:
+                        p['iot'].append(
+                            {
+                                'endpoint': iot.endpoint,
+                                'token_iot_number': iot.token_iot_number
+
+                            }
+                        )
+
                 p['vod'] = []
                 for dm in ubqs:
                     if p['UID'] == dm['uid']:
@@ -486,12 +520,18 @@ class EquipmentManagerV3(View):
                                              'View_Password', 'ChannelIndex', 'Type', 'isShare',
                                              'primaryUserID', 'primaryMaster', 'data_joined', 'vodPrimaryUserID',
                                              'vodPrimaryMaster', 'userID__userEmail',
-                                             'version', 'isVod', 'isExist', 'NotificationMode', 'isCameraOpenCloud', 'endpoint', 'token_iot_number')
+                                             'version', 'isVod', 'isExist', 'NotificationMode', 'isCameraOpenCloud', 'serial_number')
 
                 dvls = CommonService.qs_to_list(device_qs)
                 uid_list = []
+                serial_number_list = []
                 for dvl in dvls:
                     uid_list.append(dvl['UID'])
+                    serial_number_list.append(dvl['serial_number'][0:6])
+
+                # 新增获取IOT证书内容
+                iotqs = iotdeviceInfoModel.objects.filter(serial_number__serial_number__in=serial_number_list)
+
                 ubqs = UID_Bucket.objects.filter(uid__in=uid_list). \
                     values('bucket__content', 'status', 'channel', 'endTime', 'uid')
                 upqs = UID_Preview.objects.filter(uid__in=uid_list).order_by('channel').values('id', 'uid', 'channel')
@@ -554,6 +594,17 @@ class EquipmentManagerV3(View):
                     uv_dict[us['uid']]['channels'] = channels
 
                 for p in dvls:
+                    # 新增IOT
+                    p['iot'] = []
+                    for iot in iotqs:
+                        if p['serial_number'][0:6] == iot.serial_number.serial_number:
+                            p['iot'].append(
+                                {
+                                    'endpoint': iot.endpoint,
+                                    'token_iot_number': iot.token_iot_number
+
+                                }
+                            )
                     p['vod'] = []
                     for dm in ubqs:
                         if p['UID'] == dm['uid']:

Controller/IotCoreController.py

@@ -8,7 +8,9 @@ import uuid
 import boto3
 from django.views import View
 
-from Model.models import Device_User, Device_Info, RegionCountryModel, iotdeviceInfoModel
+from Controller.DeviceConfirmRegion import Device_Region
+from Model.models import Device_User, Device_Info, iotdeviceInfoModel, UIDCompanySerialModel, \
+    SerialNumberModel
 from Object.IOTCore.IotObject import IOTClient
 from Object.ResponseObject import ResponseObject
 from Service.CommonService import CommonService
@@ -20,107 +22,88 @@ class IotCoreView(View):
         request.encoding = 'utf-8'
         request_dict = request.GET
         operation = kwargs.get('operation', None)
-        return self.validate(operation, request_dict)
+        return self.validate(operation, request_dict, request)
 
     def post(self, request, *args, **kwargs):
         request.encoding = 'utf-8'
         request_dict = request.POST
         operation = kwargs.get('operation', None)
-        return self.validate(operation, request_dict)
+        return self.validate(operation, request_dict, request)
 
-    def validate(self, operation, request_dict):
+    def validate(self, operation, request_dict, request):
 
         response = ResponseObject()
 
-        if operation == 'createProvisioningClaim':
-            return self.create_provisioning_claim(request_dict, response)
-        elif operation == 'createKeysAndCertificate':
-            return self.create_keys_and_certificate(request_dict, response)
+        if operation == 'createKeysAndCertificate':
+            return self.create_keys_and_certificate(request_dict, response, request)
         else:
             return response.json(404)
 
-    # 即时预置注册  ：已放弃
-    def create_provisioning_claim(self, request_dict, response):
-        uid = request_dict.get('uid', None)
-        token = request_dict.get('token', None)
-        time_stamp = request_dict.get('time_stamp', None)
-
-        if uid and token and time_stamp:
-            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 and distance > 600: 暂时去掉延时
-            if token != time_stamp :
-                return response.json(404)
-
-            region_country_qs = Device_Info.objects.filter(UID=uid).values('userID__region_country')
-            if not region_country_qs.exists() or region_country_qs[0]['userID__region_country'] == 0 :
-                return response.json(173)
-
-            region_country_qs = RegionCountryModel.objects.filter(number=region_country_qs[0]['userID__region_country'])
-            if region_country_qs.exists():
-                user_region = region_country_qs[0]
-                iotClient = IOTClient(user_region.region_id)
-                return response.json(0, {'res': iotClient.create_provisioning_claim('Ansjer_Iot_Queue')})
-        else:
-            return response.json(444)
 
     # CVM注册  ：正使用
-    def create_keys_and_certificate(self, request_dict, response):
-        uid = request_dict.get('uid', None)
-        uid_code = request_dict.get('uid_code', None)
+    def create_keys_and_certificate(self, request_dict, response, request):
+        serial_number = request_dict.get('serial_number', None)
+        serial_number_code = request_dict.get('serial_number_code', None)
         token = request_dict.get('token', None)
         time_stamp = request_dict.get('time_stamp', None)
-        device_version = request_dict.get('device_version', None)
+        device_version = request_dict.get('device_version', None).replace('.', '_') # 物品组命名不能包含'.'
+        language = request_dict.get('language', None)
 
-        if uid and token and time_stamp and uid_code:
-            uid_code = CommonService.decode_data(uid_code)
+        if serial_number and token and time_stamp and serial_number_code and device_version and language:
+            uid_code = CommonService.decode_data(serial_number_code)
             token = int(CommonService.decode_data(token))
             time_stamp = int(time_stamp)
 
             now_time = int(time.time())
             distance = now_time - time_stamp
+            thingGroup = device_version + '_' + language
 
             # if token != time_stamp and distance > 600: 暂时去掉延时
-            # if token != time_stamp or uid != uid_code :
+            # if token != time_stamp or serial_number != serial_number_code :
             #     return response.json(404)
 
-            region_country_qs = Device_Info.objects.filter(UID=uid).values('userID__region_country')
-            if not region_country_qs.exists() or region_country_qs[0]['userID__region_country'] == 0 :
-                return response.json(173)
+            serial = serial_number[0:6]
 
-            iotqs = iotdeviceInfoModel.objects.filter(uid=uid)
+            iotqs = iotdeviceInfoModel.objects.filter(serial_number__serial_number=serial)
 
             # 判断设备是否已注册证书
             if not iotqs.exists():
-                region_country_qs = RegionCountryModel.objects.filter(
-                    number=region_country_qs[0]['userID__region_country'])
-                if region_country_qs.exists():
-                    user_region = region_country_qs[0]
-
-                    iotClient = IOTClient(user_region.region_id)
-                    res = iotClient.create_keys_and_certificate(uid, device_version)
-                    nowTime = int(time.time())
-                    token_iot_number = hashlib.md5((str(uuid.uuid1()) + str(nowTime)).encode('utf-8')).hexdigest()
-                    Device_Info.objects.filter(UID=uid).update(endpoint=res[0]['endpoint'], token_iot_number=token_iot_number )
-                    iotdeviceInfoModel.objects.create(uid=uid, certificateId=res[0]['certificateId'],
-                                                      certificatePem=res[0]['certificatePem'],
-                                                      publicKey=res[0]['publicKey'],
-                                                      privateKey=res[0]['privateKey'],
-                                                      Thingname=res[1]['ThingName'])
-                    return response.json(0, {'res': res})
+                ip = CommonService.get_ip_address(request)
+                region_id = Device_Region().get_device_region(ip)
+
+                iotClient = IOTClient(region_id)
+                res = iotClient.create_keys_and_certificate(serial, thingGroup)
+                nowTime = int(time.time())
+                token_iot_number = hashlib.md5((str(uuid.uuid1()) + str(nowTime)).encode('utf-8')).hexdigest()
+
+                sn = SerialNumberModel.objects.get(serial_number=serial)
+
+                iotdeviceInfoModel.objects.create(serial_number=sn,
+                                                  endpoint=res[0]['endpoint'],
+                                                  certificate_id=res[0]['certificateId'],
+                                                  certificate_pem=res[0]['certificatePem'],
+                                                  public_key=res[0]['publicKey'],
+                                                  private_key=res[0]['privateKey'],
+                                                  thing_name=res[1]['ThingName'],
+                                                  token_iot_number=token_iot_number
+                                                  )
+                res = {
+                    'certificateId': res[0]['certificateId'],
+                    'certificatePem': res[0]['certificatePem'],
+                    'publicKey': res[0]['publicKey'],
+                    'privateKey': res[0]['privateKey'],
+                    'endpoint': res[0]['endpoint']
+                }
+                return response.json(0, {'res': res})
             else:
-                dev_qs = Device_Info.objects.filter(UID=uid)
-                iot = iotdeviceInfoModel.objects.get(uid=uid)
+
+                iot = iotqs[0]
                 res = {
-                    'certificateId': iot.certificateId,
-                    'certificatePem': iot.certificatePem,
-                    'publicKey': iot.publicKey,
-                    'privateKey': iot.privateKey,
-                    'endpoint': dev_qs[0].endpoint
+                    'certificateId': iot.certificate_id,
+                    'certificatePem': iot.certificate_pem,
+                    'publicKey': iot.public_key,
+                    'privateKey': iot.private_key,
+                    'endpoint': iot.endpoint
                 }
                 # print('此设备已注册证书')
                 return response.json(0, {'res': res})

Controller/RegionController.py

@@ -262,7 +262,7 @@ class RegionView(View):
             now_time = int(time.time())
             distance = now_time - time_stamp
 
-            if token != time_stamp or distance > 300 or distance < 0:
+            if token != time_stamp or distance > 30000 or distance < 0:
                 return response.json(404)
 
             lang_qs = LanguageModel.objects.filter(lang=type)

Controller/RegionCountryController.py

@@ -4,10 +4,9 @@ import time
 
 from django.views import View
 
-from Model.models import Device_User, RegionCountryModel
+from Model.models import Device_User
 from Object.ResponseObject import ResponseObject
 from Object.TokenObject import TokenObject
-import  json
 
 class RegionCountryView(View):
 
@@ -33,8 +32,6 @@ class RegionCountryView(View):
 
         if operation == 'initUserRegion':
             return self.do_initUserRegion(token.userID, request_dict, response)
-        elif operation == 'initRegionDate':
-            return self.do_initRegionDate(request_dict, response)
         else:
             return response.json(404)
 
@@ -47,26 +44,3 @@ class RegionCountryView(View):
         user.region_country=number
         user.save()
         return response.json(0)
-
-    def do_initRegionDate(self, request_dict, response):
-        filepath = request_dict.get('filepath')
-
-        with open(filepath, 'r', encoding='UTF-8') as f:
-            region_list = json.load(f)
-
-        #region_list = json.loads(fobj)
-        now_time = int(time.time())
-        regin_list = []
-        for region in region_list:
-            name = region['name']
-            region_id = region['region_id']
-
-            countries_list = region['countries']
-            for countries in countries_list:
-                cn = countries['cn']
-                en = countries['en']
-                number = countries['number']
-                regin_list.append(RegionCountryModel(number=number, region_id=region_id, name=name, cn=cn, en=en, add_time=now_time, update_time=now_time))
-
-        RegionCountryModel.objects.bulk_create(regin_list)
-        return response.json(0)

Controller/SerialNumberController.py

@@ -7,8 +7,9 @@ import time
 from django.db import transaction
 from django.views import View
 
+from Controller.DeviceConfirmRegion import Device_Region
 from Model.models import SerialNumberModel, CompanySerialModel, UIDCompanySerialModel, CompanyModel, RegionModel, \
-    CountryModel, UIDModel, RegionCountryModel, Device_Info, iotdeviceInfoModel
+    CountryModel, UIDModel, Device_Info, iotdeviceInfoModel
 from Object.RedisObject import RedisObject
 from Object.uidManageResponseObject import uidManageResponseObject
 from Object.TokenObject import TokenObject
@@ -23,15 +24,15 @@ class SerialNumberView(View):
         request.encoding = 'utf-8'
         operation = kwargs.get('operation', None)
         request_dict = request.GET
-        return self.validate(request_dict, operation)
+        return self.validate(request_dict, operation, request)
 
     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)
+        return self.validate(request_dict, operation, request)
 
-    def validate(self, request_dict, operation):
+    def validate(self, request_dict, operation, request):
         token = TokenObject(request_dict.get('token', None))
         response = uidManageResponseObject()
 
@@ -39,6 +40,8 @@ class SerialNumberView(View):
             return self.do_get_uid(request_dict, response)
         elif operation == 'getSerial':
             return self.do_get_serial_number(request_dict, response)
+        elif operation == 'attachUID':
+            return self.do_attach_uid(request_dict, response, request)
         else:
             if token.code != 0:
                 return response.json(token.code)
@@ -49,8 +52,6 @@ class SerialNumberView(View):
                 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:
@@ -190,18 +191,33 @@ class SerialNumberView(View):
             return response.json(444)
 
     @transaction.atomic
-    def do_attach_uid(self, request_dict, response):
+    def do_attach_uid(self, request_dict, response, request):
         serial_number = request_dict.get('serial_number', None)
         country_id = request_dict.get('country_id', None)
         company_id = request_dict.get('company_id', None)
+        token = request_dict.get('token', None)
+        time_stamp = request_dict.get('time_stamp', None)
+
+        if serial_number and len(serial_number) == 9  and company_id:
+
+            token = int(CommonService.decode_data(token))
+            time_stamp = int(time_stamp)
+
+            now_time = int(time.time())
+            distance = now_time - time_stamp
+
+            if token != time_stamp or distance > 60000 or distance < 0:
+                return response.json(404)
 
-        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:
+                    if not country_id :
+                        ip = CommonService.get_ip_address(request)
+                        country_id = Device_Region().get_device_region(ip)
 
                     # 判断序列号是否已和企业关联
                     company_serial_qs = CompanySerialModel.objects.filter(company__secret=company_id,
@@ -209,17 +225,6 @@ class SerialNumberView(View):
                     if not company_serial_qs.exists():
                         return response.json(173)
 
-                    region_country_qs = RegionCountryModel.objects.filter(number=country_id)
-                    endpoint = 'a2rqy12o004ad8-ats.iot.us-east-1.amazonaws.com'
-                    if region_country_qs.exists():
-                        user_region = region_country_qs[0]
-                        if user_region.region_id == 1:
-                            endpoint = 'a250bbr0p9u7as-ats.iot.cn-northwest-1.amazonaws.com.cn'
-                        elif user_region.region_id == 2:
-                            endpoint = 'a2rqy12o004ad8-ats.iot.ap-southeast-1.amazonaws.com'
-                        elif user_region.region_id == 3:
-                            endpoint = 'a2rqy12o004ad8-ats.iot.eu-west-1.amazonaws.com'
-
                     # 当序列号已关联UID
                     company_serial = company_serial_qs[0]
 
@@ -259,11 +264,15 @@ class SerialNumberView(View):
                                 company_serial.status = 2
                                 company_serial.save()
 
+                                dev = Device_Info.objects.filter(UID=uid.uid)
+                                if dev.exists():
+                                    dev.update(serial_number=serial_number)
+
+
                                 res = {
                                     'uid': CommonService.encode_data(uid.uid),
                                     'mac': CommonService.encode_data(uid.mac),
-                                    'extra': uid.uid_extra,
-                                    'endpoint': endpoint
+                                    'extra': uid.uid_extra
                                 }
                                 return response.json(0, res)
                             else:
@@ -277,8 +286,7 @@ class SerialNumberView(View):
                             res = {
                                 'uid': CommonService.encode_data(uid['uid__uid']),
                                 'mac': CommonService.encode_data(uid['uid__mac']),
-                                'extra': uid['uid__uid_extra'],
-                                'endpoint': endpoint
+                                'extra': uid['uid__uid_extra']
                             }
                             return response.json(0, res)
                         else:
@@ -342,13 +350,13 @@ class SerialNumberView(View):
         if serial_number:
             serial = serial_number[0:6]
 
-            uid_serial_qs = UIDCompanySerialModel.objects.filter(company_serial__serial_number=serial)
+            uid_serial_qs = UIDCompanySerialModel.objects.filter(company_serial__serial_number__serial_number=serial)
             if uid_serial_qs.exists():
                 uid_serial = uid_serial_qs[0]
 
-                Device_Info.objects.filter(UID=uid_serial.uid).update(endpoint='',
-                                                           token_iot_number='')
-                iotdeviceInfoModel.objects.filter(uid=uid_serial.uid).delete()
+                iot = iotdeviceInfoModel.objects.filter(serial_number__serial_number=serial)
+                if iot.exists():
+                    iot.delete()
 
                 company_serial_qs = CompanySerialModel.objects.filter(id=uid_serial.company_serial.id)
                 if company_serial_qs.exists():
@@ -362,6 +370,10 @@ class SerialNumberView(View):
                     uid.status = 0
                     uid.save()
                 uid_serial.delete()
+
+                dev = Device_Info.objects.filter(UID=uid.uid)
+                if dev.exists():
+                    dev.update(serial_number='')
                 return response.json(0)
             else:
                 return response.json(173)

Model/models.py

@@ -118,22 +118,6 @@ class Role(models.Model):
             permslist.sort()
             return permslist
 
-
-class RegionCountryModel(models.Model):
-    number = models.IntegerField(primary_key=True, verbose_name='唯一标识')
-    region_id = models.IntegerField(verbose_name='大洲编号')
-    name = models.CharField(max_length=50, verbose_name=u'名称')
-    cn = models.CharField(blank=True, max_length=64, verbose_name=u'中文名称')
-    en = models.CharField(blank=True, max_length=64, verbose_name=u'英文名称')
-    add_time = models.IntegerField(default=0, verbose_name='添加时间')
-    update_time = models.IntegerField(default=0, verbose_name='更新时间')
-
-    class Meta:
-        db_table = 'region_country'
-        verbose_name = '地区表'
-        verbose_name_plural = verbose_name
-
-
 class Device_User(AbstractBaseUser):
     userID = models.CharField(blank=True, max_length=32, primary_key=True,
                               verbose_name=u'用户ID', unique=True)
@@ -257,8 +241,7 @@ class Device_Info(models.Model):
     isVod = models.SmallIntegerField(blank=True, default=0, verbose_name='是否支持云存')  # 是否支持云存设备
     isExist = models.SmallIntegerField(blank=True, default=1, verbose_name='是否被删除')  # 是否被删除了(需主用户交互) 1存在，0不存在，2设备被重置
     isCameraOpenCloud =  models.SmallIntegerField(blank=True, default=1, verbose_name='是否开启云存')  # 0：不开启  1：开启
-    endpoint = models.CharField(blank=True, max_length=256, default='', verbose_name=u'iot端点')
-    token_iot_number = models.CharField(blank=True, default='', max_length=50, verbose_name='连接iot令牌')
+    serial_number = models.CharField(blank=True, max_length=9, default='', verbose_name='关联序列号')
     ###
     REQUIRED_FIELDS = []
 
@@ -1512,7 +1495,7 @@ class CountryLanguageModel(models.Model):
 
 class SerialNumberModel(models.Model):
     id = models.AutoField(primary_key=True)
-    serial_number = models.CharField(max_length=9, db_index=True, verbose_name='序列号')
+    serial_number = models.CharField(max_length=9, db_index=True, unique=True, verbose_name='序列号')
     status = models.SmallIntegerField(default=1, verbose_name='可用状态。0：不可用，1：可用')
     add_time = models.IntegerField(default=0, verbose_name='添加时间')
 
@@ -1551,13 +1534,14 @@ class UIDCompanySerialModel(models.Model):
 
 class iotdeviceInfoModel(models.Model):
     id = models.AutoField(primary_key=True)
-    uid = models.CharField(blank=True, max_length=32, default='', verbose_name=u'设备uid')
-    certificateId = models.CharField(blank=True, max_length=256, default='', verbose_name=u'证书id')
-    certificatePem = models.TextField(blank=True, default='', verbose_name=u'证书项目')
-    publicKey = models.TextField(blank=True, default='', verbose_name=u'公有密钥')
-    privateKey = models.TextField(blank=True, default='', verbose_name=u'私有密钥')
-    Thingname = models.CharField(blank=True, max_length=256, default='', verbose_name=u'IoT Thing Name')
-
+    serial_number = models.ForeignKey(SerialNumberModel, to_field='id', default='', on_delete=models.CASCADE, verbose_name='关联序列号表的id')
+    certificate_id = models.CharField(blank=True, max_length=256, default='', verbose_name=u'证书id')
+    certificate_pem = models.TextField(blank=True, default='', verbose_name=u'证书项目')
+    public_key = models.TextField(blank=True, default='', verbose_name=u'公有密钥')
+    private_key = models.TextField(blank=True, default='', verbose_name=u'私有密钥')
+    thing_name = models.CharField(blank=True, max_length=256, default='', verbose_name=u'IoT Thing Name')
+    endpoint = models.CharField(blank=True, max_length=256, db_index=True, default='', verbose_name=u'iot端点')
+    token_iot_number = models.CharField(blank=True,  db_index=True ,default='', max_length=50, verbose_name='连接iot令牌')
     class Meta:
         db_table = 'iot_deviceInfo'
         verbose_name = 'iot设备信息表'

Object/IOTCore/IotObject.py

@@ -38,16 +38,16 @@ class IOTClient(IOTObject):
             self.endpoint = 'a2rqy12o004ad8-ats.iot.ap-southeast-1.amazonaws.com'
 
         if region_id == 3:
-            self.client = boto3.client('iot', region_name=AWS_IOT_SES_ACCESS_FOREIGN_REGION_EUROPE,
+            self.client = boto3.client('iot', region_name=AWS_IOT_SES_ACCESS_FOREIGN_REGION_AMERICA,
                                        aws_access_key_id=AWS_IOT_SES_ACCESS_FOREIGN_ID,
                                        aws_secret_access_key=AWS_IOT_SES_ACCESS_FOREIGN_SECRET)
-            self.endpoint = 'a2rqy12o004ad8-ats.iot.eu-west-1.amazonaws.com'
+            self.endpoint = 'a2rqy12o004ad8-ats.iot.us-east-1.amazonaws.com'
 
         if region_id == 4:
-            self.client = boto3.client('iot', region_name=AWS_IOT_SES_ACCESS_FOREIGN_REGION_AMERICA,
+            self.client = boto3.client('iot', region_name=AWS_IOT_SES_ACCESS_FOREIGN_REGION_EUROPE,
                                        aws_access_key_id=AWS_IOT_SES_ACCESS_FOREIGN_ID,
                                        aws_secret_access_key=AWS_IOT_SES_ACCESS_FOREIGN_SECRET)
-            self.endpoint = 'a2rqy12o004ad8-ats.iot.us-east-1.amazonaws.com'
+            self.endpoint = 'a2rqy12o004ad8-ats.iot.eu-west-1.amazonaws.com'
 
 
 
@@ -64,71 +64,94 @@ class IOTClient(IOTObject):
         }
         return res
 
-    def create_keys_and_certificate(self, uid, device_version):
-        result = self.client.create_keys_and_certificate(setAsActive=True)
-        res = {
-            'certificateId': result['certificateId'],
-            'certificatePem': result['certificatePem'],
-            'publicKey': result['keyPair']['PublicKey'],
-            'privateKey': result['keyPair']['PrivateKey'],
-            'endpoint': 'a250bbr0p9u7as-ats.iot.cn-northwest-1.amazonaws.com.cn'
-        }
-        # 根据证书ID注册物品和策略
-        templateBody = {
-            "Parameters": {
-                "ThingName": {
-                    "Type": "String"
-                },
-                "SerialNumber": {
-                    "Type": "String"
-                },
-                "DeviceLocation": {
-                    "Type": "String"
-                },
-                "AWS::IoT::Certificate::Id": {
-                    "Type": "String"
+    def create_keys_and_certificate(self, serial_number, thingGroup):
+        try:
+            result = self.client.create_keys_and_certificate(setAsActive=True)
+            res = {
+                'certificateId': result['certificateId'],
+                'certificatePem': result['certificatePem'],
+                'publicKey': result['keyPair']['PublicKey'],
+                'privateKey': result['keyPair']['PrivateKey'],
+                'endpoint': self.endpoint
+            }
+            # 搜索是否存在该物品组
+            thing_groups_res = self.client.list_thing_groups(nextToken='', maxResults=1,
+                                                             namePrefixFilter=thingGroup, recursive=False)
+            if thing_groups_res['thingGroups']:
+                thingGroupName = thing_groups_res['thingGroups'][0]['groupName']  # 获取物品组名称
+            else:
+                attributes = {
+                    "update_time": "0"
                 }
-            },
-            "Resources": {
-                "thing": {
-                    "Type": "AWS::IoT::Thing",
-                    "Properties": {
-                        "AttributePayload": {},
-                        # "ThingGroups" : ["v1-lightbulbs", {"Ref" : "DeviceLocation"}],
-                        "ThingName": {
-                            "Ref": "ThingName"
-                        },
-                        "ThingGroups": [{"Ref" : "DeviceLocation"}]
-                    },
-                    "OverrideSettings": {
-                        "AttributePayload": "MERGE",
-                        "ThingTypeName": "REPLACE",
-                        "ThingGroups": "DO_NOTHING"
+                thingGroupProperties = {
+                    "thingGroupDescription": "OTA",
+                    "attributePayload": {
+                        "attributes": attributes,
+                        "merge": False  # 更新时覆盖掉而不是合并
                     }
-                },
-                "certificate": {
-                    "Type": "AWS::IoT::Certificate",
-                    "Properties": {
-                        "CertificateId": {"Ref": "AWS::IoT::Certificate::Id"},
-                        "Status": "Active"
+                }
+                create_thing_group_res = self.client.create_thing_group(thingGroupName=thingGroup,
+                                                                        thingGroupProperties=thingGroupProperties)
+                thingGroupName = create_thing_group_res['thingGroupName']  # 获取物品组名称
+            print('物品组:', thingGroupName)
+            # 根据证书ID注册物品和策略
+            templateBody = {
+                "Parameters": {
+                    "ThingName": {
+                        "Type": "String"
+                    },
+                    "SerialNumber": {
+                        "Type": "String"
+                    },
+                    "thingGroupName": {
+                        "Type": "String"
+                    },
+                    "AWS::IoT::Certificate::Id": {
+                        "Type": "String"
                     }
                 },
-                "policy": {
-                    "Properties": {
-                        "PolicyName": "My_Iot_Policy"
+                "Resources": {
+                    "thing": {
+                        "Type": "AWS::IoT::Thing",
+                        "Properties": {
+                            "AttributePayload": {},
+                            # "ThingGroups" : ["v1-lightbulbs", {"Ref" : "DeviceLocation"}],
+                            "ThingName": {
+                                "Ref": "ThingName"
+                            },
+                            "ThingGroups": [{"Ref": "thingGroupName"}]
+                        },
+                        "OverrideSettings": {
+                            "AttributePayload": "MERGE",
+                            "ThingTypeName": "REPLACE",
+                            "ThingGroups": "DO_NOTHING"
+                        }
                     },
-                    "Type": "AWS::IoT::Policy"
-                },
+                    "certificate": {
+                        "Type": "AWS::IoT::Certificate",
+                        "Properties": {
+                            "CertificateId": {"Ref": "AWS::IoT::Certificate::Id"},
+                            "Status": "Active"
+                        }
+                    },
+                    "policy": {
+                        "Properties": {
+                            "PolicyName": "My_Iot_Policy"
+                        },
+                        "Type": "AWS::IoT::Policy"
+                    },
+                }
             }
-        }
-
-        templateBody = json.dumps(templateBody)
-        parameters = {"ThingName": "Ansjer_Device_" + uid,
-                      "DeviceLocation": device_version,
-                      "AWS::IoT::Certificate::Id": res['certificateId']}
-        self.client.register_thing(
-            templateBody=templateBody,
-            parameters=parameters
-        )
-        return res, parameters
 
+            templateBody = json.dumps(templateBody)
+            parameters = {"ThingName": "Ansjer_Device_" + serial_number,
+                          "thingGroupName": thingGroupName,
+                          "AWS::IoT::Certificate::Id": res['certificateId']}
+            self.client.register_thing(
+                templateBody=templateBody,
+                parameters=parameters
+            )
+            return res, parameters
+        except Exception as e:
+            print(e)
+            # return response.json(500, repr(e))