class CodecAdminSchema(CodecSchema):
productID = EmqString(dump_only=True)
code = EmqString(dump_only=True, len_max=100000)
codeStatus = EmqInteger(required=True)
reviewOpinion = EmqString(len_max=1000)
class AlertActionSchema(BaseSchema):
alertName = EmqString(required=True)
alertContent = EmqString(required=True)
alertSeverity = EmqInteger(required=True, validate=OneOf([1, 2, 3, 4]))
class PublishActionSchema(PublishSchema):
is_private = True
deviceIntID = EmqInteger(dump_only=True)
protocol = EmqString()
prefixTopic = EmqString(len_max=1000)
class LogoInfoSchema(BaseSchema):
logo = EmqInteger()
sign = EmqInteger()
icon = EmqInteger()
logoDark = EmqInteger()
class RuleSchema(BaseSchema):
ruleName = EmqString(required=True)
sql = EmqString(required=True, len_max=1000)
fromTopics = fields.Nested(FromTopicSchema, allow_none=True, many=True)
scopeData = fields.Nested(ScopeDataSchema)
ruleType = EmqInteger(required=True, validate=OneOf([1, 2]))
remark = EmqString(allow_none=True)
enable = EmqInteger(allow_none=True, validate=OneOf([0, 1]))
actions = fields.Nested(ActionSchema,
only='id',
required=True,
many=True,
dump_only=True)
userIntID = EmqInteger(dump_only=True)
tenantID = EmqString(dump_only=True)
@validates('ruleName')
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')
@validates_schema
def validate_rule_meta(self, data):
rule_type = data.get('ruleType')
# fromTopics is required when ruleType=1
if rule_type == 1 and not data.get('fromTopics'):
raise ValidationError(
fields.Field.default_error_messages['required'],
['fromTopics'])
# scopeData is required when ruleType=2
if rule_type == 2 and not data.get('scopeData'):
raise ValidationError(
fields.Field.default_error_messages['required'], ['scopeData'])
@pre_load()
def remove_from_topics(self, data):
if data.get('ruleType') == 1:
data.pop('scopeData', None)
elif data.get('ruleType') == 2:
data.pop('fromTopics', None)
@post_load()
def add_tenant_prefix(self, data):
sql = data.get('sql')
new_sql = _add_tenant_to_sql(sql)
data['sql'] = new_sql
return data
@post_dump()
def remove_tenant_prefix(self, data):
sql = data.get('sql')
new_sql = _remove_tenant_from_sql(sql)
data['sql'] = new_sql
return data
class MessageSchema(BaseSchema):
msgTitle = EmqString(required=True)
msgContent = EmqString(required=True)
messageType = EmqInteger(required=True)
class InvitationSchema(BaseSchema):
userIntID = EmqInteger(allow_none=True)
inviteEmail = EmqEmail(required=True)
roleIntID = EmqInteger(required=True)
tenantID = EmqString(allow_none=True, len_max=9)
inviteStatus = EmqInteger(allow_none=True, validate=OneOf([0, 1]))
class TenantSchema(BaseSchema):
tenantType = EmqInteger(required=True, validate=OneOf([1, 2]))
tenantID = EmqString(allow_none=True, len_max=9)
company = EmqString(allow_none=True)
companySize = EmqString(allow_none=True)
companyAddress = EmqString(allow_none=True)
contactPerson = EmqString(allow_none=True)
contactPhone = EmqString(allow_none=True)
contactEmail = EmqEmail(allow_none=True)
enable = EmqInteger(dump_only=True)
tenantBalance = EmqFloat(dump_only=True)
invoiceBalance = EmqFloat(dump_only=True)
logo = EmqInteger()
logoDark = EmqInteger()
@validates('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')
@post_dump
def convert_image(self, data):
logo_id = data.get('logo')
logo_dark_id = data.get('logoDark')
logo = UploadInfo.query.filter(UploadInfo.id == logo_id).first()
logo_dark = UploadInfo.query.filter(
UploadInfo.id == logo_dark_id).first()
if logo:
logo_light_info = {
'name': logo.displayName,
'uploadID': logo.id,
'url':
f'/api/v1/download?fileType=image&filename={logo.fileName}'
}
else:
file_name = 'logo.png'
logo_light_info = {
'name': file_name,
'uploadID': 0,
'url': '/backend_static/images/%s' % file_name
}
if logo_dark:
logo_dark_info = {
'name':
logo_dark.displayName,
'uploadID':
logo_dark.id,
'url':
f'/api/v1/download?fileType=image&filename={logo_dark.fileName}'
}
else:
file_name = 'logo-dark.png'
logo_dark_info = {
'name': file_name,
'uploadID': 0,
'url': '/backend_static/images/%s' % file_name
}
data['logo'] = logo_light_info
data['logoDark'] = logo_dark_info
return data
class Lwm2mDeviceSchema(BaseSchema):
is_private = True
autoSub = EmqInteger(required=True, validate=OneOf([0, 1]))
IMEI = EmqString(required=True, len_max=15)
IMSI = EmqString(required=True, len_max=15)
class EndDeviceSchema(DeviceSchema):
loraData = EmqDict(allow_none=True) # lora data extend
lwm2mData = EmqDict(allow_none=True) # lwm2m data extend
upLinkSystem = EmqInteger(required=True) # 1:cloud 2:device 3:gateway
parentDevice = EmqInteger(allow_none=True)
gateway = EmqInteger(allow_none=True)
cloudProtocol = EmqInteger(load_only=True)
@validates('deviceName')
def device_name_is_exist(self, value):
if self._validate_obj('deviceName', value):
return
device_name = EndDevice.query \
.filter_tenant(tenant_uid=g.tenant_uid) \
.filter(EndDevice.deviceName == value) \
.with_entities(EndDevice.deviceName).first()
if device_name:
raise DataExisted(field='deviceName')
@validates_schema
def validate_uplink_system(self, data):
uplink_system = data.get('upLinkSystem')
if uplink_system == 1:
data['parentDevice'], data['gateway'] = None, None
elif uplink_system == 2 and isinstance(data.get('parentDevice'), int):
parent_device = data['parentDevice']
end_device_id = EndDevice.query \
.filter_tenant(tenant_uid=g.tenant_uid) \
.filter(EndDevice.id == parent_device) \
.with_entities(EndDevice.id).first()
if not end_device_id:
raise DataNotFound(field='parentDevice')
data['parentDevice'], data['gateway'] = end_device_id, None
elif uplink_system == 3 and isinstance(data.get('gateway'), int):
gateway = data['gateway']
gateway_id = Gateway.query \
.filter_tenant(tenant_uid=g.tenant_uid) \
.filter(Gateway.id == gateway) \
.with_entities(Gateway.id).first()
if not gateway_id:
raise DataNotFound(field='gateway')
data['parentDevice'], data['gateway'] = None, gateway_id
else:
raise FormInvalid(field='upLinkSystem')
return data
@validates_schema
def validate_cloud_protocol(self, data):
cloud_protocol = data.get('cloudProtocol')
if cloud_protocol in [1, 2, 5, 6, 7]:
# mqtt, coap, http, websocket, modbus
data['loraData'], data['lwm2mData'] = None, None
elif cloud_protocol == 3 and data.get('lwm2mData'):
# lwm2m data
data['loraData'] = None
data['lwm2mData'] = Lwm2mDeviceSchema().load(
data['lwm2mData']).data
data['deviceID'] = data['lwm2mData']['IMEI']
elif cloud_protocol == 4 and data.get('loraData'):
# lora data
data['lwm2mData'] = None
data['loraData'] = LoRaDeviceSchema().load(data['loraData']).data
else:
error_fields = {3: 'lwm2mData', 4: 'loraData'}
raise FormInvalid(
field=error_fields.get(cloud_protocol, 'cloudProtocol'))
return data
@post_dump
def handle_uplink_system(self, data):
if data['upLinkSystem'] == 2:
parentDevice = data['parentDevice']
parent_device = Device.query.filter(Device.id == parentDevice) \
.with_entities(Device.deviceName).first()
data['parentDeviceName'] = parent_device.deviceName
elif data['upLinkSystem'] == 3:
gateway = data['gateway']
gateway = Device.query.filter(Device.id == gateway) \
.with_entities(Device.deviceName).first()
data['gatewayName'] = gateway.deviceName
return data