async def set_device_default_value(device_info):
if device_info.get('upLinkSystem') != 3:
device_info['gateway'] = None
if device_info.get('upLinkSystem') == 3 and not device_info.get('gateway'):
device_info['upLinkSystem'] = 1
device_info['gateway'] = None
if device_info.get('cloudProtocol') == 3:
# lwm2m protocol
if device_info.get('deviceID'):
imei = device_info['deviceID']
else:
imei = generate_uuid(size=15)
device_info['deviceID'] = imei
lwm2m_data = {
'autoSub': 0,
'IMEI': imei,
'IMSI': imei
}
device_info['lwm2mData'] = json.dumps(lwm2m_data)
if not device_info.get('deviceID'):
device_info['deviceID'] = generate_uuid()
if not device_info.get('deviceUsername'):
device_info['deviceUsername'] = generate_uuid()
if not device_info.get('token'):
device_info['token'] = device_info['deviceUsername']
if not device_info.get('token'):
device_info['token'] = device_info['deviceUsername']
device_info['upLinkNetwork'] = 1
device_info['deviceType'] = 1 # end_devices
return device_info
async def device_publish_task(request_dict) -> TaskResult:
"""
:param request_dict:
required key: topic, prefixTopic,
payload, deviceID, tenantID, protocol
optional key: streamID
"""
request_dict['taskID'] = generate_uuid() # emqx publish taskID
device_uid = request_dict['deviceID']
task_id = request_dict['taskID']
if not request_dict.get('streamID'):
request_dict['streamID'] = None
# insert publish logs
insert_sql = insert_publish_logs_sql.format(**request_dict)
insert_status = await db.execute(sql=insert_sql)
if not insert_status:
message = f"insert {device_uid} publish logs errors!"
return get_task_result(status=4, message=message)
# get publish json
request_dict['payload'] = json.loads(request_dict['payload'])
publish_json_func = PROTOCOL_PUBLISH_JSON_FUNC.get(
request_dict['protocol'])
if not publish_json_func:
message = f"{device_uid} publish not support this protocol"
return get_task_result(status=4, message=message)
publish_json = publish_json_func(request_dict)
# emqx publish
task_result = await _emqx_device_publish(publish_json, device_uid, task_id)
return task_result
def validate_webhook(self, data):
url = data.get('url')
token = data.get('token')
if not all([url, token]):
return
timestamp = int(time.time())
nonce = generate_uuid(size=10)
hash_str = f"{token}{timestamp}{nonce}".encode('utf-8')
signature = hashlib.sha1(hash_str).hexdigest()
validate_status = True
params = dict(signature=signature, timestamp=timestamp, nonce=nonce)
with SyncHttp() as sync_http:
response = sync_http.get(url=url, params=params)
if response.responseCode != 200:
validate_status = False
try:
response_dict = json.loads(response.responseContent)
if response_dict.get('nonce') != params.get('nonce'):
validate_status = False
except Exception as e:
logger.error(f"Webhook {e}", exc_info=True)
validate_status = False
if not validate_status:
raise FormInvalid(field='Webhook url')
class ActorBackgroundTask(BackgroundTask):
taskID = generate_uuid()
def __init__(self, func: Callable, *args: Any, **kwargs: Any):
self.func = func
self.args = args
self.kwargs = kwargs
super().__init__(func, *args, **kwargs)
def random_group_uid():
""" Generate a 6-bit group identifier """
group_uid = generate_uuid(size=6)
group = db.session.query(db.func.count(Group.id)) \
.filter(Group.groupID == group_uid).scalar()
if group:
group_uid = random_group_uid()
return group_uid
def random_product_uid():
""" Generate a 6-bit product identifier """
product_uid = generate_uuid(size=6, str_type='char')
product = db.session.query(Product.id) \
.filter(Product.productID == product_uid).first()
if product:
product_uid = random_product_uid()
return product_uid
def random_app_uid():
""" Generate a 6-bit app identifier """
app_uid = generate_uuid(size=6)
application = db.session.query(func.count(Application.id)) \
.filter(Application.appID == app_uid).scalar()
if application:
app_uid = random_app_uid()
return app_uid
def create_cert():
request_dict = CertSchema.validate_request()
request_dict.update(generate_cert())
cert = Cert()
created_cert = cert.create(request_dict)
record = created_cert.to_dict()
record['root'] = {'fileName': 'root_ca.crt', 'content': record['root']}
_uid = generate_uuid()
record['cert'] = {'fileName': f"{_uid}.crt", 'content': record['cert']}
record['key'] = {'fileName': f"{_uid}.key", 'content': record['key']}
return jsonify(record), 201
def device_publish():
request_dict = PublishSchema.validate_request()
# # create publish logs
request_dict['taskID'] = generate_uuid()
request_dict['publishStatus'] = 1
request_dict['payload'] = json.loads(request_dict['payload'])
client_publish_log = PublishLog()
created_publish_log = client_publish_log.create(request_dict)
# get publish json of protocol
publish_json_func = PROTOCOL_PUBLISH_JSON_FUNC.get(request_dict['protocol'])
if not publish_json_func:
raise FormInvalid(field='cloudProtocol')
publish_json = publish_json_func(request_dict)
record = _emqx_client_publish(publish_json, created_publish_log)
return jsonify(record)
async def store_task(func, *, func_args=None, func_kwargs=None):
func_path = qualname(func) # import_module
task = ActorTask()
task.taskStatus = 1
task.createAt = datetime.now()
task.taskID = generate_uuid()
task.taskName = func_path.split('.')[-1]
task_info = {
'path': func_path,
'args': func_args if func_args else [],
'kwargs': func_kwargs if func_kwargs else {}
}
task.taskInfo = json.dumps(task_info)
_actor_task = task.to_dict()
await db.execute(insert_task_sql.format(**_actor_task))
return task.taskID
def get_rule_json(rule):
rule_actions = []
for action in rule.actions:
if action.actionType == 1:
alert_dict = AlertActionSchema().dump(action.config).data
action_config = {
'webhook': {
**alert_dict, 'url':
current_app.config.get('CURRENT_ALERT_URL'),
'ruleIntID':
rule.id
}
}
elif action.actionType == 2:
email_dict = EmailActionSchema().dump(action.config).data
action_config = {'mail': email_dict}
elif action.actionType == 3:
webhook_dict = WebhookActionSchema().dump(action.config).data
action_config = {'webhook': webhook_dict}
elif action.actionType == 4:
publish_dict = PublishActionSchema().dump(action.config).data
publish_dict['taskID'] = generate_uuid()
publish_json_func = PROTOCOL_PUBLISH_JSON_FUNC.get(
publish_dict['protocol'])
if not publish_json_func:
raise FormInvalid(field='cloudProtocol')
publish_json = publish_json_func(publish_dict)
action_config = {'publish': {'json': json.dumps(publish_json)}}
elif action.actionType == 5:
mqtt_dict = MqttActionSchema().dump(action.config).data
action_config = {'mqtt': mqtt_dict}
else:
continue
rule_actions.append(action_config)
rule_json = {
'id': rule.id,
'sql': rule.sql,
'enabled': rule.enable == 1,
'actions': rule_actions
}
return rule_json
class Device(BaseModel):
__tablename__ = 'devices'
deviceName = db.Column(db.String(50))
deviceType = db.Column(db.Integer) # 1:end_device 2:gateway
deviceID = db.Column(db.String(50))
deviceUsername = db.Column(db.String(50))
token = db.Column(db.String(50), default=generate_uuid(size=36))
authType = db.Column(db.SmallInteger, server_default='1') # 1:token 2:cert
lastConnection = db.Column(db.DateTime)
blocked = db.Column(db.SmallInteger, server_default='0') # 0:false 1:true
deviceStatus = db.Column(db.SmallInteger,
server_default='0') # 0:offline 1:online 2:sleep
location = db.Column(db.String(300))
longitude = db.Column(db.Float)
latitude = db.Column(db.Float)
softVersion = db.Column(db.String(50))
hardwareVersion = db.Column(db.String(50))
manufacturer = db.Column(db.String(50))
serialNumber = db.Column(db.String(100))
deviceConsoleIP = db.Column(db.String(50))
deviceConsoleUsername = db.Column(db.String(50))
deviceConsolePort = db.Column(db.Integer, server_default='22')
carrier = db.Column(db.Integer, server_default='1')
upLinkNetwork = db.Column(db.Integer) # 1:2G, 2:3G.....
description = db.Column(db.String(300))
mac = db.Column(db.String(50))
metaData = db.Column(JSONB) # meta data
groups = db.relationship('Group', secondary=GroupDevice,
lazy='dynamic') # device groups
certs = db.relationship('Cert', secondary=CertDevice,
lazy='dynamic') # device certs
productID = db.Column(db.String, db.ForeignKey('products.productID'))
userIntID = db.Column(db.Integer, db.ForeignKey('users.id'))
tenantID = db.Column(
db.String,
db.ForeignKey('tenants.tenantID',
onupdate="CASCADE",
ondelete="CASCADE"))
__mapper_args__ = {'polymorphic_on': deviceType}
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
