dcos-core-monalisav2-latam 1.0.0

package/src/functions/routesflow/assign-routeflow-queue.js

@@ -0,0 +1,77 @@
+const VtexApi = require('../../vtex/clients/VtexApi');
+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) {
+    Logger.debug("Message Body: ", record.body);
+    try {
+      const order = JSON.parse(record.body);
+      const AccountConfig = order?.accountConfig;
+      const AccountConfigParent = order?.accountConfigParent;
+      const orderId = order?.orderInfo?.OrderId;
+      const vtexApiChild = new VtexApi(AccountConfig.AccountName, AccountConfig.Credentials.key, AccountConfig.Credentials.token);
+      const vtexApiParent = new VtexApi(AccountConfigParent.AccountName, AccountConfigParent.Credentials.key, AccountConfigParent.Credentials.token);
+      const responseOrderInfoChild = await vtexApiChild.fetch(`/oms/pvt/orders/${orderId}`, { method: "GET" });
+      const responseOrderInfoParent = await vtexApiParent.fetch(`/oms/pvt/orders/${responseOrderInfoChild?.data?.marketplaceOrderId}`, { method: "GET" });
+      if (!responseOrderInfoParent || responseOrderInfoParent.status !== 200) {
+          statusCode = 404;
+          response = { error: responseOrderInfoParent };
+          Logger.error({ statusCode, response});
+      }
+      const email = responseOrderInfoParent?.data?.clientProfileData?.email;
+      const responseMailParent = await vtexApiParent.fetchOrderMail(email);
+      const clientId = responseMailParent?.data?.email?.split("+")[1]?.split("@")[0];
+      Logger.setAccount(AccountConfig)
+      if(!clientId){ 
+        statusCode = 404;
+        response = { error: `Client not found, email: ${email}` };
+        Logger.error(statusCode, response);
+      }
+      
+      const responseMasterDataCT = await vtexApiParent.fetch(
+          `/dataentities/${AccountConfig.AcronymClientVtex}/search?_fields=_all&id=${clientId}`, { method: "GET" }
+      );
+
+      if (!responseMasterDataCT || responseMasterDataCT.status !== 200 || !responseMasterDataCT?.data?.length > 0) {
+          statusCode = 404;
+          response = { error: responseMasterDataCT };
+          Logger.error(statusCode, response);
+      }
+
+      let additionalFields = {
+          id : orderId,
+      }
+
+      const fields = AccountConfig?.AdditionalInfoOrderFromClient?.fields || [];
+      const data = responseMasterDataCT?.data[0] || {};
+
+      fields.forEach(field => {
+        additionalFields[field] = data[field] || ""; // Asigna el valor correspondiente o un string vacío si no existe
+      });
+      Logger.debug({ additionalFields });
+      const updateAdditionalFields = await vtexApiChild.fetch(
+          `/dataentities/${AccountConfig.AdditionalInfoOrderFromClient.nameEntity}/documents/`, { method: "PATCH", data: additionalFields });
+      
+      if (!updateAdditionalFields && (updateAdditionalFields.status !== 200 || updateAdditionalFields.status !== 201 || updateAdditionalFields.status !== 204)) {
+          statusCode = 404;
+          response = { error: updateAdditionalFields };
+          Logger.error(statusCode, response);
+      }
+      
+      Logger.debug(statusCode, { additionalFields });
+    }catch (error) {
+      Logger.error(error);
+      statusCode = 500;
+      response = { error: error.message };
+    }
+  }  
+}

package/src/functions/schemas/vtex/handle-schemas.js

@@ -0,0 +1,102 @@
+const Apiresponse = require('../../../common/utils/api-response.js');
+const {
+  handlePutRecordSchema,
+  handleGetRecordSchema,
+  handleDeleteRecordSchema
+} = require('../../../common/utils/schemas-utils.js');
+const { handleSchemaVtexMD2 } = require('../../../common/utils/vtex/save-schemas.js');
+const { handleHookVtexMD2 } = require('../../../common/utils/vtex/save-hooks.js');
+
+const AccountData = require("../../../entities/account.js");
+
+const { SCHEMAS_VTEX_TABLE, HOOKS_VTEX_TABLE } = process?.env ?? {};
+
+
+module.exports.handler = async (event) => {
+  const schemaName = event?.pathParameters?.SchemaName ?? '';
+  const hookName = event?.pathParameters?.HookName ?? '';
+  const httpMethod = event?.httpMethod?.toUpperCase();
+  const account = event?.queryStringParameters;
+  const body = parseRequestBody(event?.body);
+
+  const arrPath = event.resource.split('/')
+  const [resource, identifier, provider] = arrPath.filter(part => part !== '')
+
+  try {
+    if (identifier === 'schemas' && provider === 'vtex') {
+      return await handleRequest(schemaName, httpMethod, account, body, SCHEMAS_VTEX_TABLE, identifier)
+    }
+
+    if (identifier === 'hooks' && provider === 'vtex') {
+      return await handleRequest(hookName, httpMethod, account, body, HOOKS_VTEX_TABLE, identifier)
+    }
+    return Apiresponse.response(404, `Resource: ${identifier} not found`)
+  } catch (error) {
+    return Apiresponse.response(500, `Internal Server Error: ${error.message}`);
+  }
+};
+
+const handleRequest = async (id, httpMethod, account, body, tableName, identifier) => {
+  switch (httpMethod) {
+    case 'PUT':
+      return await handlePutRecordSchema(id, body, tableName, identifier);
+
+    case 'GET':
+      return await handleGetRecordSchema({ id, tableName, identifier });
+
+    case 'DELETE':
+      if (identifier === 'schemas') {
+        if (account?.an && account?.entity) {
+          const accountConfig = await getAccountConfig(account.an);
+          return await handleSchemaVtexMD2({
+            id,
+            entityName: account.entity,
+            data: {},
+            origin: accountConfig,
+            httpMethod,
+          });
+        }
+      }
+
+      if (identifier === 'hooks') {
+        if (account?.an) {
+          const accountConfig = await getAccountConfig(account.an);
+          return await handleHookVtexMD2({
+            id,
+            data: {},
+            origin: accountConfig,
+            httpMethod,
+          });
+        }
+      }
+      
+      return await handleDeleteRecordSchema({ id, tableName, identifier });
+
+    default:
+      return Apiresponse.response(405, `Method ${httpMethod} not allowed`);
+  }
+};
+
+const getAccountConfig = async (accountName) => {
+  const accountConfig = await AccountData.getAccountDataByAccountName(accountName);
+  if (!accountConfig) {
+    throw new Error(`Account configuration not found for account: ${accountName}`);
+  }
+  const { AccountName, Credentials } = accountConfig;
+  if (!AccountName || !Credentials?.key || !Credentials?.token) {
+    throw new Error(`Incomplete account configuration for account: ${accountName}`);
+  }
+  return {
+    AccountName,
+    AppKey: Credentials.key,
+    AppToken: Credentials.token,
+  };
+};
+
+const parseRequestBody = (body) => {
+  try {
+    return body ? JSON.parse(body) : {};
+  } catch (error) {
+    throw new Error("Invalid JSON body format.");
+  }
+};

package/src/functions/security/process_gas.js

@@ -0,0 +1,221 @@
+/**
+ * Funciones usadas en GAS (Google Apps Script) para ejecutar la actualización
+ * de roles con base a la información enviada por correo electrónico.
+ */
+
+// Se obtiene la referencia a las propiedades del script
+const propsServices = PropertiesService.getScriptProperties();
+const {
+  email_subject = 'Roles process',
+  auth_username,
+  auth_password,
+  auth_url,
+  service_url,
+  from_name = 'User roles manager',
+  limit_emails = 5
+} = propsServices.getProperties();
+
+/**
+ * Función callback del trigger configurado en Activadores(Triggers)
+ */
+function callbackTrigger() {
+  // Si se desea pausar la ejecución automática, se debe comentar el llamado a la función readEmails()
+  readEmails();
+}
+
+/**
+ * Función que se encarga de ejecutar el proceso de consultar los mensajes de correo para ejecutar la actualización de roles.
+ */
+function readEmails() {
+  // Se consulta los mensajes de correo sin leer y que tenga el asunto configurado en la propiedad 'email_subject'
+  const threads = GmailApp.search(`is:unread subject:(${email_subject})`);
+  if (!threads.length) {
+    return;
+  }
+
+  // Se obtiene el token de autenticación para ejecutar el servicio
+  let authResponse = getAuthToken();
+
+  // Contador de correos electrónicos
+  let counter = 0;
+
+  // Se consulta la lista de mensajes en cada uno de los hilos de mensajes
+  for (let thread of threads) {
+    // Se obtiene los mensajes de cada uno de los hilos
+    const messages = thread.getMessages();
+    for (const message of messages) {
+      const messageId = message.getId();
+      // Si el mensaje está sin leer, se ejecuta el proceso
+      if (message.isUnread()) {
+        // Si el contador no ha llegado al límite de correos
+        if (counter < limit_emails) {
+          // Se obtiene el email de quien envía el mensaje y los archivos adjuntos
+          let { name, email } = getFromMail(message), attachments = message.getAttachments();
+          if (email) {
+            // Se obtiene el template HTML del mensaje de correo
+            let templateEmail = HtmlService.createTemplateFromFile('EmailTemplate');
+            templateEmail.username = name;
+
+            // Se valida el número de archivos adjuntos
+            if (attachments.length == 1) {
+              executeService(authResponse, message, templateEmail, email, attachments[0]);
+            } else {
+              templateEmail.message = attachments.length == 0 ?
+                'Su solicitud no pudo ser procesada, debido a que el correo no contiene un archivo adjunto.' :
+                `Su solicitud no pudo ser procesada, debido a que el correo contiene más de un archivo adjunto (${attachments.length}).`;
+              sendEmailNotification(message, templateEmail, email);
+            }
+          } else {
+            console.error(`Email message ${messageId} without from email address`);
+          }
+
+          // Se marca el correo como leido
+          message.markRead();
+          counter++;
+        } else {
+          // Si el contador de correos supera el límite, se finaliza el loop de threads
+          break;
+        }
+      } else {
+      }
+    }
+
+    // Si el contador de correos supera el límite, se finaliza el loop de threads
+    if (counter >= limit_emails) {
+      break;
+    }
+  }
+}
+
+/**
+ * Obtiene el token de autenticación para ejecutar el servicio que se encarga de actualizar los roles de usuario.
+ * @return Objeto JSON con la respuesta de la API.
+ */
+function getAuthToken() {
+  // Token de autenticación Basic para ejecutar la autenticación al servicio
+  const basicToken = Utilities.base64Encode(auth_username + ':' + auth_password);
+
+  // Petición a la API de autenticación del servicio en Monaliza v2
+  let authRequest = UrlFetchApp.fetch(auth_url, {
+    method: 'POST',
+    headers: { 'Authorization': `Basic ${basicToken}` },
+    payload: {
+      'grant_type': 'client_credentials',
+      'scope': 'vtex.rol/vtex.rol.read'
+    },
+    // Se agrega este parámetro para que no se dispare la excepción en caso que la petición falle
+    muteHttpExceptions: true
+  });
+
+  let responseCode = authRequest.getResponseCode(), responseText = authRequest.getContentText();
+  if (responseCode !== 200) {
+    throw new Error(`Error ${responseCode}: `, responseText);
+  }
+
+  // Se obtiene el token de la respuesta de la petición
+  return JSON.parse(responseText);
+}
+
+/**
+ * Ejecuta el servicio encargado de actualizar los roles de usuario.
+ * @param {object} authResponse Objeto JSON con el token de autenticación.
+ * @param {GmailApp.GmailMessage} message Referencia al mensaje de correo enviado.
+ * @param {HtmlService.HtmlTemplate} templateEmail Referencia al template a usar en el cuerpo del correo electrónico.
+ * @param {string} email Dirección de correo del remitente.
+ * @param {GmailApp.GmailAttachment} attachment Archivo adjunto del correo electrónico.
+ */
+function executeService(authResponse, message, templateEmail, email, attachment) {
+  const boundary = 'googleAppsScriptBoundary';
+  // Se obtiene el nombre y tipo del archivo adjunto a enviar al servicio de actualización de roles
+  const fileName = attachment.getName(), fileType = attachment.getContentType();
+  // Content para el email del remitente
+  let emailData = '';
+  emailData += `--${boundary}\r\n`;
+  emailData += `Content-Disposition: form-data; name="email"\r\n\r\n`;
+  emailData += `${email}\r\n`;
+
+  // Se define el blob para el campo email
+  let emailFieldBlob = Utilities.newBlob(emailData).getBytes();
+
+  // Content para el archivo adjunto
+  let fileData = '';
+  fileData += `--${boundary}\r\n`;
+  fileData += `Content-Disposition: form-data; name="file"; filename="${fileName}"\r\n`;
+  fileData += `Content-Type: ${fileType}\r\n\r\n`;
+
+  // Se define el blob para el campo del archivo adjunto
+  let fileFieldBlob = Utilities.newBlob(fileData).getBytes().concat(attachment.copyBlob().getBytes());
+
+  // Se define el cuerpo de la petición con el email del remitente y la data del archivo adjunto, concatenando el cierre del bloque
+  let payload = emailFieldBlob.concat(fileFieldBlob)
+    .concat(Utilities.newBlob(`\r\n--${boundary}--`).getBytes());
+  const serviceRequest = UrlFetchApp.fetch(service_url, {
+    method: 'POST',
+    headers: { 'Authorization': `Bearer ${authResponse.access_token}` },
+    contentType: `multipart/form-data; boundary=${boundary}`,
+    payload: payload,
+    // Se agrega este parámetro para que no se dispare la excepción en caso que la petición falle
+    muteHttpExceptions: true,
+  });
+
+  // Se obtiene el código y cuerpo de la respuesta de la petición.
+  const serviceResponseCode = serviceRequest.getResponseCode();
+  // Se obtiene la respuesta de la petición en formato JSON
+  let serviceResponse = JSON.parse(serviceRequest.getContentText());
+
+  // Se establece el texto del cuerpo del mensaje de respuesta
+  templateEmail.message = serviceResponseCode == 200 ?
+    'Su solicitud ha sido procesada satisfactoriamente. En el archivo adjunto podrá encontrar el resumen de ejecución.' :
+    'Su solicitud no pudo ser sido procesada satisfactoriamente. En el archivo adjunto podrá encontrar el detalle del error presentado.';
+
+  sendEmailNotification(message, templateEmail, email, [
+    Utilities.newBlob(JSON.stringify(serviceResponse, null, 2), 'application/json', 'ServiceResponse.json')
+  ]);
+}
+
+/**
+ * Ejecuta el proceso de responder un mensaje de correo electrónico.
+ * @param {GmailApp.GmailMessage} message Referencia al mensaje de correo enviado.
+ * @param {HtmlService.HtmlTemplate} templateEmail Referencia al template a usar en el cuerpo del correo electrónico.
+ * @param {string} email Dirección de correo del remitente.
+ * @param {GmailApp.GmailAttachment[]} attachments Archivos adjuntos al correo de respuesta.
+ */
+function sendEmailNotification(message, templateEmail, email, attachments = null) {
+  let params = {
+    // Cuerpo del mensaje en formato HTML
+    htmlBody: templateEmail.evaluate().getContent(),
+    // Nombre de quien responde el correo
+    name: from_name,
+    // Parámetro para que en el correo se incluya el noreply@dominio.com
+    noReply: true
+  };
+
+  // Se valida si se incluye archivos adjuntos en la respuesta del correo
+  if (attachments?.length) {
+    params.attachments = attachments;
+  }
+
+  // Se responde el mensaje
+  let replyEmail = message.reply('', params);
+}
+
+/**
+ * Extrae el nombre y dirección de correo electrónico del remitente del mensaje.
+ * @param {GmailApp.GmailMessage} message Mensaje de correo electrónico.
+ * @return Nombre y dirección de correo electrónico del remitente.
+ */
+function getFromMail(message) {
+  let sender = message.getFrom();
+  if (sender) {
+    let match = sender.match(/"*(.+)"* <(.+)>/);
+    if (match?.length == 3) {
+      const [, name, email] = match;
+      if (name && email) {
+        return { name, email };
+      }
+    }
+
+    return { name: 'Usuario', email: sender };
+  }
+  return {};
+}