dcos-core-monalisav2-latam 1.0.0

package/src/common/utils/vtex/save-schemas.js

@@ -0,0 +1,65 @@
+const VtexApi = require("../../../vtex/clients/VtexApi");
+const Logger = require("../logger");
+
+const handlePutOperation = async (vtexApi, url, data) => {
+  const options = {
+    method: 'PUT',
+    data,
+  };
+  const response = await vtexApi.fetch(url, options);
+  if ((response?.status >= 200 && response?.status < 400) || !response) {
+    return {
+      status: 200,
+      message: "Record created/updated successfully",
+    };
+  }
+  Logger.error("Failed PUT operation", response);
+  throw new Error("Failed PUT operation");
+};
+
+const handleDeleteOperation = async (vtexApi, url) => {
+  const options = {
+    method: 'DELETE',
+  };
+  const response = await vtexApi.fetch(url, options);
+  
+  if ((response?.status >= 200 && response?.status < 400) || !response) {
+    return {
+      status: 200,
+      message: "Record deleted successfully",
+    };
+  }
+  Logger.error("Failed DELETE operation", response);
+  throw new Error("Failed DELETE operation");
+};
+
+const handleSchemaVtexMD2 = async ({ id, entityName, data, origin, httpMethod }) => {
+  if (!id || !origin) {
+    Logger.error("Missing required parameters (id or origin).");
+    throw new Error("Missing required parameters (id or origin).");
+  }
+  const { AccountName, AppKey, AppToken } = origin;
+  if (!AccountName || !AppKey || !AppToken) {
+    Logger.error("Incomplete 'origin' object.");
+    throw new Error("Incomplete 'origin' object.");
+  }
+  const vtexApi = new VtexApi(AccountName, AppKey, AppToken);
+  const url = `/dataentities/${entityName}/schemas/${id}`;
+  try {
+    switch (httpMethod) {
+      case 'PUT':
+        return await handlePutOperation(vtexApi, url, data);
+      case 'DELETE':
+        return await handleDeleteOperation(vtexApi, url);
+      default:
+        return { status: 405, message: `Method ${httpMethod} not allowed to VTEX` };
+    }
+  } catch (error) {
+    Logger.error(`Error during operation ${httpMethod}:`, error.message);
+    throw error;
+  }
+};
+
+module.exports = {
+  handleSchemaVtexMD2,
+};

package/src/common/utils/vtex-hook-handler.js

@@ -0,0 +1,71 @@
+const ApiResponse = require("./api-response");
+const AccountData = require("../../entities/account");
+const VtexApi = require("../../vtex/clients/VtexApi");
+const Logger = require("./logger");
+
+async function handler(event) {
+  try {
+    const accountName = event.pathParameters?.accountName;
+    
+    if (!accountName) {
+      return ApiResponse.response(400, { 
+        success: false, 
+        message: "accountName is required in URL path" 
+      });
+    }
+
+    // Consultar la configuración de la cuenta en DynamoDB
+    const accountConfig = await AccountData.getAccountDataByAccountName(accountName);
+    if (!accountConfig) {
+      return ApiResponse.response(404, { 
+        success: false, 
+        message: `Account ${accountName} not found` 
+      });
+    }
+
+    // Validar que tenga credenciales VTEX
+    if (!accountConfig.Credentials?.key || !accountConfig.Credentials?.token) {
+      return ApiResponse.response(400, { 
+        success: false, 
+        message: "VTEX credentials not configured for this account" 
+      });
+    }
+
+    // Crear instancia de VtexApi
+    const vtexApi = new VtexApi(
+      accountConfig.AccountName,
+      accountConfig.Credentials.key,
+      accountConfig.Credentials.token
+    );
+
+    // Consultar configuración del hook en VTEX
+    const hookConfig = await vtexApi.fetch('/orders/hook/config', {
+      method: 'GET'
+    });
+
+    // Formatear respuesta
+    return ApiResponse.response(200, {
+      success: true,
+      data: {
+        accountName: accountConfig.AccountName,
+        parentAccountName: accountConfig.ParentAccountName,
+        hookConfiguration: hookConfig?.data || null
+      }
+    });
+
+  } catch (error) {
+    Logger.error("Error checking VTEX hook configuration", {
+      error: error.message,
+      stack: error.stack,
+      accountName: event.pathParameters?.accountName
+    });
+
+    return ApiResponse.response(500, {
+      success: false,
+      message: "Error checking VTEX hook configuration",
+      error: error.response?.data?.message || error.message
+    });
+  }
+}
+
+module.exports = { handler };

package/src/common/validation/AccountCoordinatesValidation.js

@@ -0,0 +1,350 @@
+const VtexApi = require("../../vtex/clients/VtexApi");
+const Logger = require("../utils/logger");
+const GeneralRequiredError = require("./GeneralErrorValidation");
+
+/**
+ * Clase para validar coordenadas geográficas de accounts en VTEX
+ */
+class AccountCoordinatesValidation {
+  constructor(accountConfig) {
+    this.accountConfig = accountConfig;
+    this.vtexApi = null;
+
+    Logger.setAccount(accountConfig)
+
+    // Inicializar VtexApi si tenemos las credenciales
+    if (this.accountConfig?.Credentials?.key && this.accountConfig?.Credentials?.token) {
+      this.vtexApi = new VtexApi(
+        this.accountConfig.AccountName,
+        this.accountConfig.Credentials.key,
+        this.accountConfig.Credentials.token
+      );
+    }
+  }
+
+  /**
+   * Valida si las coordenadas geográficas están configuradas correctamente
+   * @returns {Promise<{isValid: boolean, errors: string[], warnings: string[]}>}
+   */
+  async validateCoordinates() {
+    const result = {
+      isValid: true,
+      errors: [],
+      warnings: []
+    };
+
+    try {
+      let shouldValidateDefault = false;
+      let shouldValidateListOptions = false;
+
+      // Determinar qué validaciones necesitamos hacer
+      if (this.accountConfig.SetGeoCoordinatesGlobal === true) {
+        shouldValidateDefault = true;
+      }
+
+      if (this.accountConfig.SetGeoCoordinatesApp === true) {
+        shouldValidateListOptions = true;
+        // Para SetGeoCoordinatesApp también validamos default porque son independientes
+        shouldValidateDefault = true;
+      }
+
+      // Si no hay nada que validar, retornar éxito
+      if (!shouldValidateDefault && !shouldValidateListOptions) {
+        Logger.debug("Both SetGeoCoordinatesGlobal and SetGeoCoordinatesApp are disabled, skipping coordinates validation");
+        return result;
+      }
+
+      // Validar que country esté configurado para cualquier tipo de validación
+      if (!this.accountConfig.CodeCountry || this.accountConfig.CodeCountry.trim() === "") {
+        result.isValid = false;
+        result.errors.push("CodeCountry property is required when SetGeoCoordinatesGlobal or SetGeoCoordinatesApp is enabled");
+        return result;
+      }
+
+      // Validar coordenadas por defecto (requerido para ambos casos)
+      if (shouldValidateDefault) {
+        Logger.debug("Validating default coordinates");
+        const defaultCoordinatesValidation = await this.validateDefaultCoordinates();
+        if (!defaultCoordinatesValidation.isValid) {
+          result.isValid = false;
+          result.errors.push(...defaultCoordinatesValidation.errors);
+        }
+        result.warnings.push(...defaultCoordinatesValidation.warnings);
+      }
+
+      // Validar coordenadas de listOptions si SetGeoCoordinatesApp está habilitado
+      if (shouldValidateListOptions) {
+        Logger.debug("Validating listOptions coordinates (SetGeoCoordinatesApp = true)");
+        const listOptionsValidation = await this.validateListOptionsCoordinates();
+        if (!listOptionsValidation.isValid) {
+          result.isValid = false;
+          result.errors.push(...listOptionsValidation.errors);
+        }
+        result.warnings.push(...listOptionsValidation.warnings);
+      }
+
+    } catch (error) {
+      Logger.error("Error during coordinates validation:", error);
+      result.isValid = false;
+      result.errors.push(`Validation error: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Valida las coordenadas por defecto
+   * @returns {Promise<{isValid: boolean, errors: string[], warnings: string[]}>}
+   */
+  async validateDefaultCoordinates() {
+    const result = {
+      isValid: true,
+      errors: [],
+      warnings: []
+    };
+
+    const defaultCoords = this.accountConfig.ConditionsGeoCoordinates?.default;
+    
+    if (!defaultCoords) {
+      result.errors.push("Default coordinates are not configured in ConditionsGeoCoordinates.default");
+      result.isValid = false;
+      return result;
+    }
+
+    const { latitude, longitude } = defaultCoords;
+
+    // Caso 5: Ignorar validación si las coordenadas están en cero o vacías
+    if (this.isCoordinateZeroOrEmpty(latitude) && this.isCoordinateZeroOrEmpty(longitude)) {
+      result.warnings.push("Default coordinates are set to (0,0) or empty, skipping validation");
+      return result;
+    }
+
+    // Convertir a número si viene como string
+    const lat = typeof latitude === 'string' ? parseFloat(latitude) : latitude;
+    const lng = typeof longitude === 'string' ? parseFloat(longitude) : longitude;
+
+    // Validar que las coordenadas sean números válidos
+    if (!this.isValidCoordinate(lat) || !this.isValidCoordinate(lng)) {
+      result.errors.push("Invalid default coordinates format");
+      result.isValid = false;
+      return result;
+    }
+
+    // Validar coordenadas con VTEX API
+    const vtexValidation = await this.validateCoordinatesWithVtex(
+      lat, 
+      lng, 
+      "default coordinates"
+    );
+    
+    if (!vtexValidation.isValid) {
+      result.isValid = false;
+      result.errors.push(...vtexValidation.errors);
+    }
+    result.warnings.push(...vtexValidation.warnings);
+
+    return result;
+  }
+
+  /**
+   * Valida las coordenadas de listOptions cuando SetGeoCoordinatesApp está habilitado
+   * @returns {Promise<{isValid: boolean, errors: string[], warnings: string[]}>}
+   */
+  async validateListOptionsCoordinates() {
+    const result = {
+      isValid: true,
+      errors: [],
+      warnings: []
+    };
+
+    const listOptions = this.accountConfig.ConditionsGeoCoordinates?.listOptions;
+
+    if (!listOptions || !Array.isArray(listOptions)) {
+      result.warnings.push("No listOptions found for SetGeoCoordinatesApp validation");
+      return result;
+    }
+
+    for (let i = 0; i < listOptions.length; i++) {
+      const option = listOptions[i];
+      const geoCoords = option?.geoCoordinates;
+
+      if (!geoCoords) {
+        result.warnings.push(`listOptions[${i}] missing geoCoordinates`);
+        continue;
+      }
+
+      const { latitude, longitude } = geoCoords;
+
+      // Caso 5: Ignorar si las coordenadas están en cero o vacías
+      if (this.isCoordinateZeroOrEmpty(latitude) && this.isCoordinateZeroOrEmpty(longitude)) {
+        result.warnings.push(`listOptions[${i}] coordinates are set to (0,0) or empty, skipping validation`);
+        continue;
+      }
+
+      // Convertir a número si viene como string
+      const lat = typeof latitude === 'string' ? parseFloat(latitude) : latitude;
+      const lng = typeof longitude === 'string' ? parseFloat(longitude) : longitude;
+
+      // Validar formato de coordenadas
+      if (!this.isValidCoordinate(lat) || !this.isValidCoordinate(lng)) {
+        result.errors.push(`Invalid coordinates format in listOptions[${i}]`);
+        result.isValid = false;
+        continue;
+      }
+
+      // Validar con VTEX API
+      const vtexValidation = await this.validateCoordinatesWithVtex(
+        lat, 
+        lng, 
+        `listOptions[${i}]`
+      );
+
+      if (!vtexValidation.isValid) {
+        result.isValid = false;
+        result.errors.push(...vtexValidation.errors.map(error => 
+          `listOptions[${i}]: ${error}`
+        ));
+      }
+      result.warnings.push(...vtexValidation.warnings.map(warning => 
+        `listOptions[${i}]: ${warning}`
+      ));
+    }
+
+    return result;
+  }
+
+  /**
+   * Valida coordenadas usando la API de regiones de VTEX
+   * @param {number} latitude - Latitud
+   * @param {number} longitude - Longitud
+   * @param {string} context - Contexto para logging
+   * @returns {Promise<{isValid: boolean, errors: string[], warnings: string[]}>}
+   */
+  async validateCoordinatesWithVtex(latitude, longitude, context = "") {
+    const result = {
+      isValid: true,
+      errors: [],
+      warnings: []
+    };
+
+    if (!this.vtexApi) {
+      result.errors.push("VTEX API credentials not available for coordinates validation");
+      result.isValid = false;
+      return result;
+    }
+
+    try {
+      const country = this.accountConfig.CodeCountry;
+      const geoCoordinates = `${longitude}%3B${latitude}`; // URL encoded format: lng%3Blat
+      const salesChannel = this.accountConfig.SalesChannel || "1";
+
+      Logger.debug(`Validating coordinates ${context}:`, {
+        country,
+        geoCoordinates,
+        salesChannel,
+        accountName: this.accountConfig.AccountName
+      });
+
+      // Llamada a la API de regiones de VTEX usando formato público
+      const response = await this.vtexApi.fetch(
+        `/checkout/pub/regions?country=${country}&geoCoordinates=${geoCoordinates}&sc=${salesChannel}`,
+        {
+          method: "GET"
+        },
+        false // printLog = false para evitar logs de error innecesarios
+      );
+
+      if (!response || response.status !== 200) {
+        result.errors.push(`VTEX regions API returned status ${response?.status || 'unknown'} for ${context}`);
+        result.isValid = false;
+        return result;
+      }
+
+      const regions = response.data;
+
+      // Verificar que la respuesta contenga información de sellers
+      if (!regions || !Array.isArray(regions) || regions.length === 0) {
+        result.errors.push(`No regions found for coordinates ${context} (${latitude}, ${longitude})`);
+        result.isValid = false;
+        return result;
+      }
+
+      // Buscar si alguna región contiene el AccountName como seller
+      let sellerFound = false;
+      let availableSellers = [];
+
+      for (const region of regions) {
+        if (region.sellers && Array.isArray(region.sellers)) {
+          const sellers = region.sellers || [];
+          availableSellers.push(...sellers.map(seller => seller.id));
+          const matchingSeller = sellers.find(seller => {
+            return seller.id && seller.id === this.accountConfig.AccountName;
+          });
+          
+          if (matchingSeller) {
+            sellerFound = true;
+            break;
+          }
+        }
+      }
+
+      if (!sellerFound) {
+        const uniqueSellers = [...new Set(availableSellers)];
+        result.errors.push(
+          `Account '${this.accountConfig.AccountName}' not found as seller for ${context} (${latitude}, ${longitude}). ` +
+          `Available sellers: ${uniqueSellers.length > 0 ? uniqueSellers.join(', ') : 'none'}`
+        );
+        result.isValid = false;
+      } else {
+        Logger.debug(`✓ Coordinates ${context} validated successfully for account ${this.accountConfig.AccountName}`);
+      }
+
+    } catch (error) {
+      Logger.error(`Error validating coordinates ${context} with VTEX:`, error);
+      result.errors.push(`Error validating ${context}: ${error.message}`);
+      result.isValid = false;
+    }
+
+    return result;
+  }
+
+  /**
+   * Verifica si un valor es una coordenada válida
+   * @param {any} coordinate - Valor a validar
+   * @returns {boolean}
+   */
+  isValidCoordinate(coordinate) {
+    return (
+      typeof coordinate === 'number' &&
+      !isNaN(coordinate) &&
+      isFinite(coordinate)
+    );
+  }
+
+  /**
+   * Verifica si una coordenada es cero o está vacía (Caso 5)
+   * @param {any} coordinate - Valor a validar
+   * @returns {boolean}
+   */
+  isCoordinateZeroOrEmpty(coordinate) {
+    return (
+      coordinate === 0 ||           // número 0
+      coordinate === "0" ||         // string "0"
+      coordinate === "" ||          // string vacío
+      coordinate === null ||        // null
+      coordinate === undefined      // undefined
+    );
+  }
+
+  /**
+   * Método estático para validar coordenadas de un account
+   * @param {Object} accountConfig - Configuración del account
+   * @returns {Promise<{isValid: boolean, errors: string[], warnings: string[]}>}
+   */
+  static async validate(accountConfig) {
+    const validator = new AccountCoordinatesValidation(accountConfig);
+    return await validator.validateCoordinates();
+  }
+}
+
+module.exports = AccountCoordinatesValidation;

package/src/common/validation/GeneralErrorValidation.js

@@ -0,0 +1,11 @@
+const MainErrorValidation = require("./MainErrorValidation");
+
+class GeneralErrorValidation extends MainErrorValidation {
+    constructor(property) {
+      super(`${property}`);
+      this.name = "GeneralErrorValidation";
+      this.property = property;
+    }
+}
+
+module.exports = GeneralErrorValidation;

package/src/common/validation/MainErrorValidation.js

@@ -0,0 +1,8 @@
+class MainErrorValidation extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "MainErrorValidation";
+    }
+  }
+
+module.exports = MainErrorValidation;