dcos-core-monalisav2-latam 1.0.0

package/src/functions/security/security-handler.js

@@ -0,0 +1,950 @@
+const { parse } = require('aws-multipart-parser');
+const validate = require('validate.js');
+const AWSServices = require('../../common/utils/aws-services');
+const ApiResponse = require('../../common/utils/api-response');
+const Util = require('../../common/utils/util.js');
+const SecretManagerApi = require('../../mdlz/auth/SecretManagerApi.js');
+const VtexApi = require('../../vtex/clients/VtexApi');
+const Logger = require("../../common/utils/logger");
+
+const MANAGER_STORE_KEYS = process.env.AUTHORIZATION_MANAGER_KEY;
+const REMOVE_USER = true;
+
+/**
+ * Función principal que maneja las solicitudes entrantes.
+ * @param {Object} event - Evento de AWS Lambda.
+ * @returns {Object} - Respuesta API con resultado del proceso.
+ */
+const producer = async (event) => {
+  // Datos iniciales de la respuesta a la petición
+  let statusCode = 200, responseMessage = { message: '' };
+
+  try {
+    // Determinar el tipo de operación basado en la ruta
+    const operationType = getOperationType(event);
+    
+    // Conexión a la API de Secret Manager
+    const configAuth = await AWSServices.getSecretValue(MANAGER_STORE_KEYS);
+    const auth = JSON.parse(configAuth);
+
+    // Rama de ejecución según tipo de operación
+    switch (operationType) {
+      case 'accounts':
+        return await processAccountsRequest(event, auth);
+      case 'users':
+        return await processUsersRequest(event, auth);
+      default:
+        return await processUsersRequest(event, auth);
+    }
+  } catch (ex) {
+    Logger.error('Error process request: ', ex);
+
+    statusCode = 400;
+    const { message } = ex;
+    try {
+      responseMessage = JSON.parse(message);
+    } catch (parseEx) {
+      responseMessage.message = `Process went wrong: ${message}`;
+    }
+  }
+
+  return ApiResponse.response(statusCode, responseMessage);
+};
+
+/**
+ * Determina el tipo de operación basado en la ruta de la petición
+ * @param {Object} event - Evento de AWS Lambda
+ * @returns {String} - Tipo de operación: 'users' o 'accounts'
+ */
+const getOperationType = (event) => {
+  const path = event.resource || '';
+  switch (path) {
+    case '/batch/users':
+      return 'users';
+    case '/batch/accounts':
+      return 'accounts';
+    default:
+      return 'users';
+  }
+};
+
+/**
+ * Procesa la solicitud para gestionar cuentas
+ * @param {Object} event - Evento de AWS Lambda
+ * @param {Object} auth - Configuración de autenticación
+ * @returns {Object} - Respuesta API con resultado del proceso
+ */
+async function processAccountsRequest(event, auth) {
+  let statusCode = 200;
+  let responseMessage = { message: '', dataSuccess: [], dataErrors: [] };
+
+  try {
+    // Consulta de los valores almacenados en el Secret Manager
+    const { accountsData, isAvailable, authorizedUsers, availableExtensions } = await getSecretDataAccount(auth);
+
+    // Extraer datos del formulario
+    const formData = getFormData(event, availableExtensions);
+    const { email: formDataEmail, file: formDataFile } = formData;
+
+    // Validar autorización del remitente
+    if (!validateSenderAuthorizationAdmin(formDataEmail, authorizedUsers, isAvailable)) {
+      return ApiResponse.response(403, {
+        message: `El usuario '${formDataEmail}' no está autorizado para ejecutar este proceso`
+      });
+    }
+
+    // Procesar el archivo CSV para accounts
+    const result = await processAccountsCsv(formDataFile, accountsData, auth);
+
+    responseMessage.message = "Proceso de cuentas finalizado";
+    responseMessage.dataSuccess = result.dataSuccess;
+    responseMessage.dataErrors = result.dataErrors;
+
+    return ApiResponse.response(statusCode, responseMessage);
+  } catch (error) {
+    Logger.error('Error procesando cuentas:', error);
+    return ApiResponse.response(400, {
+      message: `Error procesando cuentas: ${error.message}`
+    });
+  }
+}
+
+/**
+ * Procesa la solicitud para gestionar usuarios
+ * @param {Object} event - Evento de AWS Lambda
+ * @param {Object} auth - Configuración de autenticación
+ * @returns {Object} - Respuesta API con resultado del proceso
+ */
+async function processUsersRequest(event, auth) {
+  let statusCode = 200;
+  let responseMessage = { message: '', dataSuccess: [], dataErrors: [] };
+
+  try {
+    // Consulta de los valores almacenados en el Secret Manager
+    const { accountsData, isAvailable, authorizedUsers, availableExtensions } = await getSecretData(auth);
+    const { limitUsersProcess = 50 } = auth;
+
+    // Extraer datos del formulario
+    const formData = getFormData(event, availableExtensions);
+    const { email: formDataEmail, file: formDataFile } = formData;
+
+    // Validar permisos del usuario
+    let permissions = { '*': isAvailable };
+    if (Object.keys(authorizedUsers).length && formDataEmail && authorizedUsers.hasOwnProperty(formDataEmail)) {
+      permissions = { ...permissions, ...authorizedUsers[formDataEmail] };
+    }
+
+    // Validar si el usuario tiene permisos para ejecutar el proceso
+    const { '*': executeProcess, ...remainPermissions } = permissions;
+    if (!executeProcess && Object.keys(remainPermissions).length == 0) {
+      throw new Error(`The user '${formDataEmail}' isn't authorized for execute the process`);
+    }
+
+    // Obtener propiedades de validación del CSV
+    const { separatorColumn, constraints } = getCsvValidationProperties(accountsData, executeProcess, remainPermissions);
+
+    // Obtener filas del CSV
+    const { csvRows, headerRow } = getCsvRowsData(formDataFile, limitUsersProcess);
+
+    // Validar encabezado del CSV
+    const csvColumns = Object.keys(constraints);
+    if (!new RegExp(`^\\w+(?:${separatorColumn}\\w+)*$`).test(headerRow)) {
+      throw new Error(`CSV header '${headerRow}' must contain the column separator '${separatorColumn}'`);
+    }
+
+    // Validar columnas del CSV
+    const csvHeaderKeys = arrayToJson(headerRow.split(separatorColumn), []);
+    for (let key of csvColumns) {
+      if (csvHeaderKeys.hasOwnProperty(key)) {
+        delete csvHeaderKeys[key];
+      }
+    }
+
+    // Validar columnas inválidas
+    const invalidColumns = Object.keys(csvHeaderKeys);
+    if (invalidColumns.length) {
+      throw new Error(`CSV header contains invalid columns: '${invalidColumns.join(separatorColumn)}'`);
+    }
+
+    // Validar filas del CSV
+    let promises = [], checkUsers = {}, accountsIssue = {};
+    const dataSuccess = [], dataErrors = [];
+    validateRowsData(promises, checkUsers, csvRows, csvColumns, separatorColumn, constraints, dataErrors);
+
+    // Consultar usuarios en VTEX si es necesario
+    await findUsersInVtex(accountsData, checkUsers, accountsIssue);
+
+    if (promises.length) {
+      let result = await Promise.allSettled(promises.map(userRow => {
+        return new Promise(async (resolve) => {
+          const { jsonData } = userRow;
+          let { roles } = jsonData;
+          if (!roles && REMOVE_USER) {
+            await removeUser(accountsData, resolve, userRow, auth, checkUsers, accountsIssue);
+          } else {
+            await updateUserRoles(accountsData, resolve, userRow, auth);
+          }
+        });
+      })).catch(Logger.error);
+
+      for (let res of result) {
+        const { index, error, message } = res.value;
+        if (error) {
+          dataErrors[index] = `Line: ${index + 1}. Error: ${error}`;
+        } else {
+          dataSuccess[index] = `Line: ${index + 1}. Message: ${message}`;
+        }
+      }
+    }
+
+    responseMessage.message = 'Process finished';
+    responseMessage.dataSuccess = dataSuccess.filter(message => message);
+    responseMessage.dataErrors = dataErrors.filter(message => message);
+
+    return ApiResponse.response(statusCode, responseMessage);
+  } catch (error) {
+    Logger.error('Error procesando usuarios:', error);
+    return ApiResponse.response(400, {
+      message: `Error procesando usuarios: ${error.message}`
+    });
+  }
+}
+
+/**
+ * Valida si el remitente está autorizado para ejecutar el proceso
+ * @param {string} email - Correo del remitente
+ * @param {object} authorizedUsers - Objeto con usuarios autorizados
+ * @param {boolean} isAvailable - Indica si el sistema está disponible globalmente
+ * @returns {boolean} - Indica si el remitente está autorizado
+ */
+function validateSenderAuthorization(email, authorizedUsers, isAvailable) {
+  if (!email) return false;
+  if (isAvailable) return true;
+  if (authorizedUsers.hasOwnProperty(email)) {
+    const permissions = authorizedUsers[email];
+    if (permissions.hasOwnProperty('*') && permissions['*'] === true) {
+      return true;
+    }
+    for (const account in permissions) {
+      if (permissions[account] === true) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Valida si el remitente está autorizado para ejecutar el proceso (solo admin con permiso global)
+ * @param {string} email - Correo del remitente
+ * @param {object} authorizedUsers - Objeto con usuarios autorizados
+ * @param {boolean} isAvailable - Indica si el sistema está disponible globalmente
+ * @returns {boolean} - Indica si el remitente está autorizado
+ */
+function validateSenderAuthorizationAdmin(email, authorizedUsers, isAvailable) {
+  // Si no hay email, no está autorizado
+  if (!email) return false;
+  // Si el sistema está disponible globalmente, todos están autorizados
+  if (isAvailable) return true;
+  // Verificar si el usuario existe en la lista de autorizados
+  if (authorizedUsers.hasOwnProperty(email)) {
+    const permissions = authorizedUsers[email];
+    // Solo está autorizado si tiene el permiso global (*) explícitamente en true
+    return permissions['*'] === true;
+  }
+  // No está autorizado por defecto
+  return false;
+}
+
+/**
+ * Obtiene los datos enviados al cuerpo de la petición.
+ * @param {Object} event - Objeto con datos de la petición a la función lambda.
+ * @param {Array} availableExtensions - Lista de extensiones permitidas.
+ * @returns {Object} - Objeto con los datos del form-data.
+ */
+function getFormData(event, availableExtensions) {
+  const formData = parse(event, true);
+
+  let errors = validate(formData, {
+    'file': { presence: { allowEmpty: false } },
+    'file.type': { presence: { allowEmpty: false } },
+    'file.filename': { presence: { allowEmpty: false } },
+    'file.contentType': {
+      presence: { allowEmpty: false },
+      inclusion: {
+        within: availableExtensions,
+        message: `^El archivo debe tener una extensión .csv o .txt. Verifique el formato de su archivo e inténtelo nuevamente.`
+      }
+    },
+    'file.content': { presence: { allowEmpty: false } },
+    'email': { presence: { allowEmpty: true }, email: true }
+  });
+
+  if (errors) {
+    let errorsData = {};
+    for (let key in errors) {
+      const [message = ''] = errors[key];
+      errorsData[key] = message;
+    }
+    throw new Error(JSON.stringify(errorsData));
+  }
+
+  return formData;
+}
+
+/**
+ * Consulta los valores configuradas en Secret Manager.
+ * @param {Object} auth - Configuración de autenticación
+ * @returns {Object} - Datos de configuración obtenidos
+ */
+async function getSecretDataAccount(auth) {
+  const { tokenSecretManagerAPI, urlSecretManagerAPI, secretName } = auth;
+  const secretManagerApi = new SecretManagerApi(`Bearer ${tokenSecretManagerAPI}`, urlSecretManagerAPI);
+  const responseSecret = await secretManagerApi.fetch(`${secretName}`, { method: 'GET' }, true);
+  const { status: smStatus, statusText: smStatusText, data: smData } = responseSecret;
+
+  // Validar respuesta del Secret Manager
+  if (!(smStatus >= 200 && smStatus < 300)) {
+    throw new Error(`Can't get information from SM API`);
+  }
+
+  if (!smData?.[0]?.value) {
+    throw new Error(`Information from SM API not defined`);
+  }
+
+  const { 
+    isAvailable = false, 
+    authorizedUsers = {}, 
+    availableExtensions = ['text/csv', 'text/plain'], 
+    accounts = [] 
+  } = smData[0].value;
+
+  // 1. Procesar cuentas: Mantener como ARRAY para usar .some()
+  const accountsData = accounts
+    .filter(account => 
+      account.accountName && 
+      account.vtexAppkey && 
+      account.vtexAppToken
+    );
+
+  // 2. Limpiar permisos redundantes
+  Object.keys(authorizedUsers).forEach(email => {
+    const hasWildcard = authorizedUsers[email].hasOwnProperty('*');
+    const { '*': wildcardUser, ...remainPerms } = authorizedUsers[email];
+    
+    Object.keys(remainPerms).forEach(account => {
+      if (remainPerms[account] === (hasWildcard ? wildcardUser : isAvailable)) {
+        delete authorizedUsers[email][account];
+      }
+    });
+  });
+
+  return { 
+    accountsData, // Ahora es un array filtrado y mapeado
+    isAvailable, 
+    authorizedUsers, 
+    availableExtensions 
+  };
+}
+
+/**
+ * Consulta los valores configuradas en Secret Manager.
+ * @param {*} auth 
+ */
+async function getSecretData(auth) {
+  const { tokenSecretManagerAPI, urlSecretManagerAPI, secretName } = auth;
+  const secretManagerApi = new SecretManagerApi(`Bearer ${tokenSecretManagerAPI}`, urlSecretManagerAPI);
+  const responseSecret = await secretManagerApi.fetch(`${secretName}`, { method: 'GET' }, true);
+  const { status: smStatus, statusText: smStatusText, data: smData } = responseSecret;
+
+  // Se valida si la consulta de los secret fue exitosa
+  if (!(smStatus >= 200 && smStatus < 300)) {
+    throw new Error(`Can't get information from SM API`);
+  }
+
+  if (!smData?.[0]?.value) {
+    throw new Error(`Information from SM API not defined`);
+  }
+
+  const accountsData = {};
+  const { isAvailable = false, authorizedUsers = {}, availableExtensions = ['text/csv', 'text/plain'], accounts = [] } = smData[0].value;
+
+  // Se agrupa los datos de las cuentas por el nombre (accountName)
+  for (let account of accounts) {
+    const { accountName, vtexAppkey, vtexAppToken } = account;
+    if (accountName && !accountsData[accountName]) {
+      // Instancia de conexión a la API de VTEX para el account 'accountName'
+      accountsData[accountName] = new VtexApi(accountName, vtexAppkey, vtexAppToken);
+    }
+  }
+
+  // Se eliminan las redundancias que puede tener la parametrización de permisos
+  for (let email in authorizedUsers) {
+    const hasWildcard = authorizedUsers[email].hasOwnProperty('*');
+    const { '*': wildcardUser, ...remainPerms } = authorizedUsers[email];
+    for (let account in remainPerms) {
+      if (remainPerms[account] == hasWildcard ? wildcardUser : isAvailable) {
+        delete authorizedUsers[email][account];
+      }
+    }
+  }
+
+  return { accountsData, isAvailable, authorizedUsers, availableExtensions };
+}
+
+/**
+ * Procesa el archivo CSV para configurar accounts
+ * @param {object} fileData - Objeto con datos del archivo subido
+ * @param {object} accountsData - Datos de las cuentas existentes
+ * @param {object} auth - Configuración de autenticación
+ * @returns {object} - Resultados del procesamiento
+ */
+async function processAccountsCsv(fileData, accountsData, auth) {
+  const result = {
+    dataSuccess: [],
+    dataErrors: []
+  };
+
+  try {
+    // 1. Validación básica del contenido del archivo
+    let csvDataString = Buffer.from(fileData.content).toString();
+    if (!csvDataString || !csvDataString.trim()) {
+      throw new Error("El contenido del CSV está vacío o no es válido");
+    }
+
+    const csvRows = csvDataString.trim().split(/\r?\n/);
+    
+    // 2. Validación de headers
+    if (csvRows.length === 0) {
+      throw new Error("El archivo no contiene datos");
+    }
+
+    const headerRow = csvRows.shift();
+    
+    // 3. Validación de existencia de headers
+    if (!headerRow) {
+      throw new Error("El archivo no contiene encabezados. Debe incluir la primera línea con los nombres de columna.");
+    }
+
+    // 4. Validación del delimitador
+    if (!headerRow.includes(';')) {
+      throw new Error("El archivo CSV debe estar delimitado por ';'. Verifique el formato e inténtelo nuevamente.");
+    }
+
+    // 5. Validación de headers esperados
+    const headers = headerRow.split(';').map(h => h.trim().toLowerCase());
+    const expectedHeaders = ['action', 'accountname', 'appkey', 'apptoken'];
+    const missingHeaders = expectedHeaders.filter(h => !headers.includes(h));
+    
+    if (missingHeaders.length > 0) {
+      throw new Error(`Encabezados incorrectos. Faltan: ${missingHeaders.join(', ')}. Formato esperado: ACTION;ACCOUNTNAME;APPKEY;APPTOKEN`);
+    }
+
+    // Mapeo de índices de columnas
+    const columnIndices = {};
+    headers.forEach((header, index) => {
+      columnIndices[header] = index;
+    });
+
+    // Obtener configuración actual del Secret Manager
+    const { currentConfig, secretManagerApi } = await getCurrentSecretManagerConfig(auth);
+    
+    if (!Array.isArray(currentConfig.value.accounts)) {
+      currentConfig.value.accounts = [];
+    }
+
+    // Procesar cada fila del CSV
+    for (let [index, row] of csvRows.entries()) {
+      try {
+        row = row.trim();
+        if (!row) {
+          result.dataErrors.push(`Línea ${index + 2}: Fila vacía (se esperaban datos)`);
+          continue;
+        }
+
+        const rowData = row.split(';');
+        
+        // 6. Validación de campos vacíos
+        const action = (rowData[columnIndices.action]?.trim() || 'add').toLowerCase();
+        const accountName = rowData[columnIndices.accountname]?.trim();
+        const appKey = rowData[columnIndices.appkey]?.trim();
+        const appToken = rowData[columnIndices.apptoken]?.trim();
+
+        // Validar campos obligatorios
+        const errors = [];
+        if (!accountName) errors.push('ACCOUNTNAME no puede estar vacío');
+        if (!appKey) errors.push('APPKEY no puede estar vacío');
+        if (!appToken) errors.push('APPTOKEN no puede estar vacío');
+        if (!['add', 'delete'].includes(action)) {
+          errors.push(`ACTION '${action}' no válida (solo ADD/DELETE)`);
+        }
+
+        if (errors.length > 0) {
+          result.dataErrors.push(`Línea ${index + 2}: ${errors.join('; ')}`);
+          continue;
+        }
+
+        // Procesar acción
+        const accountData = {
+          accountName: accountName.toLowerCase(),
+          vtexAppkey: appKey,
+          vtexAppToken: appToken
+        };
+
+        if (action === 'add') {
+          // Eliminar cuenta existente si ya existe
+          currentConfig.value.accounts = currentConfig.value.accounts.filter(
+            acc => acc.accountName.toLowerCase() !== accountData.accountName
+          );
+          currentConfig.value.accounts.push(accountData);
+          result.dataSuccess.push(`Línea ${index + 2}: Cuenta '${accountData.accountName}' agregada/actualizada correctamente`);
+        } else if (action === 'delete') {
+          const initialCount = currentConfig.value.accounts.length;
+          currentConfig.value.accounts = currentConfig.value.accounts.filter(
+            acc => acc.accountName.toLowerCase() !== accountData.accountName
+          );
+          if (initialCount === currentConfig.value.accounts.length) {
+            result.dataErrors.push(`Línea ${index + 2}: Cuenta '${accountData.accountName}' no encontrada para eliminar`);
+          } else {
+            result.dataSuccess.push(`Línea ${index + 2}: Cuenta '${accountData.accountName}' eliminada correctamente`);
+          }
+        }
+      } catch (error) {
+        result.dataErrors.push(`Línea ${index + 2}: Error procesando - ${error.message}`);
+      }
+    }
+
+    // Actualizar Secret Manager solo si no hay errores críticos
+    if (result.dataErrors.length === 0 || result.dataSuccess.length > 0) {
+      const updateResponse = await secretManagerApi.fetch(`${currentConfig.id}/${currentConfig.name}`, {
+        method: 'PUT',
+        data: {
+          id: currentConfig.id,
+          name: currentConfig.name,
+          value: currentConfig.value
+        }
+      }, true);
+
+      if (updateResponse.status < 200 || updateResponse.status >= 300) {
+        throw new Error(`Error al actualizar Secret Manager: ${updateResponse.statusText}`);
+      }
+    }
+
+  } catch (error) {
+    // Capturar errores de validación globales
+    throw new Error(`Error procesando CSV: ${error.message}`);
+  }
+
+  return result;
+}
+
+/**
+ * Obtiene la configuración actual del Secret Manager
+ * @param {object} auth - Configuración de autenticación
+ * @returns {object} - Configuración actual y instancia de SecretManagerApi
+ */
+async function getCurrentSecretManagerConfig(auth) {
+  const { tokenSecretManagerAPI, urlSecretManagerAPI, secretName } = auth;
+  const secretManagerApi = new SecretManagerApi(`Bearer ${tokenSecretManagerAPI}`, urlSecretManagerAPI);
+  const response = await secretManagerApi.fetch(`${secretName}`, { method: 'GET' }, true);
+
+  if (response.status < 200 || response.status >= 300) {
+    throw new Error(`Error al obtener información del Secret Manager: ${response.statusText}`);
+  }
+
+  if (!response.data?.[0]?.value) {
+    throw new Error("No se encontró configuración en Secret Manager");
+  }
+
+  // Manejar tanto string JSON como objeto
+  let secretValue = response.data[0].value;
+  if (typeof secretValue === 'string') {
+    try {
+      secretValue = JSON.parse(secretValue);
+    } catch (e) {
+      throw new Error("El valor del secret no es un JSON válido");
+    }
+  }
+
+  // Asegurar que accounts es un array
+  if (!Array.isArray(secretValue.accounts)) {
+    secretValue.accounts = [];
+  }
+
+  return {
+    currentConfig: {
+      id: response.data[0].id || secretName,
+      name: response.data[0].name || secretName,
+      value: secretValue
+    },
+    secretManagerApi
+  };
+}
+
+/**
+ * Obtiene el contenido del archivo CSV enviado en la petición.
+ * @param {object} fileData - Objeto con los datos del archivo subido.
+ * @param {Number} limitUsersProcess - Número máximo de filas que debe tener el archivo.
+ * @returns {Object} - Fila de encabezado, y filas restantes del archivo leido.
+ */
+function getCsvRowsData(fileData, limitUsersProcess) {
+  // Se obtiene el contenido del archivo subido
+  let csvDataString = Buffer.from(fileData.content).toString();
+  if (csvDataString) {
+    csvDataString = csvDataString.trim();
+  }
+
+  if (!csvDataString) {
+    throw new Error(`CSV content is empty or is invalid`);
+  }
+
+  // Se obtiene las filas del archivo
+  const csvRows = csvDataString.split(/\r?\n/), headerRow = csvRows.shift();
+
+  // Se valida que existan filas en el contenido
+  if (csvRows.length == 0) {
+    throw new Error(`CSV content is required`);
+  }
+
+  // Se valida que el N° de filas no supere el valor máximo establecido
+  if (csvRows.length > limitUsersProcess) {
+    throw new Error(`Limit process exceed to upload and update users. Maximum users: ${limitUsersProcess}`);
+  }
+
+  return { csvRows, headerRow };
+}
+
+/**
+ * Obtiene las propiedades a usar en la validación del contenido del archivo csv.
+ * @param {object} accountsData - Lista de accounts registradas en SecretManager.
+ * @param {Boolean} hasPermission - Valor que indica si se tiene permisos para ejecutar la actualización con todas los accounts.
+ * @param {object} remainPermissions - Objeto con lista de accounts exentos de la condicional 'hasPermission'.
+ * @returns {Object} - Caracter * del separador de columnas (separatorColumn) y reglas de validación (constraints).
+ */
+function getCsvValidationProperties(accountsData, hasPermission, remainPermissions) {
+  let exclusion = [];
+  for (let account in accountsData) {
+    if (remainPermissions.hasOwnProperty(account)) {
+      if (!remainPermissions[account]) {
+        exclusion.push(account);
+      }
+    } else if (!hasPermission) {
+      exclusion.push(account);
+    }
+  }
+
+  const separatorColumn = ';', constraints = {
+    'accountname': {
+      'presence': { allowEmpty: false },
+      'inclusion': {
+        'within': Object.keys(accountsData),
+        'message': `^'%{value}' isn't in the accounts configuration list`
+      },
+      'exclusion': {
+        'within': exclusion,
+        'message': `^User isn't authorized for process roles in account '%{value}'`
+      }
+    },
+    'email': {
+      'presence': { allowEmpty: false },
+      'email': {
+        'message': `'%{value}' is not valid`
+      }
+    },
+    'roles': {
+      'presence': { allowEmpty: true },
+      'format': {
+        'pattern': /^\d*(,\d+)*$/,
+        'message': `'%{value}' is not a valid comma separated id values`
+      }
+    }
+  };
+
+  return { separatorColumn, constraints };
+}
+
+/**
+ * Realiza la validación de datos para cada una de las filas del archivo
+ * @param {array} promises - Array donde se inserta los datos válidos.
+ * @param {object} checkUsers - Objeto donde se consolida los usuarios a eliminar.
+ * @param {array} csvRows - Filas del archivo csv leido.
+ * @param {array} csvColumns - Lista de columnas del archivo.
+ * @param {string} separatorColumn - Separador de columnas.
+ * @param {object} constraints - Reglas de validación del archivo.
+ * @param {array} dataErrors - Lista donde se concatena el mensaje de error para cada línea del archivo.
+ */
+function validateRowsData(promises, checkUsers, csvRows, csvColumns, separatorColumn, constraints, dataErrors) {
+  for (let [index, row] of csvRows.entries()) {
+    row = row.trim();
+    if (row) {
+      if (new RegExp(`^.*(?:${separatorColumn}.*){${csvColumns.length - 1}}$`).test(row)) {
+        let rowData = row.split(separatorColumn);
+        const jsonData = arrayToJson(csvColumns, rowData);
+        let errors = validate(jsonData, constraints);
+        if (errors) {
+          let reportErrors = [];
+          for (let err in errors) {
+            const [message = ''] = errors[err];
+            if (message) {
+              reportErrors.push(message);
+            }
+          }
+          dataErrors[index] = `Line: ${index + 1}. Error: ${reportErrors.join(';')}`;
+        } else {
+          promises.push({ index, jsonData });
+
+          let { accountname, email, roles } = jsonData;
+          if (!roles && REMOVE_USER) {
+            if (accountname && !checkUsers.hasOwnProperty(accountname)) {
+              checkUsers[accountname] = {};
+            }
+            if (email && !checkUsers[accountname]?.hasOwnProperty(email)) {
+              checkUsers[accountname][email] = null;
+            }
+          }
+        }
+      } else {
+        dataErrors[index] = `Line: ${index + 1}. Error: row data '${row}' does not have the columns separator (${separatorColumn}) and/or does not have the columns number required (${csvColumns.length})`;
+      }
+    } else {
+      dataErrors[index] = `Line: ${index + 1}. Error: Line is empty`;
+    }
+  }
+}
+
+/**
+ * Convierte un array a un objeto JSON usando las cabeceras como claves.
+ * @param {Array} headers - Cabeceras que serán usadas como claves
+ * @param {Array} items - Valores a asignar a cada clave
+ * @returns {Object} - Objeto JSON con los datos
+ */
+function arrayToJson(headers, items) {
+  let objectData = {};
+  headers.forEach((key, index) => {
+    objectData[key] = items?.[index]?.trim() ?? null;
+  });
+  return objectData;
+}
+
+/**
+ * Actualiza los roles asociados a un determinado usuario.
+ * @param {object} accountsData - Datos de cuentas
+ * @param {function} resolve - Función para resolver la promesa
+ * @param {object} userRow - Objeto de datos de la fila
+ * @param {object} auth - Configuración de autenticación
+ */
+async function updateUserRoles(accountsData, resolve, userRow, auth) {
+  const { index, jsonData } = userRow;
+  let { accountname, email, roles } = jsonData;
+
+  const responseCreateUser = await accountsData[accountname].fetch(auth?.pathCreateUser, {
+    method: 'POST',
+    data: { name: '', email }
+  }, false).catch(ex => {
+    const errReq = Util.getErrorData(ex);
+    Logger.error(errReq);
+    const { status, message } = errReq;
+    switch (status) {
+      case 400:
+        resolve({ index, error: `Invalid VTEX request for create user with email '${email}'` });
+        break;
+      case 403:
+        resolve({ index, error: `Denied access or invalid/inactived credentials for create user in account '${accountname}'` });
+        break;
+      default:
+        resolve({ index, error: message });
+        break;
+    }
+  });
+
+  if (responseCreateUser?.data?.id) {
+    const { id: userId } = responseCreateUser.data;
+
+    let rolesKeys = {};
+    for (let roleId of roles.split(',')) {
+      roleId = String(roleId);
+      if (roleId) {
+        rolesKeys[roleId] = true;
+      }
+    }
+
+    const relativeGetAddRoleByUser = auth?.pathGetAddRoleByUser.replace('{userId}', userId);
+    const responseGetRoles = await accountsData[accountname].fetch(`${relativeGetAddRoleByUser}`, { method: 'GET' }, false).catch(ex => {
+      const errReq = Util.getErrorData(ex);
+      Logger.error(errReq);
+      const { status, message } = errReq;
+      switch (status) {
+        case 400:
+          resolve({ index, error: `Invalid VTEX request for get user roles with email '${email}'. ${message}` });
+          break;
+        case 403:
+          resolve({ index, error: `Denied access or invalid/inactived credentials for get user roles in account '${accountname}'. ${message}` });
+          break;
+        default:
+          resolve({ index, error: message });
+          break;
+      }
+    });
+
+    if (responseGetRoles?.data) {
+      for (let roleItem of responseGetRoles.data) {
+        if (roleItem?.id) {
+          let userRoleId = String(roleItem.id);
+          if (rolesKeys.hasOwnProperty(userRoleId)) {
+            delete rolesKeys[userRoleId];
+          } else {
+            const relativeDeleteRoleByUser = auth?.pathRemoveRoleByUser.replace('{userId}', userId).replace('{roleId}', userRoleId);
+            const responseDelRoles = await accountsData[accountname].fetch(relativeDeleteRoleByUser, { method: 'DELETE' }, false).catch(ex => {
+              const errReq = Util.getErrorData(ex);
+              Logger.error(errReq);
+            });
+            if (responseDelRoles) {
+              Logger.log(`Role ${userRoleId} was deleted successfully for user ${userId}`);
+            }
+          }
+        }
+      }
+
+      const newRolesId = Object.keys(rolesKeys);
+      if (newRolesId.length) {
+        const responseSetUserRoles = await accountsData[accountname].fetch(relativeGetAddRoleByUser, {
+          method: 'PUT', data: newRolesId
+        }, false).catch(ex => {
+          const errReq = Util.getErrorData(ex);
+          Logger.error(errReq);
+          const { status, message } = errReq;
+          switch (status) {
+            case 400:
+              resolve({ index, error: `${message}. Roles list: '${newRolesId.join(',')}'. Email: '${email}'. Account: ${accountname}` });
+              break;
+            case 403:
+              resolve({ index, error: `Denied access or invalid/inactived credentials for put user roles '${newRolesId.join(',')}' in account '${accountname}'. ${message}` });
+              break;
+            default:
+              resolve({ index, error: message });
+              break;
+          }
+        });
+
+        if (responseSetUserRoles) {
+          resolve({ index, message: `User '${email}' created/updated successfully` });
+        }
+      } else {
+        resolve({ index, message: `User '${email}' not modified` });
+      }
+    } else {
+      resolve({ index, error: `Error white get user roles for email '${email}'` });
+    }
+  } else {
+    resolve({ index, error: `User '${email}' not created/updated` });
+  }
+}
+
+/**
+ * Realiza la eliminación del usuario de VTEX.
+ * @param {object} accountsData - Datos de cuentas
+ * @param {function} resolve - Función para resolver la promesa
+ * @param {object} userRow - Objeto de datos del usuario a eliminar
+ * @param {object} auth - Configuración de autenticación
+ * @param {object} checkUsers - Lista de usuarios con opción de ser eliminados
+ * @param {object} accountsIssue - Lista de accounts que haya presentado algún incidente
+ */
+async function removeUser(accountsData, resolve, userRow, auth, checkUsers, accountsIssue) {
+  const { index, jsonData } = userRow;
+  let { accountname, email } = jsonData;
+
+  if (checkUsers?.[accountname]?.[email]) {
+    const deleteUserEndpoint = auth?.pathCreateUser + '/' + checkUsers[accountname][email];
+
+    const responseDeleteUser = await accountsData[accountname].fetch(deleteUserEndpoint, {
+      method: 'DELETE'
+    }, false).catch(ex => {
+      const errReq = Util.getErrorData(ex);
+      const { status, message } = errReq;
+      switch (status) {
+        case 400:
+          resolve({ index, error: `Invalid VTEX request for delete user with email '${email}'` });
+          break;
+        case 403:
+          resolve({ index, error: `Denied access or invalid/inactived credentials for delete user in account '${accountname}'` });
+          break;
+        default:
+          resolve({ index, error: message });
+          break;
+      }
+    });
+
+    if (responseDeleteUser) {
+      resolve({ index, message: `User '${email}' delete success in account '${accountname}'` });
+    }
+  } else if (accountsIssue.hasOwnProperty(accountname)) {
+    resolve({ index, error: accountsIssue[accountname] })
+  } else {
+    resolve({ index, message: `User '${email}' not found in account '${accountname}'` });
+  }
+}
+
+/**
+ * Consulta en cada account la lista de usuarios.
+ * @param {object} accountsData - Instancias de conexión a la API de VTEX por accounts.
+ * @param {object} checkUsers - Lista de usuarios a eliminar.
+ * @param {object} accountsIssue - Lista de accounts que haya presentado algún incidente.
+ */
+async function findUsersInVtex(accountsData, checkUsers, accountsIssue) {
+  if (Object.keys(checkUsers).length) {
+    await Promise.allSettled(Object.entries(checkUsers).map(accountData => {
+      return new Promise(async (resolve, reject) => {
+        const [accountName, users] = accountData;
+
+        let pageNumber = 1, numItems = 100;
+        do {
+          const responseListUsers = await accountsData[accountName].fetch(Util.setQueryParams('/license-manager/site/pvt/logins/list/paged', {
+            pageNumber, numItems
+          }), {
+            method: 'GET'
+          }, false).catch(ex => {
+            const errReq = Util.getErrorData(ex);
+            Logger.error(errReq);
+
+            let message;
+            switch (errReq.status) {
+              case 400:
+                message = `Invalid VTEX request for find users in account '${accountName}'`;
+                break;
+              case 401:
+                message = `Credential key is inactived in account '${accountName}'`;
+                break;
+              case 403:
+                message = `Denied access or invalid/inactived credentials for find users in account '${accountName}'`;
+                break;
+            }
+
+            if (!accountsIssue.hasOwnProperty(accountName) && message) {
+              accountsIssue[accountName] = message;
+            }
+          });
+          if (responseListUsers?.data?.items?.length) {
+            const { items } = responseListUsers.data;
+            for (let userData of items) {
+              const { id, email } = userData;
+              if (id && email) {
+                if (users.hasOwnProperty(email)) {
+                  users[email] = id;
+                }
+              }
+            }
+
+            pageNumber++;
+          } else {
+            break;
+          }
+        } while (true);
+        resolve(accountName);
+      });
+    })).catch(Logger.error);
+  }
+}
+
+module.exports = {
+  producer,
+};