tuain-ecosystem-lib/lib/ecosystem/terminals.js

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

const { ObjectId } = require('mongodb');
const {
  dbQueries: { terminals: terminalQueries },
  collections: {
    terminals: terminalsColl, stores: storesColl,
    thirdParties: thirdPartiesColl, devices: devicesColl,
  },
} = require('../../config');

const modErrs = {
  findStore: {
    notFound: ['01', 'No se encontró sucursal que se ajuste a la búsqueda'],
  },
  findDevice: {
    notFound: ['01', 'No se encontró dispositivo que se ajuste a la búsqueda'],
  },
  findTerminal: {
    notFound: ['01', 'No se encontró Terminal que se ajuste a la búsqueda'],
  },
  findThirdParty: {
    notFound: ['01', 'No se encontró tercero que se ajuste a la búsqueda'],
  },
};

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

  async getTerminals(reqData) {
    const { terminalIds } = reqData;
    const terminalCol = this.getDb().collection(terminalsColl);
    const terminals = await terminalCol.find(terminalQueries
      .findTerminals(terminalIds)).sort({ creation: -1 }).toArray();
    return [null, terminals];
  }

  async createTerminal(reqData) {
    const terminalCol = this.getDb().collection(terminalsColl);
    const newTerminal = {
      ...reqData,
      enabled: false,
      creation: new Date(),
    };
    const insert = await terminalCol.insertOne(newTerminal);
    const terminalId = insert?.insertedId;
    return [null, { terminalId }];
  }

  async modifyTerminal(reqData) {
    const { terminalId } = reqData;
    const terminalCol = this.getDb().collection(terminalsColl);
    const terminalDetail = await terminalCol.findOne(terminalQueries.findById(terminalId));
    if (!terminalDetail) {
      const errorDetail = `Terminal con Id ${terminalId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findTerminal.notFound, errorDetail);
      return [errorObj, null];
    }
    const terminalData = {
      ...reqData,
    };
    delete terminalData.terminalId;
    const actionResult = await terminalCol.updateOne(terminalQueries.findById(terminalId),
      terminalQueries.updateObj(terminalData));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Modificación de terminal ${terminalData} con resultado ${result}`);
    return [null, { result }];
  }

  async activateTerminal(reqData) {
    const { terminalId } = reqData;
    const terminalCol = this.getDb().collection(terminalsColl);
    const terminalDetail = await terminalCol.findOne(terminalQueries.findById(terminalId));
    if (!terminalDetail) {
      const errorDetail = `Terminal con Id ${terminalId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findTerminal.notFound, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await terminalCol.updateOne(terminalQueries.findById(terminalId),
      terminalQueries.updateObj({ enabled: true }));
    const result = (actionResult?.result?.nModified > 0);
    return [null, { result }];
  }

  async inactivateTerminal(reqData) {
    const { terminalId } = reqData;
    const terminalCol = this.getDb().collection(terminalsColl);
    const terminalDetail = await terminalCol.findOne(terminalQueries.findById(terminalId));
    if (!terminalDetail) {
      const errorDetail = `Terminal con Id ${terminalId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findTerminal.notFound, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await terminalCol.updateOne(terminalQueries.findById(terminalId),
      terminalQueries.updateObj({ enabled: false }));
    const result = (actionResult?.result?.nModified > 0);
    return [null, { result }];
  }

  async addExternalReference(reqData) {
    const { terminalId, externalSource, externalCode } = reqData;
    const terminalCol = this.getDb().collection(terminalsColl);
    const terminalDetail = await terminalCol.findOne(terminalQueries.findById(terminalId));
    if (!terminalDetail) {
      const errorDetail = `Terminal con Id ${terminalId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findTerminal.notFound, errorDetail);
      return [errorObj, null];
    }
    const currentCoding = terminalDetail.externalCoding?.find(item => item.externalSource === externalSource);
    if (currentCoding) {
      await terminalCol.updateOne(terminalQueries.findById(terminalId),
        terminalQueries.removeExternalRef(externalSource));
    }
    const externalRefData = { externalSource, externalCode };
    const actionResult = await terminalCol.updateOne(terminalQueries.findById(terminalId),
      terminalQueries.addExternalRef(externalRefData));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Adición de una referencia externa a una terminal ${externalRefData} con resultado ${result}`);
    return [null, { result }];
  }

  async deleteExternalReference(reqData) {
    const { terminalId, externalSource } = reqData;
    const terminalCol = this.getDb().collection(terminalsColl);
    const terminalDetail = await terminalCol.findOne(terminalQueries.findById(terminalId));
    if (!terminalDetail) {
      const errorDetail = `Terminal con Id ${terminalId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findTerminal.notFound, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await terminalCol.updateOne(terminalQueries.findById(terminalId),
      terminalQueries.removeExternalRef(externalSource));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`eliminación de una referencia externa a un tercero ${externalSource} con resultado ${result}`);
    return [null, { result }];
  }

  async addTerminalStore(reqData) {
    const { terminalId, storeId } = reqData;
    const terminalCol = this.getDb().collection(terminalsColl);
    const storeCol = this.getDb().collection(storesColl);
    const storeDetail = await storeCol.findOne(terminalQueries.findById(storeId));
    if (!storeDetail) {
      const errorDetail = `Store con Id ${storeId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findStore.notFound, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await terminalCol.updateOne(terminalQueries.findById(terminalId),
      terminalQueries.updateObj({ storeId: ObjectId(storeId) }));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Asignación de sucursal ${storeId} a terminal ${terminalId} con resultado ${result}`);
    return [null, { result }];
  }

  async getStoreTerminals(reqData) {
    const { storeId } = reqData;
    const terminalCol = this.getDb().collection(terminalsColl);
    const terminals = await terminalCol.find(terminalQueries.findByStore(storeId)).toArray();
    return [null, terminals];
  }

  async addTerminalDevice(reqData) {
    const { terminalId, deviceId } = reqData;
    const terminalCol = this.getDb().collection(terminalsColl);
    const deviceCol = this.getDb().collection(devicesColl);
    const deviceDetail = await deviceCol.findOne(terminalQueries.findById(deviceId));
    if (!deviceDetail) {
      const errorDetail = `Dispositivo con Id ${deviceId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findDevice.notFound, errorDetail);
      return [errorObj, null];
    }
    const actionResult = await terminalCol.updateOne(terminalQueries.findById(terminalId),
      terminalQueries.updateObj({ deviceId: ObjectId(deviceId) }));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Asignación de dispositivo ${deviceId} a terminal ${terminalId} con resultado ${result}`);
    return [null, { result }];
  }

  async getDeviceTerminals(reqData) {
    const { deviceId } = reqData;
    const terminalCol = this.getDb().collection(terminalsColl);
    const terminals = await terminalCol.find(terminalQueries.findByDevice(deviceId)).toArray();
    return [null, terminals];
  }

  async addTerminalThirdParty(reqData) {
    const { terminalId, thirdPartyId, thirdPartyRole } = reqData;
    const terminalCol = this.getDb().collection(terminalsColl);
    const thirdPartieCol = this.getDb().collection(thirdPartiesColl);
    const thirdPartieDetail = await thirdPartieCol.findOne(terminalQueries.findById(thirdPartyId));
    if (!thirdPartieDetail) {
      const errorDetail = `Tercero con Id ${thirdPartyId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findThirdParty.notFound, errorDetail);
      return [errorObj, null];
    }
    const terminalDetail = await terminalCol.findOne(terminalQueries.findById(terminalId));
    if (!terminalDetail) {
      const errorDetail = `Terminal con Id ${terminalId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findTerminal.notFound, errorDetail);
      return [errorObj, null];
    }
    const thirdParty = terminalDetail.thirdParties?.find(item => item.thirdPartyRole === thirdPartyRole);
    if (thirdParty) {
      await terminalCol.updateOne(terminalQueries.findById(terminalId),
        terminalQueries.removeThirdParty(thirdPartyRole));
    }
    const actionResult = await terminalCol.updateOne(terminalQueries.findById(terminalId),
      { $set: { thirdParties: [{ thirdPartyId: ObjectId(thirdPartyId), thirdPartyRole }] } });
    // terminalQueries.addToArray('thirdParties', { thirdPartyId: ObjectId(thirdPartyId), thirdPartyRole }));
    const result = actionResult?.result?.nModified > 0;
    this.logger.debug(`Asignación de tercero ${thirdPartyId} a terminal ${terminalId} con resultado ${result}`);
    return [null, { result }];
  }

  async getThirdPartyTerminals(reqData) {
    const { thirdPartyId, thirdPartyRole } = reqData;
    const terminalCol = this.getDb().collection(terminalsColl);
    const terminals = await terminalCol.find(terminalQueries
      .findByThirdParty(thirdPartyId, thirdPartyRole)).toArray();
    return [null, terminals];
  }

  async getTerminal(reqData) {
    const { terminalId, serial, fullSerial } = reqData;
    const terminalCol = this.getDb().collection(terminalsColl);
    let terminalDetail;
    if (fullSerial) {
      terminalDetail = await terminalCol.findOne(terminalQueries
        .findByFullSerial(fullSerial));
    } else if (serial) {
      terminalDetail = await terminalCol.findOne(terminalQueries
        .findBySerial(serial));
    } else {
      terminalDetail = await terminalCol.findOne(terminalQueries
        .findById(terminalId));
    }
    if (!terminalDetail) {
      const errorDetail = `Terminal con Id ${terminalId} no encontrado`;
      const errorObj = this.errMgr.get(modErrs.findTerminal.notFound, errorDetail);
      return [errorObj, null];
    }
    return [null, terminalDetail];
  }
}

module.exports = TerminalManager;