dcos-core-monalisav2-latam 1.0.0

package/src/entities/account.js

@@ -0,0 +1,639 @@
+const DynamoAWS = require("aws-sdk/clients/dynamodb");
+const Validation = require("../common/utils/validation-data");
+const Logger = require("../common/utils/logger");
+
+const ACCOUNT_DATA_CONFIG_TABLE = process.env.ACCOUNT_DATA_CONFIG_TABLE;
+const MAX_LIMIT = process.env.MAX_LIMIT || 150;
+
+/**
+ * Procesa respuesta de DynamoDB aplicando filtros adicionales y transformaciones
+ * @param {Array} items - Elementos obtenidos de DynamoDB
+ * @param {Object} queryParams - Parámetros de consulta
+ * @returns {Array} - Elementos filtrados y procesados
+ */
+const processItems = (items, queryParams) => {
+  if (!items || !items.length) return [];
+
+  let processedItems = [...items];
+
+  // Aplicar filtro _moduleActive
+  if (queryParams._moduleActive) {
+    const module = queryParams._moduleActive;
+    processedItems = processedItems.filter(item =>
+      item[module] &&
+      ((typeof item[module] === 'object' && item[module].isActive === true) ||
+        (typeof item[module] === 'boolean' && item[module] === true))
+    );
+  }
+
+  // Aplicar filtro _accountPattern
+  if (queryParams._accountPattern) {
+    const pattern = queryParams._accountPattern.replace(/\*/g, '.*');
+    const regex = new RegExp(`^${pattern}$`, 'i');
+    processedItems = processedItems.filter(item => regex.test(item.AccountName));
+  }
+
+  // Aplicar filtro _integration
+  if (queryParams._integration) {
+    const integrationType = queryParams._integration.toLowerCase();
+
+    processedItems = processedItems.filter(item => {
+      switch (integrationType) {
+        case 'sftp':
+          return item.SftpUsed === true ||
+            (item.SftpIntegration && item.SftpIntegration.isActive === true);
+        case 'api':
+          return item.Credentials && item.Credentials.key && item.Credentials.token;
+        case 'webhook':
+          return item.HookOrderVtexMDv2 && item.HookOrderVtexMDv2.trim() !== '';
+        default:
+          return false;
+      }
+    });
+  }
+
+  // Aplicar filtro _like
+  if (queryParams._like) {
+    const searchTerm = queryParams._like.toLowerCase();
+
+    processedItems = processedItems.filter(item => {
+      // Buscar en todas las propiedades de primer nivel
+      return Object.entries(item).some(([key, value]) => {
+        if (typeof value === 'string') {
+          return value.toLowerCase().includes(searchTerm);
+        } else if (typeof value === 'number') {
+          return value.toString().includes(searchTerm);
+        } else if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'string') {
+          return value.some(val => val.toLowerCase().includes(searchTerm));
+        }
+        return false;
+      });
+    });
+  }
+
+  // Proyectar campos si se especifican en _fields
+  if (queryParams._fields) {
+    const fields = queryParams._fields.split(',').map(f => f.trim());
+
+    processedItems = processedItems.map(item => {
+      const projectedItem = {};
+      fields.forEach(field => {
+        // Soporte para campos anidados con notación de punto
+        if (field.includes('.')) {
+          const parts = field.split('.');
+          let current = item;
+          let valid = true;
+
+          // Navegar por el objeto hasta el campo anidado
+          for (let i = 0; i < parts.length - 1; i++) {
+            if (current && current[parts[i]]) {
+              current = current[parts[i]];
+            } else {
+              valid = false;
+              break;
+            }
+          }
+
+          // Si el camino es válido, extraer el valor final
+          const lastPart = parts[parts.length - 1];
+          if (valid && current && current[lastPart] !== undefined) {
+            // Crear estructura anidada en el objeto proyectado
+            let target = projectedItem;
+            for (let i = 0; i < parts.length - 1; i++) {
+              if (!target[parts[i]]) {
+                target[parts[i]] = {};
+              }
+              target = target[parts[i]];
+            }
+            target[lastPart] = current[lastPart];
+          }
+        } else if (item[field] !== undefined) {
+          projectedItem[field] = item[field];
+        }
+      });
+
+      return projectedItem;
+    });
+  }
+
+  // Excluir campos si se especifican en _excludeFields
+  if (queryParams._excludeFields) {
+    const excludeFields = queryParams._excludeFields.split(',').map(f => f.trim());
+
+    processedItems = processedItems.map(item => {
+      const filteredItem = { ...item };
+
+      excludeFields.forEach(field => {
+        // Soporte para campos anidados con notación de punto
+        if (field.includes('.')) {
+          const parts = field.split('.');
+          let current = filteredItem;
+
+          // Navegar hasta el penúltimo nivel
+          for (let i = 0; i < parts.length - 1; i++) {
+            if (!current[parts[i]]) {
+              return; // Campo no existe, nada que eliminar
+            }
+            current = current[parts[i]];
+          }
+
+          // Eliminar propiedad del último nivel
+          const lastPart = parts[parts.length - 1];
+          if (current[lastPart] !== undefined) {
+            delete current[lastPart];
+          }
+        } else {
+          delete filteredItem[field];
+        }
+      });
+
+      return filteredItem;
+    });
+  }
+
+  return processedItems;
+};
+
+/**
+ * Obtiene cuentas filtradas por ParentAccountName y parámetros avanzados de consulta
+ * @param {string} parentAccountName - Nombre de la cuenta padre (opcional)
+ * @param {Object} queryParams - Parámetros adicionales de consulta (opcional)
+ * @returns {Promise<{items: Array, lastEvaluatedKey: Object|null, count: number}>} - Resultados paginados
+ */
+const getAccountsByParentName = async (parentAccountName, queryParams = {}) => {
+  try {
+    const dynamodb = new DynamoAWS.DocumentClient();
+
+    // Configuración de parámetros básicos
+    const limit = Math.min(parseInt(queryParams._limit) || MAX_LIMIT, MAX_LIMIT);
+    const sortAscending = queryParams._sort?.toLowerCase() !== 'desc';
+    const exclusiveStartKey = queryParams._from ? JSON.parse(Buffer.from(queryParams._from, 'base64').toString()) : null;
+
+    // Parámetros base para DynamoDB
+    let params = {
+      TableName: ACCOUNT_DATA_CONFIG_TABLE,
+      Limit: limit,
+    };
+
+    // Si hay un ExclusiveStartKey (para paginación)
+    if (exclusiveStartKey) {
+      params.ExclusiveStartKey = exclusiveStartKey;
+    }
+
+    // Si se proporciona una cuenta padre, usar query con el índice adecuado
+    if (parentAccountName) {
+      // Usar el índice ParentAccountNameIndex
+      params.IndexName = "ParentAccountNameIndex";
+      params.KeyConditionExpression = "ParentAccountName = :parentName";
+      params.ExpressionAttributeValues = {
+        ":parentName": parentAccountName
+      };
+      params.ScanIndexForward = sortAscending; // Control del orden
+
+      // Ejecutar la consulta a DynamoDB
+      const response = await dynamodb.query(params).promise();
+
+      // Procesar los resultados con los filtros adicionales
+      const processedItems = processItems(response.Items || [], queryParams);
+
+      return {
+        items: processedItems,
+        lastEvaluatedKey: response.LastEvaluatedKey ?
+          Buffer.from(JSON.stringify(response.LastEvaluatedKey)).toString('base64') :
+          null,
+        count: processedItems.length
+      };
+    }
+    // Si no se proporciona cuenta padre, usar scan
+    else {
+      // Ejecutar scan en DynamoDB
+      const response = await dynamodb.scan(params).promise();
+
+      // Procesar los resultados con los filtros adicionales
+      let processedItems = processItems(response.Items || [], queryParams);
+
+      // Ordenar resultados si se solicita
+      if (queryParams._sort) {
+        processedItems.sort((a, b) => {
+          if (sortAscending) {
+            return a.AccountName > b.AccountName ? 1 : -1;
+          } else {
+            return a.AccountName < b.AccountName ? 1 : -1;
+          }
+        });
+      }
+
+      return {
+        items: processedItems,
+        lastEvaluatedKey: response.LastEvaluatedKey ?
+          Buffer.from(JSON.stringify(response.LastEvaluatedKey)).toString('base64') :
+          null,
+        count: processedItems.length
+      };
+    }
+  } catch (err) {
+    Logger.error("Error getting accounts data: ", err);
+    return { items: [], lastEvaluatedKey: null, count: 0 };
+  }
+};
+
+/**
+ * Obtiene todas las cuentas con soporte para paginación y filtros avanzados
+ * @param {Object} queryParams - Parámetros de consulta
+ * @returns {Promise<{items: Array, lastEvaluatedKey: Object|null, count: number}>} - Resultados paginados
+ */
+const getAccountDataAll = async (queryParams = {}) => {
+  return getAccountsByParentName(null, queryParams);
+};
+
+/**
+ * Obtiene una cuenta específica por su AccountName con soporte para proyección de campos
+ * @param {string} accountName - Nombre de la cuenta a buscar
+ * @param {Object} queryParams - Parámetros de consulta para proyección
+ * @returns {Promise<Object|null>} - Cuenta encontrada o null
+ */
+const getAccountDataByAccountName = async (accountName, queryParams = {}) => {
+  try {
+    const dynamodb = new DynamoAWS.DocumentClient();
+    const params = {
+      TableName: ACCOUNT_DATA_CONFIG_TABLE,
+      IndexName: "AccountNameIndex",
+      KeyConditionExpression: "AccountName = :accountName",
+      ExpressionAttributeValues: {
+        ":accountName": accountName,
+      },
+    };
+    const response = await dynamodb.query(params).promise();
+
+    if (!response?.Items || response.Items.length === 0) {
+      return null;
+    }
+
+    // Aplicar proyección a un solo elemento
+    const items = processItems([response.Items[0]], queryParams);
+    return items[0] || null;
+  } catch (err) {
+    Logger.error("Error getting account data: ", err);
+    return null;
+  }
+};
+
+// El resto de funciones permanece igual
+const deleteAccountByAccountName = async (accountName) => {
+  try {
+    const account = await getAccountDataByAccountName(accountName);
+    if (!account) {
+      Logger.error(`Account ${accountName} not found for deletion`);
+      return { success: false, message: `Account ${accountName} not found` };
+    }
+    const dynamodb = new DynamoAWS.DocumentClient();
+    const params = {
+      TableName: ACCOUNT_DATA_CONFIG_TABLE,
+      Key: {
+        AccountName: accountName,
+        ParentAccountName: account.ParentAccountName
+      }
+    };
+    await dynamodb.delete(params).promise();
+    return {
+      success: true,
+      message: `Account ${accountName} deleted successfully`
+    };
+  } catch (err) {
+    Logger.error(`Error deleting account ${accountName}:`, err);
+    return {
+      success: false,
+      message: `Error deleting account: ${err.message}`
+    };
+  }
+};
+
+const addAccountDataConfig = async (accountData) => {
+  const dynamodb = new DynamoAWS.DocumentClient();
+  let data = Validation.transformFirstKeysToUpperCaseValue(accountData);
+  try {
+    const params = {
+      TableName: ACCOUNT_DATA_CONFIG_TABLE,
+      Item: data,
+      ConditionExpression: "attribute_not_exists(AccountName)",
+    };
+    await dynamodb.put(params).promise();
+    return accountData;
+  } catch (err) {
+    Logger.error("Error saving account data config: ", err);
+    if (err.code === "ConditionalCheckFailedException") {
+      try {
+        let updateExpression = 'set';
+        let ExpressionAttributeNames = {};
+        let ExpressionAttributeValues = {};
+        for (const property in data) {
+          if (property != 'AccountName' && property != 'ParentAccountName') {
+            updateExpression += ` #${property} = :${property} ,`;
+            ExpressionAttributeNames['#' + property] = property;
+            ExpressionAttributeValues[':' + property] = data[property];
+          }
+        }
+        updateExpression = updateExpression.slice(0, -1);
+        const params2 = {
+          TableName: ACCOUNT_DATA_CONFIG_TABLE,
+          Key: {
+            AccountName: data.AccountName,
+            ParentAccountName: data.ParentAccountName
+          },
+          UpdateExpression: updateExpression,
+          ExpressionAttributeNames: ExpressionAttributeNames,
+          ExpressionAttributeValues: ExpressionAttributeValues
+        };
+        let res2 = await dynamodb.update(params2).promise();
+        return accountData;
+      } catch (err2) {
+        Logger.error("Error updating account data config: ", err2);
+        if (err2.code === "ConditionalCheckFailedException") {
+          return accountData;
+        }
+        return null
+      }
+    }
+    return null;
+  }
+};
+
+/**
+ * Función de paginación completa para DataTables
+ */
+const getAccountsWithDataTablesPagination = async (dataTablesParams) => {
+  try {
+    const dynamodb = new DynamoAWS.DocumentClient();
+
+    const totalCountParams = {
+      TableName: ACCOUNT_DATA_CONFIG_TABLE,
+      Select: 'COUNT'
+    };
+
+    const totalCountResponse = await dynamodb.scan(totalCountParams).promise();
+    const recordsTotal = totalCountResponse.Count;
+
+    const allFilteredItems = await getAllFilteredAccounts(dataTablesParams);
+    const sortedItems = applySortingToAccounts(allFilteredItems, dataTablesParams.orderField, dataTablesParams.orderDir);
+
+    const start = dataTablesParams.start;
+    const length = dataTablesParams.length;
+    const paginatedItems = sortedItems.slice(start, start + length);
+
+    return {
+      data: paginatedItems,
+      recordsTotal: recordsTotal,
+      recordsFiltered: sortedItems.length,
+      draw: dataTablesParams.draw
+    };
+
+  } catch (err) {
+    Logger.error("Error in getAccountsWithDataTablesPagination: ", err);
+    return {
+      data: [],
+      recordsTotal: 0,
+      recordsFiltered: 0,
+      draw: dataTablesParams.draw
+    };
+  }
+};
+
+/**
+ * Obtiene TODOS los registros filtrados usando paginación completa de DynamoDB
+ */
+const getAllFilteredAccounts = async (dataTablesParams) => {
+  const dynamodb = new DynamoAWS.DocumentClient();
+  let allItems = [];
+  let lastEvaluatedKey = null;
+  const BATCH_SIZE = 100;
+
+  do {
+    const params = {
+      TableName: ACCOUNT_DATA_CONFIG_TABLE,
+      Limit: BATCH_SIZE,
+      ExclusiveStartKey: lastEvaluatedKey
+    };
+
+    const response = await dynamodb.scan(params).promise();
+    const filteredBatch = applyFiltersToAccounts(response.Items || [], dataTablesParams);
+    allItems = [...allItems, ...filteredBatch];
+
+    lastEvaluatedKey = response.LastEvaluatedKey;
+
+  } while (lastEvaluatedKey);
+
+  return allItems;
+};
+
+/**
+ * Aplica filtros específicos a los accounts
+ */
+const applyFiltersToAccounts = (items, dataTablesParams) => {
+  if (!items || !items.length) return [];
+
+  let filteredItems = [...items];
+
+  if (dataTablesParams.globalSearch) {
+    const searchTerm = dataTablesParams.globalSearch.toLowerCase();
+    filteredItems = filteredItems.filter(item => {
+      return Object.entries(item).some(([key, value]) => {
+        if (typeof value === 'string') {
+          return value.toLowerCase().includes(searchTerm);
+        } else if (typeof value === 'number') {
+          return value.toString().includes(searchTerm);
+        } else if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'string') {
+          return value.some(val => val.toLowerCase().includes(searchTerm));
+        }
+        return false;
+      });
+    });
+  }
+
+  Object.entries(dataTablesParams.columnFilters || {}).forEach(([fieldName, filterValue]) => {
+    if (filterValue) {
+      const searchTerm = filterValue.toLowerCase();
+      filteredItems = filteredItems.filter(item => {
+        const fieldValue = item[fieldName];
+        if (typeof fieldValue === 'string') {
+          return fieldValue.toLowerCase().includes(searchTerm);
+        } else if (typeof fieldValue === 'number') {
+          return fieldValue.toString().includes(searchTerm);
+        }
+        return false;
+      });
+    }
+  });
+
+  if (dataTablesParams._moduleActive) {
+    const module = dataTablesParams._moduleActive;
+    filteredItems = filteredItems.filter(item =>
+      item[module] &&
+      ((typeof item[module] === 'object' && item[module].isActive === true) ||
+        (typeof item[module] === 'boolean' && item[module] === true))
+    );
+  }
+
+  if (dataTablesParams._accountPattern) {
+    const pattern = dataTablesParams._accountPattern.replace(/\*/g, '.*');
+    const regex = new RegExp(`^${pattern}$`, 'i');
+    filteredItems = filteredItems.filter(item => regex.test(item.AccountName));
+  }
+
+  if (dataTablesParams._integration) {
+    const integrationType = dataTablesParams._integration.toLowerCase();
+    filteredItems = filteredItems.filter(item => {
+      switch (integrationType) {
+        case 'sftp':
+          return item.SftpUsed === true ||
+            (item.SftpIntegration && item.SftpIntegration.isActive === true);
+        case 'api':
+          return item.Credentials && item.Credentials.key && item.Credentials.token;
+        case 'webhook':
+          return item.HookOrderVtexMDv2 && item.HookOrderVtexMDv2.trim() !== '';
+        default:
+          return false;
+      }
+    });
+  }
+
+  return filteredItems;
+};
+
+/**
+ * Aplica ordenamiento a los accounts
+ */
+const applySortingToAccounts = (items, orderField, orderDir) => {
+  if (!items || !items.length) return items;
+
+  return items.sort((a, b) => {
+    let valueA = a[orderField];
+    let valueB = b[orderField];
+
+    if (valueA == null) valueA = '';
+    if (valueB == null) valueB = '';
+
+    valueA = valueA.toString().toLowerCase();
+    valueB = valueB.toString().toLowerCase();
+
+    if (orderDir === 'desc') {
+      return valueB.localeCompare(valueA);
+    } else {
+      return valueA.localeCompare(valueB);
+    }
+  });
+};
+
+/**
+ * Función para búsqueda por múltiples AccountNames
+ */
+const getAccountsByMultipleNames = async (accountNames, queryParams = {}) => {
+  try {
+    const dynamodb = new DynamoAWS.DocumentClient();
+    let allItems = [];
+
+    if (accountNames.length <= 100) {
+      const params = {
+        TableName: ACCOUNT_DATA_CONFIG_TABLE,
+        FilterExpression: "AccountName IN (" + accountNames.map((_, i) => `:an${i}`).join(', ') + ")",
+        ExpressionAttributeValues: {}
+      };
+
+      accountNames.forEach((accountName, i) => {
+        params.ExpressionAttributeValues[`:an${i}`] = accountName;
+      });
+
+      let lastEvaluatedKey = null;
+      do {
+        if (lastEvaluatedKey) {
+          params.ExclusiveStartKey = lastEvaluatedKey;
+        }
+
+        const response = await dynamodb.scan(params).promise();
+        allItems = [...allItems, ...(response.Items || [])];
+        lastEvaluatedKey = response.LastEvaluatedKey;
+
+      } while (lastEvaluatedKey);
+    } else {
+      const chunks = chunkArray(accountNames, 100);
+
+      for (const chunk of chunks) {
+        const chunkResult = await getAccountsByMultipleNames(chunk, queryParams);
+        allItems = [...allItems, ...(chunkResult.items || [])];
+      }
+    }
+
+    const filteredItems = applyFiltersToAccounts(allItems, queryParams);
+    const sortedItems = applySortingToAccounts(filteredItems, queryParams.orderField || "AccountName", queryParams.orderDir || "asc");
+
+    return {
+      items: sortedItems,
+      count: sortedItems.length,
+      lastEvaluatedKey: null
+    };
+
+  } catch (err) {
+    Logger.error("Error getting accounts by multiple names: ", err);
+    return { items: [], lastEvaluatedKey: null, count: 0 };
+  }
+};
+
+/**
+ * Función auxiliar para dividir array en chunks
+ */
+const chunkArray = (array, size) => {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+};
+
+/**
+ * Función principal que maneja DataTables y Legacy - CON VALIDACIONES
+ */
+const getAccountsForDataTables = async (queryParams = {}) => {
+  try {
+    if (!queryParams || typeof queryParams !== 'object') {
+      Logger.error("Invalid queryParams:", queryParams);
+      throw new Error("Invalid query parameters");
+    }
+
+    if (queryParams.accountNamesFilter && queryParams.accountNamesFilter.length > 0) {
+      Logger.debug("Searching by multiple AccountNames:", queryParams.accountNamesFilter);
+      return getAccountsByMultipleNames(queryParams.accountNamesFilter, queryParams);
+    }
+
+    if (queryParams.parentAccountName) {
+      return getAccountsByParentName(queryParams.parentAccountName, queryParams);
+    }
+
+    if (queryParams.draw !== undefined) {
+      return getAccountsWithDataTablesPagination(queryParams);
+    }
+
+    return getAccountsByParentName(null, queryParams);
+  } catch (error) {
+    Logger.error("Error in getAccountsForDataTables:", error);
+    return {
+      data: [],
+      items: [],
+      recordsTotal: 0,
+      recordsFiltered: 0,
+      count: 0,
+      draw: queryParams.draw || 1,
+      lastEvaluatedKey: null,
+      error: error.message
+    };
+  }
+};
+
+module.exports = {
+  getAccountDataAll,
+  getAccountsByParentName,
+  getAccountDataByAccountName,
+  getAccountsForDataTables,
+  getAccountsWithDataTablesPagination,
+  getAccountsByMultipleNames,
+  deleteAccountByAccountName,
+  addAccountDataConfig,
+};