dcos-core-monalisav2-latam 1.0.0

package/src/functions/clients_peru/utils.js

@@ -0,0 +1,243 @@
+const { SQS } = require('aws-sdk');
+const { AxiosError } = require('axios');
+const Logger = require('../../common/utils/logger');
+
+/**
+ * Envia un mensaje a una cola SQS.
+ * @param {string} url URL de la cola SQS a la que se enviará el mensaje.
+ * @param {object} message Objeto JSON con los datos a enviar a la cola.
+ * @returns 
+ */
+module.exports.sendSqsMessage = (url, message) => {
+    return new Promise((resolve, reject) => {
+        const sqs = new SQS()
+        message = JSON.stringify(message);
+        const params = { MessageBody: message, QueueUrl: url };
+        if (process?.env?.SQS_DELAY_SECONDS) {
+            params.DelaySeconds = process.env.SQS_DELAY_SECONDS;
+        }
+
+        // Se ejecuta la tarea de enviar el mensaje a SQS
+        sqs.sendMessage(params, (err, data) => {
+            if (err) {
+                reject(err);
+            } else {
+                const { MessageId } = data;
+                Logger.info(`Message sent with id: ${MessageId}`, message);
+                resolve(data);
+            }
+        });
+    });
+};
+
+/**
+ * Establece en una URL base los parámetros GET.
+ * @param {string} url Url base a la que se adicionará los Query Params.
+ * @param {object} queryParams Objeto con los Query Params a definir como método GET.
+ * @returns Url con los Query Params.
+ */
+module.exports.setQueryParams = (url, queryParams) => {
+    let queryText = ''
+    for (let key in queryParams) {
+        if (queryText) {
+            queryText += '&'
+        }
+        queryText += `${key}=${queryParams[key]}`
+    }
+
+    if (queryText) {
+        queryText = '?' + queryText
+    }
+
+    return url + queryText
+};
+
+/**
+ * Obtiene el valor de REST-Range para consultar registros en una entidad de Master Data.
+ * @param {number} page Página de registros a consultar en Master Data
+ * @param {number} limit Número máximo de registros a retornar.
+ * @returns Texto con el parámetro REST-Range de VTEX.
+ * @see {@link https://developers.vtex.com/docs/api-reference/masterdata-api#get-/api/dataentities/-acronym-/search|Search documents - Master Data V1}
+ */
+module.exports.getRestRange = (page, limit) => {
+    let start = (page - 1) * limit, end = page * limit;
+    return `resources=${start}-${end}`;
+};
+
+/**
+ * Genera los valores basados en una determinada fecha para utilizarse en
+ * el nombre de archivos y/o carpetas.
+ * @param {Date} currentDate Fecha de la cual se extrae la información
+ * @returns Valores generados a partir de la fecha.
+ */
+module.exports.getDateValues = (currentDate = new Date()) => {
+    let year = currentDate.getFullYear(),
+        month = String(currentDate.getMonth() + 1).padStart(2, '0'),
+        day = String(currentDate.getDate()).padStart(2, '0'),
+        hour = String(currentDate.getHours()).padStart(2, '0'),
+        minute = String(currentDate.getMinutes()).padStart(2, '0'),
+        second = String(currentDate.getSeconds()).padStart(2, '0');
+
+    return {
+        // Marca de tiempo de la fecha y hora actual.
+        'timestamp': year + month + day + hour + minute + second,
+        // Marca de tiempo de la fecha actual.
+        'timestampMin': year + month + day,
+        // Subcarpeta donde se moveran los archivos grandes que ya fueron divididos
+        'processedSubfolder': `${year}/${month}`
+    };
+};
+
+/**
+ * Ajusta las reglas de validación en Validate.js.
+ * @param {*} validate Instancia de la librería validate.js
+ */
+module.exports.setValidateOptions = (validate) => {
+    // Se ajusta la opción message de error para el parámetro 'format'
+    validate.validators.format.options = {
+        message: (value, attribute, validatorOptions, attributes, globalOptions) => {
+            // Se obtiene el tipo de dato del parámetro 'format' definido en las reglas de validación
+            let type = Object.prototype.toString.call(validatorOptions);
+            switch (type) {
+                case '[object String]':
+                    return `doesn't match with the pattern '${validatorOptions ?? ''}'`;
+                case '[object Object]':
+                    return `doesn't match with the pattern '${validatorOptions.pattern ?? ''}'`;
+                default:
+                    return `doesn't match with the pattern`;
+            }
+        }
+    };
+
+    // Se ajusta las validaciones para el parámetro 'presence'
+    validate.validators.presence = (value, options, attribute, attributes) => {
+        // Se valida si el atributo no está definido
+        if (!attributes.hasOwnProperty(attribute)) {
+            return `is't defined`;
+        }
+
+        // Se obtiene el tipo de dato del parámetro 'format' definido en las reglas de validación
+        let type = Object.prototype.toString.call(options);
+
+        // Si en la opción se para un valor booleano (presence=true o presence=false)
+        if (type == '[object Boolean]') {
+            return options && !value ? `can't be blank` : null;
+        }
+
+        // Si se define un valor de texto (condicional con la variable 'attributes')
+        if (type == '[object String]') {
+            try {
+                let result;
+                eval('result=' + options);
+                return result && !value ? `can't be blank` : null;
+            } catch (ex) {
+                Logger.error(ex);
+            }
+        }
+
+        if (type == '[object Object]') {
+            const { allowEmpty, message } = options;
+
+            let subType = Object.prototype.toString.call(allowEmpty);
+            if (subType == '[object Boolean]') {
+                return !allowEmpty && !value ? (message ?? `can't be blank`) : null;
+            }
+            if (subType == '[object String]') {
+                try {
+                    let result;
+                    eval('result=' + allowEmpty);
+                    return !result && !value ? (message ?? `can't be blank`) : null;
+                } catch (ex) {
+                    Logger.error(ex);
+                }
+            }
+        }
+
+        return 'has an validation error';
+    };
+
+    validate.validators.inclusion = (value, options, attribute, attributes) => {
+        // Si no se definió un valor se retorna null
+        if (!value) {
+            return null;
+        }
+
+        // Se obtiene el tipo de dato del parámetro 'format' definido en las reglas de validación
+        let type = Object.prototype.toString.call(options);
+
+        if (type == '[object Array]') {
+            return !options.includes(value) ? `is not included in the list` : null;
+        }
+
+        if (type == '[object Object]') {
+            const { within, message, sensiitiveCase } = options;
+
+            switch (sensiitiveCase) {
+                case 'U':
+                    value = value.toUpperCase();
+                    break;
+                case 'L':
+                    value = value.toLowerCase();
+                    break
+            }
+
+            return !within.includes(value) ? (message ?? `is not included in the list`) : null;
+        }
+
+        return 'has an validation error';
+    };
+}
+
+/**
+ * Extrae la información básica de un error capturado en un try...catch.
+ * @param {*} ex Objeto de datos del error.
+ * @returns Información del error presentado.
+ */
+module.exports.getErrorData = ex => {
+    let error = { message: '', status: 500, info: {} };
+    if (ex instanceof AxiosError) {
+        const { request = {}, response = {} } = ex;
+        const { path, method, host } = request;
+        const { status = 500, statusText = '', data = null } = response;
+
+        let message;
+        if (data?.Message) {
+            message = data.Message;
+        } else if (data) {
+            switch (Object.prototype.toString.call(data)) {
+                case '[object String]':
+                    message = data;
+                    break;
+                case '[object Object]':
+                    message = JSON.stringify(data);
+                    break;
+            }
+        } else if (statusText) {
+            message = statusText;
+        } else {
+            Logger.error(ex);
+            message = 'Error in Axios request';
+        }
+
+        error.status = status;
+        error.message = message;
+        error.info = { status, data, message, request: { path, method, host } };
+    } else {
+        const { message } = ex;
+        error.message = message;
+        error.info = { message };
+    }
+    return error;
+};
+
+/**
+ * Actualiza el valor de una propiedad adicionando el posfijo '_XXX';
+ * @param {object} objectData Objeto de datos.
+ * @param {string} key Nombre de la propiedad a afectar.
+ * @param {number} attemp Posfijo a definir.
+ */
+module.exports.addSuffixToTimestamp = (objectData, key, attemp) => {
+    if (objectData.hasOwnProperty(key) && objectData[key]) {
+        objectData[key] = objectData[key].replace(/(_\d+)?$/, '_' + attemp);
+    }
+};

package/src/functions/cronjobs/cron-jobs-manager.js

@@ -0,0 +1,40 @@
+const ApiResponse = require('../../common/utils/api-response');
+const Logger = require('../../common/utils/logger');
+const { getErrorData } = require('../../common/utils/util');
+const Cronjob = require('../../entities/cronjob');
+
+/**
+ * 
+ * @param {*} event Objeto que contiene información de una petición como: el body, path y método de una petición HTTP, o la lista de registros en una cola SQS.
+ * @param {*} context Objeto que contiene información sobre la invocación, la función y el entorno de ejecución.
+ */
+module.exports.create = async (event, context) => {
+  // ID de la petición en AWS
+  const { awsRequestId } = context;
+
+  try {
+    let { body, pathParameters } = event;
+    const { cronId } = pathParameters;
+
+    body = JSON.parse(body);
+    if (!body) {
+      throw new Error('Body request is not defined');
+    }
+    if (!cronId) {
+      throw new Error('Cron Id is required');
+    }
+    const result = await Cronjob.addRegisterPerId(cronId, {
+      CronId: cronId,
+      Crons: body
+    });
+    if (!result) {
+      throw new Error('Cron could not be created');
+    }
+
+    return ApiResponse.response(200, { message: 'Cron jobs saved successfully', data: result });
+  } catch (ex) {
+    const { message, info } = getErrorData(ex);
+    Logger.error(info);
+    return ApiResponse.response(500, { 'error': message, awsRequestId });
+  }
+}

package/src/functions/cronjobs/cron-jobs.js

@@ -0,0 +1,171 @@
+const nodeCron = require('node-cron');
+const parser = require('cron-parser');
+const ApiResponse = require('../../common/utils/api-response');
+const { sendMessageToSqs } = require('../../common/utils/aws-services');
+const { processNewLeadsNotification } = require('../notifications/new-leads-notification-consumer');
+const { getErrorData } = require('../../common/utils/util');
+const Cronjob = require('../../entities/cronjob');
+const { callback: executeSftpProcess, reprocessFailed } = require('../sftpIntegrations/sftp-consumer');
+const { handler: catalogSyncHandler } = require('../inventory/catalog-sync-handler');
+const { handleExecute } = require('../multiPresentation/multipres');
+const { handleConsumer } = require('../clients_peru/updateClients');
+const Logger = require('../../common/utils/logger');
+
+const {
+    SQS_CRON_JOBS_QUEUE_URL,
+    SQS_CRON_JOBS_DLQ_QUEUE_URL,
+    CRONJOB_ID
+} = process?.env ?? {};
+
+/**
+ * Función que se invoca desde el schedule definido en la propiedad 'cron_jobs' del archivo 'functions.yml'.
+ * @param {*} event Objeto que contiene información de una petición como: el body, path y método de una petición HTTP, o la lista de registros en una cola SQS.
+ * @param {*} context Objeto que contiene información sobre la invocación, la función y el entorno de ejecución.
+ */
+module.exports.run = async (event, context) => {
+    // Se obtiene la propiedad 'httpMethod' para determinar si la función se ejecutó desde una petición HTTP
+    const { httpMethod } = event;
+    // Se consulta la lista de cron jobs configurados
+    const promises = [];
+    const cronJobs = await getCronJobs();
+    for (let cronJob of cronJobs) {
+        const { Actived = false, Name, Cron, TimeZone = 'America/Bogota', ...jobData } = cronJob;
+        // Se define la zona horaria para que la fecha y hora del sistema sea acorde a la misma
+        setTimeZone(TimeZone);
+        let currentDate = new Date();
+        // Se valida si el job se encuentra activo y el cron definido sea válido
+        if (Actived && Cron && nodeCron.validate(Cron)) {
+            if (timeMatch(Cron, currentDate)) {
+                promises.push(jobData);
+            }
+        } else {
+            Logger.warn(`Job ${Name} is inactived and/or cron is not valid`, { Actived, Cron });
+        }
+    }
+    if (promises.length) {
+        Logger.log(`Cron jobs to execute: ${promises.length}`);
+        await Promise.allSettled(promises.map(jobData => {
+            return new Promise((resolve, reject) => {
+                if (!jobData || jobData === "") {
+                    return resolve(null);  // O reject si prefieres fallar en este caso
+                }
+
+                sendMessageToSqs(SQS_CRON_JOBS_QUEUE_URL, jobData).then(e => {
+                    resolve(jobData);
+                }).catch(error => {
+                    Logger.error(`Error sending message to SQS`, {
+                        error: error.message,
+                        jobData: jobData
+                    });
+                    reject(new Error(error.message));  // Propaga el error a Promise.allSettled
+                })
+            });
+        }));
+    }
+
+    // Si la función se ejecutó desde una petición HTTP se retorna una respuesta
+    if (httpMethod) {
+        return ApiResponse.response(200, { message: 'Cron jobs executed successfully', promises });
+    }
+}
+
+/**
+ * Función que se invoca desde el trigger de la cola SQS definida en la propiedad 'cronjobs-queue' del archivo 'constructs.yml'.
+ * @param {*} event Objeto que contiene información de una petición como: el body, path y método de una petición HTTP, o la lista de registros en una cola SQS.
+ * @param {*} context Objeto que contiene información sobre la invocación, la función y el entorno de ejecución.
+ */
+module.exports.queue = async (event, context) => {
+    // ID de la petición en AWS
+    const { awsRequestId } = context;
+
+    // Se recorre la lista de registros de la cola
+    for (const record of event.Records) {
+        // Se obtiene el objeto enviado a la cola
+        let { body } = record;
+        body = JSON.parse(body);
+
+        const { AccountName, ActionProcess, Values } = body;
+        try {
+            switch (ActionProcess) {
+                case 'new-leads':
+                    await processNewLeadsNotification(AccountName, ActionProcess, Values);
+                    break;
+                case 'catalog-sync':
+                    await catalogSyncHandler({
+                        pathParameters: { accountName: AccountName },
+                        ...Values
+                    });
+                    break;
+                case 'multiPresentation':
+                    await handleExecute(AccountName);
+                    break
+                case 'clientsPeru':
+                    await handleConsumer(AccountName, Values);
+                    break
+                case 'reprocessSftpFailed':
+                    await reprocessFailed(body);
+                    break
+                default:
+                    // Se pasa el cuerpo del mensaje SQS completo, para contemplar el tema de los reitentos dentro de la función.
+                    await executeSftpProcess(body);
+                    break;
+            }
+        } catch (ex) {
+            const { message, info } = getErrorData(ex);
+            Logger.error('Error in Cron Job queue', info);
+
+            await sendMessageToSqs(SQS_CRON_JOBS_DLQ_QUEUE_URL, {
+                AccountName, ActionProcess,
+                Values,
+                reason: message,
+                awsRequestId
+            }).catch(Logger.error);
+        }
+    }
+}
+
+/**
+ * Consulta la lista de jobs configurados.
+ * @returns Lista de jobs.
+ */
+async function getCronJobs() {
+    try {
+        // Se consulta en DynamoDB la lista de Jobs configurados
+        const cronJobsData = await Cronjob.getPerId(CRONJOB_ID);
+        return cronJobsData?.Crons ?? [];
+    } catch (ex) {
+        const { info } = getErrorData(ex);
+        Logger.error('Error in getCronJobs', info)
+        return [];
+    }
+}
+
+/**
+ * Establece la zona horaria en el servidor para obtener fecha y hora del sistema.
+ * @param {string} timeZone Zona horaria.
+ */
+function setTimeZone(timeZone) {
+    if (timeZone) {
+        process.env.TZ = timeZone;
+    } else {
+        delete process.env.TZ;
+    }
+}
+
+/**
+ * Valida si una fecha corresponde a un cron job.
+ * @param {string} cron Valor del cron.
+ * @param {Date} date Fecha a validar.
+ * @return Valor de verdad que indica si la fecha corresponde o no al cron (TRUE o FALSE).
+ */
+function timeMatch(cron, date) {
+    let interval = parser.parseExpression(cron);
+
+    const { minute, hour, dayOfMonth, month, dayOfWeek } = interval.fields;
+
+    return minute.includes(date.getMinutes()) &&
+        hour.includes(date.getHours()) &&
+        dayOfMonth.includes(date.getDate()) &&
+        month.includes(date.getMonth() + 1) &&
+        dayOfWeek.includes(date.getDay());
+}

package/src/functions/crons/cron.js

@@ -0,0 +1,39 @@
+"use strict";
+
+const Crons = require("../../entities/cron");
+const ApiResponse = require("../../common/utils/api-response");
+const Logger = require("../../common/utils/logger");
+/**
+ *
+ * @param {import("aws-lambda")} event
+ */
+const create = async (event) => {
+  try {
+    let message = "Cron created successfully";
+    Logger.log(event);
+    if (!event.body) {
+      return ApiResponse.response(400, "No body was found");
+    }
+    const body = JSON.parse(event.body);
+    const cronId = event?.pathParameters?.cronId;
+    if (!cronId || cronId === "") {
+      return ApiResponse.response(400, "Cron Id is required");
+    }
+     
+    const cron = await Crons.addRegisterPerId({
+    	CronId: cronId,
+    	Crons: body
+    }, cronId);
+    if (!cron) {
+      return ApiResponse.response(400, "Cron could not be created");
+    }
+    return ApiResponse.response(200, { message: message, data: cron });
+  } catch (error) {
+    Logger.error(error);
+    return ApiResponse.response(500, error);
+  }
+};
+
+module.exports = {
+  create
+};

package/src/functions/distributors/distributor-handler.js

@@ -0,0 +1,81 @@
+const VtexApi = require('../../vtex/clients/VtexApi');
+const DistributorData = require('./distributor');
+const Logger = require("../../common/utils/logger");
+
+/**
+ * Handles the event triggered by the Lambda function.
+ *
+ * @param {Object} event - The event object containing the request details.
+ * @returns {Promise<Object>} - A promise that resolves to the response object.
+ * @throws {Error} - If an error occurs during the execution.
+ */
+module.exports.handler = async (event) => {
+    let statusCode = 200;
+    let response = {};
+    for (const record of event.Records) {
+        try {
+            const order = JSON.parse(record.body);
+            const AccountConfig = order?.accountConfig;
+            Logger.setAccount(AccountConfig);
+            const orderId = order?.orderInfo?.OrderId;
+            const vtexApi = new VtexApi(AccountConfig.AccountName, AccountConfig.Credentials.key, AccountConfig.Credentials.token);
+            const responseOrder = await vtexApi.fetch(`/oms/pvt/orders/${orderId}`, { method: "GET" });
+            Logger.debug("Response Order Info: ", responseOrder?.data);
+            //get only items from responseOrder
+            const items = responseOrder?.data?.items;
+            Logger.debug("Items: ", items);
+            let itemsSkuDist = {};
+            let skuRefUsed = AccountConfig?.SkuRefUsed;
+            if (typeof skuRefUsed !== "boolean") {
+                Logger.warn("Sku or ReferenceCode filter not defined, use default: ", skuRefUsed);
+                skuRefUsed = true;
+            }
+            if (!items) {
+                Logger.error("Orders without items.");
+                return;
+            }
+            // Create a set to track unique search values
+            const uniqueSearchValues = new Set();
+            const filteredItems = items.filter(item => {
+                const searchValue = skuRefUsed ? item.refId : item.ean;
+                if (!uniqueSearchValues.has(searchValue)) {
+                    uniqueSearchValues.add(searchValue);
+                    return true;
+                }
+                return false;
+            });
+            Logger.debug("Filtered Items: ", filteredItems);
+            itemsSkuDist = await getItemsSkuDist(responseOrder, filteredItems, skuRefUsed, AccountConfig);
+            const updateAdditionalFields = await vtexApi.fetch(
+                `/dataentities/${AccountConfig.SkuDistributorManagementAdditionalInfo.entityName}/documents/`, { method: "PATCH", data: itemsSkuDist });
+                Logger.debug("Update Additional Fields: ", updateAdditionalFields);
+            if (!updateAdditionalFields && (updateAdditionalFields.status !== 200 || updateAdditionalFields.status !== 201 || updateAdditionalFields.status !== 204)) {
+                statusCode = 404;
+                response = { error: updateAdditionalFields };
+                Logger.error(statusCode, response);
+            }
+            Logger.info(statusCode, { itemsSkuDist });
+        } catch (error) {
+            Logger.error(error);
+            statusCode = 500;
+            response = { error };
+        }
+    }
+};
+
+async function getItemsSkuDist(responseOrder, filteredItems, skuRefUsed, AccountConfig) {
+    return {
+        id: responseOrder?.data?.orderId,
+        items: await Promise.all(filteredItems.map(async (item) => {
+            const searchValue = skuRefUsed ? item.refId : item.ean;
+            const distributorData = await DistributorData.getDistributorByRefId(AccountConfig.AccountName, searchValue, AccountConfig.SkuDistributorManagement);
+            Logger.info(`Distributor Data for ${searchValue}: `, distributorData);
+            return {
+                id: item.id,
+                ean: item.ean,
+                refId: item.refId,
+                ERPCode: distributorData, // Include distributor data in the item
+            };
+        }))
+    };
+}