def validate_invite_email(self, value):
email = Invitation.query \
.filter_tenant(tenant_uid=g.tenant_uid)\
.filter(Invitation.inviteEmail == value).first()
if email:
raise DataExisted(field='inviteEmail')
email = User.query.filter(User.email == value).first()
if email:
raise DataExisted(field='email')
def validate_app_name(self, value):
if self._validate_obj('appName', value):
return
app = Application.query \
.filter_tenant(tenant_uid=g.tenant_uid) \
.filter(Application.appName == value).first()
if app:
raise DataExisted(field='appName')
def name_is_exist(self, value):
if self._validate_obj('certName', value):
return
query = db.session.query(Cert.certName) \
.filter_tenant(tenant_uid=g.tenant_uid) \
.filter(Cert.certName == value).first()
if query:
raise DataExisted(field='certName')
def is_exist(self, value):
if self._validate_obj('productName', value):
return
product_name = db.session.query(Product.productName) \
.filter_tenant(tenant_uid=g.tenant_uid) \
.filter(Product.productName == value).first()
if product_name:
raise DataExisted(field='productName')
def email_is_exist(self, value):
try:
split_email = value.split('@')[0]
if split_email in current_app.config.get('RESERVED'):
raise FormInvalid(field='email')
except Exception:
raise FormInvalid(field='email')
if db.session.query(User.email).filter_by(email=value).first():
raise DataExisted(field='email')
def stream_name_is_exist(self, value):
if self._validate_obj('streamName', value):
return
product_uid = self.get_request_data('productID')
stream_name = db.session.query(DataStream.streamName) \
.filter(DataStream.productID == product_uid,
DataStream.streamName == value).first()
if stream_name:
raise DataExisted(field='dataPointName')
def name_is_exist(self, value):
if self._validate_obj('actionName', value):
return
query = db.session.query(Action.actionName) \
.filter(Action.tenantID == g.tenant_uid,
Action.actionName == value).first()
if query:
raise DataExisted(field='actionName')
def role_name_is_exist(self, value):
if self._validate_obj('roleName', value):
return
role = Role.query \
.join(Tenant, Role.tenantID == Tenant.tenantID) \
.filter(Role.roleName == value) \
.filter(Tenant.tenantID == g.tenant_uid).all()
if role:
raise DataExisted(field='roleName')
def group_name_is_exist(self, value):
if self._validate_obj('groupName', value):
return
query = db.session.query(Group.groupName) \
.filter_tenant(tenant_uid=g.tenant_uid) \
.filter(Group.groupName == value).first()
if query:
raise DataExisted(field='groupName')
def device_name_is_exist(self, value):
if self._validate_obj('deviceName', value):
return
device_name = Gateway.query \
.filter_tenant(tenant_uid=g.tenant_uid) \
.filter(Gateway.deviceName == value) \
.with_entities(Gateway.deviceName).first()
if device_name:
raise DataExisted(field='deviceName')
def name_is_exist(self, value):
if self._validate_obj('ruleName', value):
return
query = Rule.query \
.filter_tenant(tenant_uid=g.tenant_uid) \
.filter(Rule.ruleName == value) \
.first()
if query:
raise DataExisted(field='ruleName')
def stream_id_is_exist(self, value):
if self._validate_obj('streamID', value):
return
if not re.match(r"^[a-zA-Z]\w{3,}$", value):
raise FormInvalid(field='streamID')
product_uid = self.get_request_data('productID')
stream_name = db.session.query(DataStream.streamID) \
.filter(DataStream.productID == product_uid,
DataStream.streamID == value).first()
if stream_name:
raise DataExisted(field='streamID')
def validate_point_uid(self, value):
if not value or self._validate_obj('dataPointID', value):
return
if not re.match(r"^[0-9A-Za-z_\-]*$", value):
raise FormInvalid(field='dataPointID')
product_uid = self.get_request_data('productID')
data_point_uid = db.session.query(DataPoint.dataPointID) \
.filter(DataPoint.productID == product_uid,
DataPoint.dataPointID == value).first()
if data_point_uid:
raise DataExisted(field='dataPointID')
def validate_product(self, value):
if self._validate_obj('productID', value):
return
product = db.session.query(Product.id) \
.filter(Product.userIntID == g.user_id, Product.productID == value) \
.first()
if not product:
raise DataNotFound(field='productID')
codec = db.session.query(Codec.id) \
.filter(Codec.tenantID == g.tenant_uid, Codec.productID == value) \
.first()
if codec:
raise DataExisted(field='productID')
def handle_cert_devices(self, data):
devices_id = data['devices']
devices = Device.query \
.filter(Device.id.in_(set(devices_id)), Device.authType == 2) \
.many(allow_none=False, expect_result=len(devices_id))
cert_id = self.get_origin_obj('id')
exist_cert_devices = db.session \
.query(func.count(CertDevice.c.deviceIntID)) \
.filter(CertDevice.c.certIntID == cert_id,
CertDevice.c.deviceIntID.in_(set(devices_id))) \
.scalar()
if exist_cert_devices:
raise DataExisted(field='devices')
data['devices'] = devices
return data
def device_uid_is_exist(self, data):
device_uid = data.get('deviceID')
username = data.get('deviceUsername')
if self.get_origin_obj('deviceID'):
return data
if not device_uid or not username:
device_uuid = generate_uuid(size=36)
data['deviceID'] = device_uuid
data['deviceUsername'] = device_uuid
return data
# unique within the tenant
device_uid = db.session.query(Device.deviceID) \
.filter(Device.deviceID == device_uid,
Device.tenantID == g.tenant_uid).first()
if device_uid:
raise DataExisted(field='deviceID')
# unique within the platform
device = db.session.query(Device.id) \
.filter(Device.deviceID == device_uid,
Device.deviceUsername == username).first()
if device:
raise FormInvalid(field='deviceID')
return data
def company_is_exist(self, value):
if value == '':
raise FormInvalid(field='company')
if Tenant.query.filter_by(company=value).first():
raise DataExisted(field='company')
def company_is_exist(self, value):
tenant_type = request.get_json().get('tenantType')
if value == '':
raise APIException()
if tenant_type == 2 and Tenant.query.filter_by(company=value).first():
raise DataExisted(field='company')
