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