tuain-ecosystem-lib/lib/ecosystem/environment.js

Servicio de gestión mensajería instantanea de la plataforma Tuain

const { ObjectId } = require('mongodb');
const {
  dbQueries: { environment: envQueries },
  collections: {
    environments: environmentsColl, ecosystemRoles: ecosystemRolesColl,
    roleRelations: roleRelationsColl,
  },
} = require('../../config');

const ENV_SEARCH_FIELDS = ['name', 'description'];
const ROLE_SEARCH_FIELDS = ['name', 'description'];

const modErrs = {
  findEnv: {
    notFound: ['01', 'No se encontraron environments que se ajusten a la búsqueda'],
  },
  createEnv: {
    alreadyExist: ['01', 'Environments ya existe'],
  },
  modifyEnv: {
    alreadyActive: ['01', 'Environments ya está activo'],
    alreadyInactive: ['02', 'Environments ya está inactivo'],
  },
  findRole: {
    notFound: ['01', 'No se encontraron roles que se ajusten a la búsqueda'],
  },
  createRole: {
    alreadyExist: ['01', 'Rol ya existe'],
  },
  modifyRole: {
    alreadyActive: ['01', 'Rol ya está activo'],
    alreadyInactive: ['02', 'Rol ya está inactivo'],
  },
  findRelation: {
    notFound: ['01', 'No se encontraron relaciones que se ajusten a la búsqueda'],
  },
  createRelation: {
    alreadyExist: ['01', 'Relación ya existe'],
  },
  modifyRelation: {
    alreadyActive: ['01', 'Relación actualmente está activa'],
    alreadyInactive: ['01', 'Relación ya está inactiva'],
  },
};

class EnvironmentManager {
  constructor(getDb, logger, errMgr, options) {
    this.options = options;
    this.getDb = getDb;
    this.logger = logger;
    this.errMgr = errMgr;
    this.errMgr.addModuleSet('lib-environment', modErrs);
  }

  // eslint-disable-next-line no-unused-vars
  async getEnvironments(reqData = null, constraints = null) {
    const envsCol = this.getDb().collection(environmentsColl);
    const envsList = await envsCol.find(envQueries.findByAttributes(constraints, ENV_SEARCH_FIELDS));
    const environments = (envsList) ? await envsList.toArray() : null;
    if (!environments || environments.length < 1) {
      const errorObj = this.errMgr.get(modErrs.findEnv.notFound);
      return [errorObj, null];
    }
    return [null, { environments }];
  }

  async getEnvironment(reqData) {
    const { environmentId } = reqData;
    const envsCol = this.getDb().collection(environmentsColl);
    const envDetail = await envsCol.findOne(envQueries.findById(environmentId));
    if (!envDetail) {
      const errorDetail = `Environment con Id ${environmentId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findEnv.notFound, errorDetail);
      return [errorObj, null];
    }
    return [null, envDetail];
  }

  async createEnvironment(envData) {
    const { name } = envData;
    const envsCol = this.getDb().collection(environmentsColl);
    const envDetail = await envsCol.findOne(envQueries.findByName(name));
    if (envDetail) {
      const errorDetail = `Environment ${name} ya existe`;
      const errorObj = this.errMgr.get(modErrs.createEnv.alreadyExist, errorDetail);
      return [errorObj, null];
    }
    const newEnvData = { ...envData, enabled: false, creation: new Date() };
    const actionResult = await envsCol.insertOne(newEnvData);
    this.logger.debug(`Creación de un nuevo ambiente ${newEnvData} con resultado ${actionResult?.insertedId}`);
    return [null, { environmentId: actionResult?.insertedId }];
  }

  async modifyEnvironment(reqData) {
    const { environmentId } = reqData;
    const envsCol = this.getDb().collection(environmentsColl);
    const envDetail = await envsCol.findOne(envQueries.findById(environmentId));
    if (!envDetail) {
      const errorDetail = `Environment con Id ${environmentId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findEnv.notFound, errorDetail);
      return [errorObj, null];
    }
    if (envDetail.enabled) {
      const errorDetail = `Environment con Id ${environmentId} activo`;
      const errorObj = this.errMgr.get(modErrs.modifyEnv.alreadyActive, errorDetail);
      return [errorObj, null];
    }
    const updateData = { ...reqData };
    delete updateData.environmentId;
    const actionResult = await envsCol.updateOne(envQueries.findById(environmentId),
      envQueries.updateObj(updateData));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Modificación de un ambiente ${updateData} con resultado ${result}`);
    return [null, { result }];
  }

  async activateEnvironment(reqData) {
    const { environmentId } = reqData;
    const envsCol = this.getDb().collection(environmentsColl);
    const envDetail = await envsCol.findOne(envQueries.findById(environmentId));
    if (!envDetail) {
      const errorDetail = `Environment con Id ${environmentId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findEnv.notFound, errorDetail);
      return [errorObj, null];
    }
    if (envDetail.enabled) {
      const errorDetail = `Environment con Id ${environmentId} actualmente activo`;
      const errorObj = this.errMgr.get(modErrs.modifyEnv.alreadyActive, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await envsCol.updateOne(envQueries.findById(environmentId),
      envQueries.updateObj({ enabled: true }));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Activación del ambiente ${environmentId} con resultado ${result}`);
    return [null, { result }];
  }

  async inactivateEnvironment(reqData) {
    const { environmentId } = reqData;
    const envsCol = this.getDb().collection(environmentsColl);
    const envDetail = await envsCol.findOne(envQueries.findById(environmentId));
    if (!envDetail) {
      const errorDetail = `Environment con Id ${environmentId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findEnv.notFound, errorDetail);
      return [errorObj, null];
    }
    if (!envDetail.enabled) {
      const errorDetail = `Environment con Id ${environmentId} actualmente inactivo`;
      const errorObj = this.errMgr.get(modErrs.modifyEnv.alreadyInactive, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await envsCol.updateOne(envQueries.findById(environmentId),
      envQueries.updateObj({ enabled: false }));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Activación del ambiente ${environmentId} con resultado ${result}`);
    return [null, { result }];
  }

  async deleteEnvironment(reqData) {
    const { environmentId } = reqData;
    const envsCol = this.getDb().collection(environmentsColl);
    const envDetail = await envsCol.findOne(envQueries.findById(environmentId));
    if (!envDetail) {
      const errorDetail = `Environment con Id ${environmentId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findEnv.notFound, errorDetail);
      return [errorObj, null];
    }
    if (envDetail.enabled) {
      const errorDetail = `Environment con Id ${environmentId} actualmente activo`;
      const errorObj = this.errMgr.get(modErrs.modifyEnv.alreadyActive, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await envsCol.deleteOne(envQueries.findById(environmentId));
    this.logger.debug(`Eliminación del ambiente ${environmentId} con resultado ${actionResult?.result?.n}`);
    const result = actionResult?.result?.n > 0;
    return [null, { result }];
  }

  /**
   * Funciones de manejo de roles de un environment
   */

  async getRoles(reqData, constraints = null) {
    const { environmentId } = reqData;
    const rolesCol = this.getDb().collection(ecosystemRolesColl);
    const rolesList = await rolesCol.find(envQueries.findRoles(environmentId,
      constraints,
      ROLE_SEARCH_FIELDS));
    const roles = (rolesList) ? await rolesList.toArray() : null;
    if (!roles || roles.length < 1) {
      const errorObj = this.errMgr.get(modErrs.findRole.notFound);
      return [errorObj, null];
    }
    return [null, { roles }];
  }

  async getRole(reqData) {
    const { roleId } = reqData;
    const rolesCol = this.getDb().collection(ecosystemRolesColl);
    const [roleDetail] = await rolesCol.aggregate(envQueries.findRole(roleId)).toArray();
    if (!roleDetail) {
      const errorDetail = `Rol con Id ${roleId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findRole.notFound, errorDetail);
      return [errorObj, null];
    }
    return [null, roleDetail];
  }

  async createRole(roleData) {
    const { environmentId, name } = roleData;
    const envsCol = this.getDb().collection(environmentsColl);
    const envDetail = await envsCol.findOne(envQueries.findById(environmentId));
    if (!envDetail) {
      const errorDetail = `Environment con Id ${environmentId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findEnv.notFound, errorDetail);
      return [errorObj, null];
    }
    const rolesCol = this.getDb().collection(ecosystemRolesColl);
    const roleDetail = await rolesCol.findOne(envQueries.findRoleByName(environmentId, name));
    if (roleDetail) {
      const errorDetail = `Rol ${name} ya existe en environmentId ${environmentId}`;
      const errorObj = this.errMgr.get(modErrs.createRole.alreadyExist, errorDetail);
      return [errorObj, null];
    }
    delete roleData.environmentId;
    const newRoleData = {
      ...roleData,
      environmentId: ObjectId(environmentId),
      enabled: false,
      creation: new Date(),
    };
    const actionResult = await rolesCol.insertOne(newRoleData);
    this.logger.debug(`Creación de un nuevo rol ${newRoleData} con resultado ${actionResult?.insertedId}`);
    return [null, { roleId: actionResult?.insertedId }];
  }

  async modifyRole(reqData) {
    const { roleId } = reqData;
    const rolesCol = this.getDb().collection(ecosystemRolesColl);
    const roleDetail = await rolesCol.findOne(envQueries.findById(roleId));
    if (!roleDetail) {
      const errorDetail = `Rol con Id ${roleId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findRole.notFound, errorDetail);
      return [errorObj, null];
    }
    const updateData = { ...reqData };
    delete updateData.roleId;
    if (updateData.environmentId) {
      updateData.environmentId = ObjectId(updateData.environmentId);
    }
    const actionResult = await rolesCol.updateOne(envQueries.findById(roleId),
      envQueries.updateObj(updateData));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Modificación de rol ${updateData} con resultado ${result}`);
    return [null, { result }];
  }

  async activateRole(reqData) {
    const { roleId } = reqData;
    const rolesCol = this.getDb().collection(ecosystemRolesColl);
    const roleDetail = await rolesCol.findOne(envQueries.findById(roleId));
    if (!roleDetail) {
      const errorDetail = `Role con Id ${roleId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findRole.notFound, errorDetail);
      return [errorObj, null];
    }
    if (roleDetail.enabled) {
      const errorDetail = `Rol con Id ${roleId} actualmente activo`;
      const errorObj = this.errMgr.get(modErrs.modifyRole.alreadyActive, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await rolesCol.updateOne(envQueries.findById(roleId),
      envQueries.updateObj({ enabled: true }));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Activación del rol ${roleId} con resultado ${result}`);
    return [null, { result }];
  }

  async inactivateRole(reqData) {
    const { roleId } = reqData;
    const rolesCol = this.getDb().collection(ecosystemRolesColl);
    const roleDetail = await rolesCol.findOne(envQueries.findById(roleId));
    if (!roleDetail) {
      const errorDetail = `Rol con Id ${roleId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findRole.notFound, errorDetail);
      return [errorObj, null];
    }
    if (!roleDetail.enabled) {
      const errorDetail = `Rol con Id ${roleId} actualmente inactivo`;
      const errorObj = this.errMgr.get(modErrs.modifyRole.alreadyInactive, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await rolesCol.updateOne(envQueries.findById(roleId),
      envQueries.updateObj({ enabled: false }));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Inactivación del rol ${roleId} con resultado ${result}`);
    return [null, { result }];
  }

  async deleteRole(reqData) {
    const { roleId } = reqData;
    const rolesCol = this.getDb().collection(ecosystemRolesColl);
    const roleDetail = await rolesCol.findOne(envQueries.findById(roleId));
    if (!roleDetail) {
      const errorDetail = `Role con Id ${roleId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findRole.notFound, errorDetail);
      return [errorObj, null];
    }
    if (roleDetail.enabled) {
      const errorDetail = `Rol con Id ${roleId} actualmente activo`;
      const errorObj = this.errMgr.get(modErrs.modifyRole.alreadyActive, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await rolesCol.deleteOne(envQueries.findById(roleId));
    const result = actionResult?.result?.n > 0;
    this.logger.debug(`Eliminación del rol ${roleId} con resultado ${result}`);
    return [null, { result }];
  }

  async getRoleRelations(reqData) {
    const { environmentId, relationIds } = reqData;
    const envsCol = this.getDb().collection(environmentsColl);
    if (environmentId) {
      const envDetail = await envsCol.findOne(envQueries.findById(environmentId));
      if (!envDetail) {
        const errorDetail = `Environment con Id ${environmentId} no encontrado`;
        const errorObj = this.errMgr.get(modErrs.findEnv.notFound, errorDetail);
        return [errorObj, null];
      }
    }
    const relationsCol = this.getDb().collection(roleRelationsColl);
    const relationList = await relationsCol.find(envQueries
      .findRoleRelations(environmentId, relationIds)).toArray();
    return [null, relationList];
  }

  async getRoleRelation(reqData) {
    const { relationId } = reqData;
    const relationsCol = this.getDb().collection(roleRelationsColl);
    const relationDetail = await relationsCol.findOne(envQueries.findById(relationId));
    if (!relationDetail) {
      const errorDetail = `Relación con Id ${relationId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findRelation.notFound, errorDetail);
      return [errorObj, null];
    }
    return [null, relationDetail];
  }

  async createRoleRelation(roleRelationData) {
    const { environmentId, name, primaryRoleId, secondaryRoleId } = roleRelationData;
    const relationsCol = this.getDb().collection(roleRelationsColl);
    const relationDetail = await relationsCol.findOne(envQueries.findRoleByName(environmentId.name));
    if (relationDetail) {
      const errorDetail = `Relación con nombre ${name} ya existe en entorno ${environmentId}`;
      const errorObj = this.errMgr.get(modErrs.createRelation.alreadyExist, errorDetail);
      return [errorObj, null];
    }
    const rolesCol = this.getDb().collection(ecosystemRolesColl);
    const primaryRoleDetail = await rolesCol.findOne(envQueries.findById(primaryRoleId));
    const secondaryRoleIdDetail = await rolesCol.findOne(envQueries.findById(secondaryRoleId));
    if (!primaryRoleDetail) {
      const errorDetail = `Role con Id ${primaryRoleId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findRole.notFound, errorDetail);
      return [errorObj, null];
    }
    if (primaryRoleDetail.environmentId !== environmentId) {
      const errorDetail = `Role con Id ${primaryRoleId} no pertenece al mismo entorno ${environmentId}`;
      const errorObj = this.errMgr.get(modErrs.findRole.notFound, errorDetail);
      return [errorObj, null];
    }
    if (!secondaryRoleIdDetail) {
      const errorDetail = `Role con Id ${secondaryRoleId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findRole.notFound, errorDetail);
      return [errorObj, null];
    }
    if (secondaryRoleIdDetail.environmentId !== environmentId) {
      const errorDetail = `Role con Id ${secondaryRoleId} no pertenece al mismo entorno ${environmentId}`;
      const errorObj = this.errMgr.get(modErrs.findRole.notFound, errorDetail);
      return [errorObj, null];
    }
    const newRelationData = { ...roleRelationData, enabled: false, creation: new Date() };
    const actionResult = await relationsCol.insertOne(newRelationData);
    this.logger.debug(`Creación de una nueva relación ${newRelationData} con resultado ${actionResult?.insertedId}`);
    return [null, { environmentId: actionResult?.insertedId }];
  }

  async modifyRoleRelation(reqData) {
    const { relationId } = reqData;
    const relationsCol = this.getDb().collection(roleRelationsColl);
    const relationDetail = await relationsCol.findOne(envQueries.findById(relationId));
    if (!relationDetail) {
      const errorDetail = `Relación con Id ${relationId} no encontrada`;
      const errorObj = this.errMgr.get(modErrs.findRelation.notFound, errorDetail);
      return [errorObj, null];
    }
    if (relationDetail.enabled) {
      const errorDetail = `Relación con Id ${relationId} está activa`;
      const errorObj = this.errMgr.get(modErrs.modifyRelation.alreadyActive, errorDetail);
      return [errorObj, null];
    }
    const updateData = { ...reqData };
    delete updateData.relationId;
    const actionResult = await relationsCol.updateOne(envQueries.findById(relationId),
      envQueries.updateObj(updateData));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Modificación de una rleación ${updateData} con resultado ${result}`);
    return [null, { result }];
  }

  async activateRoleRelation(reqData) {
    const { relationId } = reqData;
    const relationsCol = this.getDb().collection(roleRelationsColl);
    const relationDetail = await relationsCol.findOne(envQueries.findById(relationId));
    if (!relationDetail) {
      const errorDetail = `Relación con Id ${relationId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findRelation.notFound, errorDetail);
      return [errorObj, null];
    }
    if (relationDetail.enabled) {
      const errorDetail = `Relación con Id ${relationId} actualmente activo`;
      const errorObj = this.errMgr.get(modErrs.modifyRelation.alreadyActive, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await relationsCol.updateOne(envQueries.findById(relationId),
      envQueries.updateObj({ enabled: true }));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Activación de la relación ${relationId} con resultado ${result}`);
    return [null, { result }];
  }

  async inactivateRoleRelation(reqData) {
    const { relationId } = reqData;
    const relationsCol = this.getDb().collection(roleRelationsColl);
    const relationDetail = await relationsCol.findOne(envQueries.findById(relationId));
    if (!relationDetail) {
      const errorDetail = `Relación con Id ${relationId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findRelation.notFound, errorDetail);
      return [errorObj, null];
    }
    if (!relationDetail.enabled) {
      const errorDetail = `Relación con Id ${relationId} actualmente inactivo`;
      const errorObj = this.errMgr.get(modErrs.modifyRelation.alreadyInactive, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await relationsCol.updateOne(envQueries.findById(relationId),
      envQueries.updateObj({ enabled: false }));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Inactivación de la relación ${relationId} con resultado ${result}`);
    return [null, { result }];
  }

  async deleteRoleRelation(reqData) {
    const { relationId } = reqData;
    const relationsCol = this.getDb().collection(roleRelationsColl);
    const relationDetail = await relationsCol.findOne(envQueries.findById(relationId));
    if (!relationDetail) {
      const errorDetail = `Relación con Id ${relationId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findRelation.notFound, errorDetail);
      return [errorObj, null];
    }
    if (relationDetail.enabled) {
      const errorDetail = `Relación con Id ${relationId} actualmente activa`;
      const errorObj = this.errMgr.get(modErrs.modifyRelation.alreadyActive, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await relationsCol.deleteOne(envQueries.findById(relationId));
    const result = actionResult?.result?.n > 0;
    this.logger.debug(`Eliminación de la relación ${relationId} con resultado ${result}`);
    return [null, { result }];
  }
}

module.exports = EnvironmentManager;