thingsboard_api/TB/delete.js

Thingsboard REST API implementation

const fetch = require('node-fetch');
const get = require('./get.js');

const possibleEntityTypes = {
  device: 'DEVICE',
  asset: 'ASSET',
  view: 'ENTITY_VIEW',
};

async function deleteEntity(name, entityType, flagDeleteChilds = null) {
  if (((typeof name === 'undefined') || (name === null)) || ((typeof entityType === 'undefined') || (entityType === null))) {
    return { error: true, message: 'deleteEntity(), Error: name or entityType are not defined' };
  }
  const id = await get.objectID(name, entityType);

  if (id.error) {
    return { error: true, message: id.message };
  }

  if (flagDeleteChilds) {
    const statusDeleteChilds = await deleteChilds(name, entityType);
    if (statusDeleteChilds.error) {
      return { error: true, message: `Delete child error: ${statusDeleteChilds.message} `};
    }

    if (statusDeleteChilds.success) {
      console.log(`Children for ${name} were deleted successfully!`);
    }
  }

  let url = '';
  if ((entityType.toUpperCase() === possibleEntityTypes.device) || (entityType.toUpperCase() === possibleEntityTypes.asset)) {
    url = `http://${process.env.TB_HOST}:${process.env.TB_PORT}/api/${entityType.toLowerCase()}/${id}`;
  }

  if (entityType.toLowerCase() === possibleEntityTypes.view) {
    url = `http://${process.env.TB_HOST}:${process.env.TB_PORT}/api/entityView/${id}`;
  }
  try {
    const post = await fetch(url, {
      method: 'delete',
      headers: {
        'Content-Type': 'application/json',
        'X-Authorization': `Bearer ${process.env[tokenRand+'TB_TOKEN']}`,
      },
    });

    const ans = await post.text();

    if (ans !== '') return { error: true, message: 'deleteEntity(), Error while deleting entity!' };
    if (ans === '') return { success: true };
  } catch (err) {
    return { error: true, message: `deleteEntity(), Error: ${err}` };
  }
}

async function deleteEntitiesByType(type, entityType) {
  if (((typeof type === 'undefined') || (type === null)) || ((typeof entityType === 'undefined') || (entityType === null))) {
    return { error: true, message: 'deleteEntitiesByType(), type or entity_type are not defined or null' };
  }

  const loweredType = entityType.toLowerCase();
  try {
    const ids = await get.allObjectsIDbyType(type, loweredType);
    if (ids.error) {
      return { error: true, message: ids.message };
    }
    for (let i = 0; i < ids.length; i += 1) {
      const result = await deleteEntity(ids[i].name, loweredType, false);
      // skip while error happens!
      if (result.error) {
        continue;
      }
    }
    return { success: true };
  } catch (err) {
    return { error: true, message: `delenteEntitiesByType(), Error: ${err}` };
  }
}

async function deleteChilds(name, entityType) {
  if (((typeof name === 'undefined') || (name === null)) || ((typeof entityType === 'undefined') || (entityType === null))) {
    return { error: true, message: 'deleteChilds(), name or entity_type are not defined or null' };
  }
  try {
    // set max level by default!
    const childs = await get.relations(name, entityType, 'to', 1);
    if (childs.error) {
      return { error: true, message: childs.message };
    }
    for (let i = 0; i < childs.length; i += 1) {
      const response = await deleteEntity(childs[i].name, childs[i].entity_type, true);
      // skip while error happens!
      if (response.error) {
        continue;
      }
    }
    return { success: true };
  } catch (err) {
    return { error: true, message: `deleteChilds(), Error: ${err}` };
  }
}

async function clearAlarm(alarmId) {
  if (typeof alarmId === 'undefined' || alarmId === null) {
    return { error: true, message: 'clearAlarm(), alarmId is not defined or null!' };
  }

  const url = `http://${process.env.TB_HOST}:${process.env.TB_PORT}/api/alarm/${alarmId}/clear`;
  const body = {
    alarmId: alarmId
  };
  const payload = {
    method: 'post',
    body: JSON.stringify(body),
    headers: {
      'Content-Type': 'application/json',
      'X-Authorization': `Bearer ${process.env[tokenRand+'TB_TOKEN']}`,
    },
  };

  try {
    const response = await fetch(url, payload);
    if (response.status === 200) {
      return { success: true };
    }

    return { error: true, message: `Response status ${response.status}`};
  } catch (err) {
    return { error: true, message: `clearAlarm(), Error: ${err}` };
  }
}


async function deleteRelation(fromId, fromType, toId, toType, relationType=null){
  if(relationType == null)
  relationType ='Contains'
  
    const url = `http://${process.env.TB_HOST}:${process.env.TB_PORT}/api/relation?fromId=${fromId}&fromType=${fromType}&toId=${toId}&toType=${toType}&relationType=${relationType}`;
    const payload = {
      method: 'delete',
      headers: {
        'Content-Type': 'application/json',
        'X-Authorization': `Bearer ${process.env[tokenRand+'TB_TOKEN']}`,
      },
    };
  
    try {
      const response = await fetch(url, payload);
      if (response.status === 200) {
        return { success: true };
      }
  
      return { error: true, message: `Response status ${response.status}`};
    } catch (err) {
      return { error: true, message: `clearAlarm(), Error: ${err}` };
    }


}

module.exports = {
  deleteEntity,
  deleteChilds,
  deleteEntitiesByType,
  clearAlarm,
  deleteRelation
};