tuain-ecosystem-lib/lib/ecosystem/parameters.js

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

const {
  dbQueries: { params: paramQueries },
  collections: { parameters: parametersColl },
} = require('../../config');

const modErrs = {
  findParam: {
    notFound: ['01', 'No se encontró parámetro que se ajuste a la búsqueda'],
    alreadyExists: ['02', 'Ya existe parámetro'],
    duplicatedOption: ['03', 'Opción duplicada'],
  },
};

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

  async getParameters(reqData) {
    const paramCol = this.getDb().collection(parametersColl);
    const paramDetail = await paramCol.find(paramQueries.findParams(reqData)).toArray();
    if (!paramDetail) {
      const errorDetail = `Parámetro con consulta ${reqData} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findParam.notFound, errorDetail);
      return [errorObj, null];
    }
    return [null, paramDetail];
  }

  async getParameter(reqData) {
    const { name } = reqData;
    const paramCol = this.getDb().collection(parametersColl);
    const paramDetail = await paramCol.findOne(paramQueries.findByName(name));
    if (!paramDetail) {
      const errorDetail = `Parámetro con nombre ${name} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findParam.notFound, errorDetail);
      return [errorObj, null];
    }
    return [null, paramDetail];
  }

  async createParameter(reqData) {
    const { name } = reqData;
    const paramCol = this.getDb().collection(parametersColl);
    const paramDetail = await paramCol.findOne(paramQueries.findByName(name));
    if (paramDetail) {
      const errorDetail = `Parámetro con nombre ${name} ya existe`;
      const errorObj = this.errMgr.get(modErrs.findParam.alreadyExists, errorDetail);
      return [errorObj, null];
    }
    const newParam = {
      name,
      ...reqData,
      options: [],
    };
    const insert = await paramCol.insertOne(newParam);
    const paramId = insert?.insertedId;
    return [null, { paramId }];
  }

  async modifyParameter(reqData) {
    const { name } = reqData;
    const paramCol = this.getDb().collection(parametersColl);
    const paramDetail = await paramCol.findOne(paramQueries.findByName(name));
    if (!paramDetail) {
      const errorDetail = `Parámetro con nombre ${name} ya existe`;
      const errorObj = this.errMgr.get(modErrs.findParam.alreadyExists, errorDetail);
      return [errorObj, null];
    }
    const updateParam = {
      ...reqData,
    };
    delete updateParam.name;
    delete updateParam.options;
    const actionResult = await paramCol.updateOne(paramQueries.findByName(name), paramQueries.updateObject(updateParam));
    const result = actionResult?.result?.nModified > 0;
    return [null, { result }];
  }

  async modifyWholeParameter(reqData) {
    const { name } = reqData;
    const paramCol = this.getDb().collection(parametersColl);
    const paramDetail = await paramCol.findOne(paramQueries.findByName(name));
    if (!paramDetail) {
      const errorDetail = `Parámetro con nombre ${name} ya existe`;
      const errorObj = this.errMgr.get(modErrs.findParam.alreadyExists, errorDetail);
      return [errorObj, null];
    }
    const updateParam = {
      ...reqData,
    };
    delete updateParam._id;
    delete updateParam.name;
    const actionResult = await paramCol.updateOne(paramQueries.findByName(name), paramQueries.updateObject(updateParam));
    const result = actionResult?.result?.nModified > 0;
    return [null, { result }];
  }

  async addParameterOption(reqData) {
    const { name, code, valueType, value } = reqData;
    const paramCol = this.getDb().collection(parametersColl);
    const paramDetail = await paramCol.findOne(paramQueries.findByName(name));
    if (!paramDetail) {
      const errorDetail = `Parámetro con nombre ${name} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findParam.notFound, errorDetail);
      return [errorObj, null];
    }
    const sameOption = paramDetail?.options?.find((opt) => opt.code === code);
    if (sameOption) {
      const errorDetail = `Opción con código ${code} ya existe en el parámetro ${name}`;
      const errorObj = this.errMgr.get(modErrs.findParam.duplicatedOption, errorDetail);
      return [errorObj, null];
    }
    const newOption = {
      code,
      value,
      valueType,
      ...reqData,
      attributes: [],
      tags: [],
    };
    delete newOption.name;
    const actionResult = await paramCol.updateOne(paramQueries.findByName(name), paramQueries.addToArray('options', newOption));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Adición de opción ${newOption} con resultado ${result}`);
    return [null, { result }];
  }

  async modifyParameterOption(reqData) {
    const { name, code } = reqData;
    const paramCol = this.getDb().collection(parametersColl);
    const paramDetail = await paramCol.findOne(paramQueries.findByName(name));
    if (!paramDetail) {
      const errorDetail = `Parámetro con nombre ${name} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findParam.notFound, errorDetail);
      return [errorObj, null];
    }
    const optionData = { ...reqData };
    delete optionData.name;
    delete optionData.code;
    delete optionData.attributes;
    delete optionData.tags;
    const actionResult = await paramCol.updateOne(...paramQueries.modifyOption(name, code, optionData));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`modificación de opción ${optionData} con resultado ${result}`);
    return [null, { result }];
  }

  async removeParameterOption(reqData) {
    const { name, code } = reqData;
    const paramCol = this.getDb().collection(parametersColl);
    const paramDetail = await paramCol.findOne(paramQueries.findByName(name));
    if (!paramDetail) {
      const errorDetail = `Parámetro con nombre ${name} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findParam.notFound, errorDetail);
      return [errorObj, null];
    }
    const optionIdentifier = { code };
    const actionResult = await paramCol.updateOne(
      paramQueries.findByName(name),
      paramQueries.removeFromArray('options', optionIdentifier),
    );
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Modificación de sucursal ${optionIdentifier} con resultado ${result}`);
    return [null, { result }];
  }

  async addParameterOptionAttribute(reqData) {
    const { name, code, attributeName, attributeValue } = reqData;
    const paramCol = this.getDb().collection(parametersColl);
    const paramDetail = await paramCol.findOne(paramQueries.findByName(name));
    if (!paramDetail) {
      const errorDetail = `Parámetro con nombre ${name} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findParam.notFound, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await paramCol.updateOne(
      ...paramQueries.addParamOptionAttribute(name, code, attributeName, attributeValue),
    );
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Adición del atributo ${attributeName} de opción ${code} en parámetro ${name}`);
    return [null, { result }];
  }

  async removeParamOptionAttribute(reqData) {
    const { name, code, attributeName } = reqData;
    const paramCol = this.getDb().collection(parametersColl);
    const paramDetail = await paramCol.findOne(paramQueries.findByName(name));
    if (!paramDetail) {
      const errorDetail = `Parámetro con nombre ${name} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findParam.notFound, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await paramCol.updateOne(...paramQueries.removeParamOptionAttribute(name, code, attributeName));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Eliminación del atributo ${attributeName} de opción ${code} en parámetro ${name}`);
    return [null, { result }];
  }

  async addParameterOptionTag(reqData) {
    const { name, code, tag } = reqData;
    const paramCol = this.getDb().collection(parametersColl);
    const paramDetail = await paramCol.findOne(paramQueries.findByName(name));
    if (!paramDetail) {
      const errorDetail = `Parámetro con nombre ${name} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findParam.notFound, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await paramCol.updateOne(...paramQueries.addParameterOptionTag(name, code, tag));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Adición del tag ${tag} de opción ${code} en parámetro ${name}`);
    return [null, { result }];
  }

  async removeParamOptionTag(reqData) {
    const { name, code, tag } = reqData;
    const paramCol = this.getDb().collection(parametersColl);
    const paramDetail = await paramCol.findOne(paramQueries.findByName(name));
    if (!paramDetail) {
      const errorDetail = `Parámetro con nombre ${name} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findParam.notFound, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await paramCol.updateOne(...paramQueries.removeParamOptionTag(name, code, tag));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Eliminación del atributo ${tag} de opción ${code} en parámetro ${name}`);
    return [null, { result }];
  }
}

module.exports = ParamManager;