Merge branch 'dev' into lang

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

@@ -72,4 +72,18 @@ class ConfirmRegion(TemplateView):
         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")
+            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

@@ -479,7 +479,7 @@ def addInterface(request):
                                                                     'isShare',
                                                                     'primaryUserID', 'primaryMaster', 'vodPrimaryUserID', 'vodPrimaryMaster', 'userID__userEmail',
                                                                     'data_joined', 'version',
-                                                                    'isVod', 'isExist', 'isCameraOpenCloud', 'endpoint', 'token_iot_number')
+                                                                    'isVod', 'isExist', 'isCameraOpenCloud')
                     dvql = CommonService.qs_to_list(dvqs)
                     ubqs = UID_Bucket.objects.filter(uid=UID). \
                         values('bucket__content', 'status', 'channel', 'endTime', 'uid')
@@ -816,7 +816,7 @@ 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')
         dvls = CommonService.qs_to_list(dvql)
         uid_list = []
         for dvl in dvls:

Controller/EquipmentManagerV2.py

@@ -220,7 +220,7 @@ 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')
         dvls = CommonService.qs_to_list(dvql)
         uid_list = []
         for dvl in dvls:

Controller/EquipmentManagerV3.py

@@ -196,7 +196,7 @@ class EquipmentManagerV3(View):
                                                                         'vodPrimaryUserID', 'vodPrimaryMaster',
                                                                         'userID__userEmail',
                                                                         'data_joined', 'version',
-                                                                        'isVod', 'isExist', 'isCameraOpenCloud', 'endpoint', 'token_iot_number')
+                                                                        'isVod', 'isExist', 'isCameraOpenCloud')
                         dvql = CommonService.qs_to_list(dvqs)
                         ubqs = UID_Bucket.objects.filter(uid=UID). \
                             values('bucket__content', 'status', 'channel', 'endTime', 'uid')
@@ -306,8 +306,7 @@ 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')
             dvls = CommonService.qs_to_list(dvql)
             uid_list = []
             for dvl in dvls:
@@ -486,7 +485,7 @@ 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')
 
                 dvls = CommonService.qs_to_list(device_qs)
                 uid_list = []

Controller/IotCoreController.py

@@ -8,8 +8,10 @@ import uuid
 import boto3
 from django.views import View
 
-from Model.models import Device_User, Device_Info, RegionCountryModel, iotdeviceInfoModel
-from Object.IOTCore.IotObject import ChinaIOTClient, AsiaIOTClient, EuropeIOTClient, AmericaIOTClient
+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,75 +22,34 @@ 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]
-
-                if user_region.region_id == 1:
-                    iotClient = ChinaIOTClient()
-
-                    return response.json(0, {'res': iotClient.create_provisioning_claim('Ansjer_Iot_Queue')})
-                elif user_region.region_id == 2:
-                    iotClient = AsiaIOTClient()
-                    return response.json(0, {'res': iotClient.create_provisioning_claim('Ansjer_Iot_Queue')})
-                elif user_region.region_id == 3:
-                    iotClient = EuropeIOTClient()
-                    return response.json(0, {'res': iotClient.create_provisioning_claim('Ansjer_Iot_Queue')})
-                else:
-                    iotClient = AmericaIOTClient()
-                    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)
 
-        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:
+            uid_code = CommonService.decode_data(serial_number_code)
             token = int(CommonService.decode_data(token))
             time_stamp = int(time_stamp)
 
@@ -96,52 +57,44 @@ class IotCoreView(View):
             distance = now_time - time_stamp
 
             # 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]
-
-                    if user_region.region_id == 1:
-                        iotClient = ChinaIOTClient()
-
-                    elif user_region.region_id == 2:
-                        iotClient = AsiaIOTClient()
-
-                    elif user_region.region_id == 3:
-                        iotClient = EuropeIOTClient()
-
-                    else:
-                        iotClient = AmericaIOTClient()
-                    res = iotClient.create_keys_and_certificate(uid)
-                    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, device_version)
+                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
+                                                  )
+                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

@@ -8,7 +8,7 @@ from django.db import transaction
 from django.views import View
 
 from Model.models import SerialNumberModel, CompanySerialModel, UIDCompanySerialModel, CompanyModel, RegionModel, \
-    CountryModel, UIDModel, RegionCountryModel, Device_Info, iotdeviceInfoModel
+    CountryModel, UIDModel, Device_Info, iotdeviceInfoModel
 from Object.RedisObject import RedisObject
 from Object.uidManageResponseObject import uidManageResponseObject
 from Object.TokenObject import TokenObject
@@ -209,17 +209,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]
 
@@ -262,8 +251,7 @@ class SerialNumberView(View):
                                 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 +265,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 +329,11 @@ 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()
+                iotdeviceInfoModel.objects.filter(serial_number__serial_number=serial).delete()
 
                 company_serial_qs = CompanySerialModel.objects.filter(id=uid_serial.company_serial.id)
                 if company_serial_qs.exists():

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,6 @@ 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令牌')
     ###
     REQUIRED_FIELDS = []
 
@@ -1551,13 +1533,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

@@ -21,99 +21,35 @@ class IOTObject(metaclass=ABCMeta):
         pass
 
 
-class ChinaIOTClient(IOTObject):
+class IOTClient(IOTObject):
 
-    def __init__(self):
-        self.client = boto3.client('iot', region_name=AWS_IOT_SES_ACCESS_CHINA_REGION,
-                                   aws_access_key_id=AWS_IOT_SES_ACCESS_CHINA_ID,
-                                   aws_secret_access_key=AWS_IOT_SES_ACCESS_CHINA_SECRET)
+    def __init__(self, region_id = 1):
 
-    def create_provisioning_claim(self, templateName):
+        if region_id == 1:
+            self.client = boto3.client('iot', region_name=AWS_IOT_SES_ACCESS_CHINA_REGION,
+                                       aws_access_key_id=AWS_IOT_SES_ACCESS_CHINA_ID,
+                                       aws_secret_access_key=AWS_IOT_SES_ACCESS_CHINA_SECRET)
+            self.endpoint = 'a250bbr0p9u7as-ats.iot.cn-northwest-1.amazonaws.com.cn'
 
-        result = self.client.create_provisioning_claim(templateName=templateName)
+        if region_id == 2:
+            self.client = boto3.client('iot', region_name=AWS_IOT_SES_ACCESS_FOREIGN_REGION_ASIA,
+                                       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.ap-southeast-1.amazonaws.com'
 
-        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'
-        }
-        return res
+        if region_id == 3:
+            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.eu-west-1.amazonaws.com'
 
-    def create_keys_and_certificate(self, uid):
-        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"
-                }
-            },
-            "Resources": {
-                "thing": {
-                    "Type": "AWS::IoT::Thing",
-                    "Properties": {
-                        "AttributePayload": {},
-                        "ThingGroups": [],
-                        "ThingName": {
-                            "Ref": "ThingName"
-                        },
-                    },
-                    "OverrideSettings": {
-                        "AttributePayload": "MERGE",
-                        "ThingTypeName": "REPLACE",
-                        "ThingGroups": "DO_NOTHING"
-                    }
-                },
-                "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,
-                      "AWS::IoT::Certificate::Id": res['certificateId']}
-        self.client.register_thing(
-            templateBody=templateBody,
-            parameters=parameters
-        )
-        return res, parameters
+        if region_id == 4:
+            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.us-east-1.amazonaws.com'
 
 
-class AmericaIOTClient(IOTObject):
-
-    def __init__(self):
-        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)
 
     def create_provisioning_claim(self, templateName):
 
@@ -124,104 +60,18 @@ class AmericaIOTClient(IOTObject):
             'certificatePem': result['certificatePem'],
             'publicKey': result['keyPair']['PublicKey'],
             'privateKey': result['keyPair']['PrivateKey'],
-            'endpoint': 'a2rqy12o004ad8-ats.iot.us-east-1.amazonaws.com'
+            'endpoint': self.endpoint
         }
         return res
 
-    def create_keys_and_certificate(self, uid):
+    def create_keys_and_certificate(self, serial_number, 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': 'a2rqy12o004ad8-ats.iot.us-east-1.amazonaws.com'
-        }
-        # 根据证书ID注册物品和策略
-        templateBody = {
-            "Parameters": {
-                "ThingName": {
-                    "Type": "String"
-                },
-                "SerialNumber": {
-                    "Type": "String"
-                },
-                "DeviceLocation": {
-                    "Type": "String"
-                },
-                "AWS::IoT::Certificate::Id": {
-                    "Type": "String"
-                }
-            },
-            "Resources": {
-                "thing": {
-                    "Type": "AWS::IoT::Thing",
-                    "Properties": {
-                        "AttributePayload": {},
-                        "ThingGroups": [],
-                        "ThingName": {
-                            "Ref": "ThingName"
-                        },
-                    },
-                    "OverrideSettings": {
-                        "AttributePayload": "MERGE",
-                        "ThingTypeName": "REPLACE",
-                        "ThingGroups": "DO_NOTHING"
-                    }
-                },
-                "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,
-                      "AWS::IoT::Certificate::Id": res['certificateId']}
-        self.client.register_thing(
-            templateBody=templateBody,
-            parameters=parameters
-        )
-        return res, parameters
-
-
-class AsiaIOTClient(IOTObject):
-
-    def __init__(self):
-        self.client = boto3.client('iot', region_name=AWS_IOT_SES_ACCESS_FOREIGN_REGION_ASIA,
-                                   aws_access_key_id=AWS_IOT_SES_ACCESS_FOREIGN_ID,
-                                   aws_secret_access_key=AWS_IOT_SES_ACCESS_FOREIGN_SECRET)
-
-    def create_provisioning_claim(self, templateName):
-        result = self.client.create_provisioning_claim(templateName=templateName)
-
-        res = {
-            'certificateId': result['certificateId'],
-            'certificatePem': result['certificatePem'],
-            'publicKey': result['keyPair']['PublicKey'],
-            'privateKey': result['keyPair']['PrivateKey'],
-            'endpoint': 'a2rqy12o004ad8-ats.iot.ap-southeast-1.amazonaws.com'
-        }
-        return res
-
-    def create_keys_and_certificate(self, uid):
-        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': 'a2rqy12o004ad8-ats.iot.ap-southeast-1.amazonaws.com'
+            'endpoint': 'a250bbr0p9u7as-ats.iot.cn-northwest-1.amazonaws.com.cn'
         }
         # 根据证书ID注册物品和策略
         templateBody = {
@@ -244,10 +94,11 @@ class AsiaIOTClient(IOTObject):
                     "Type": "AWS::IoT::Thing",
                     "Properties": {
                         "AttributePayload": {},
-                        "ThingGroups": [],
+                        # "ThingGroups" : ["v1-lightbulbs", {"Ref" : "DeviceLocation"}],
                         "ThingName": {
                             "Ref": "ThingName"
                         },
+                        "ThingGroups": []
                     },
                     "OverrideSettings": {
                         "AttributePayload": "MERGE",
@@ -272,7 +123,8 @@ class AsiaIOTClient(IOTObject):
         }
 
         templateBody = json.dumps(templateBody)
-        parameters = {"ThingName": "Ansjer_Device_" + uid,
+        parameters = {"ThingName": "Ansjer_Device_" + serial_number,
+                      #"DeviceLocation": device_version,
                       "AWS::IoT::Certificate::Id": res['certificateId']}
         self.client.register_thing(
             templateBody=templateBody,
@@ -280,88 +132,3 @@ class AsiaIOTClient(IOTObject):
         )
         return res, parameters
 
-
-class EuropeIOTClient(IOTObject):
-
-    def __init__(self):
-        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)
-
-    def create_provisioning_claim(self, templateName):
-        result = self.client.create_provisioning_claim(templateName=templateName)
-
-        res = {
-            'certificateId': result['certificateId'],
-            'certificatePem': result['certificatePem'],
-            'publicKey': result['keyPair']['PublicKey'],
-            'privateKey': result['keyPair']['PrivateKey'],
-            'endpoint': 'a2rqy12o004ad8-ats.iot.eu-west-1.amazonaws.com'
-        }
-        return res
-
-    def create_keys_and_certificate(self, uid):
-        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': 'a2rqy12o004ad8-ats.iot.eu-west-1.amazonaws.com'
-        }
-        # 根据证书ID注册物品和策略
-        templateBody = {
-            "Parameters": {
-                "ThingName": {
-                    "Type": "String"
-                },
-                "SerialNumber": {
-                    "Type": "String"
-                },
-                "DeviceLocation": {
-                    "Type": "String"
-                },
-                "AWS::IoT::Certificate::Id": {
-                    "Type": "String"
-                }
-            },
-            "Resources": {
-                "thing": {
-                    "Type": "AWS::IoT::Thing",
-                    "Properties": {
-                        "AttributePayload": {},
-                        "ThingGroups": [],
-                        "ThingName": {
-                            "Ref": "ThingName"
-                        },
-                    },
-                    "OverrideSettings": {
-                        "AttributePayload": "MERGE",
-                        "ThingTypeName": "REPLACE",
-                        "ThingGroups": "DO_NOTHING"
-                    }
-                },
-                "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,
-                      "AWS::IoT::Certificate::Id": res['certificateId']}
-        self.client.register_thing(
-            templateBody=templateBody,
-            parameters=parameters
-        )
-        return res, parameters