dcos-core-monalisav2-latam 1.0.0

package/src/functions/actions/save-promotions-order-history.js

@@ -0,0 +1,324 @@
+const VtexApi = require('../../vtex/clients/VtexApi');
+// LOGGER
+const Logger = require("../../common/utils/logger");
+const Convert = require("../../common/MondelezCastOrder");
+
+const ERROR_MESSAGES = {
+  NO_RECORDS: 'No records found in event',
+  INVALID_JSON: 'Invalid JSON in record body',
+  MISSING_ACCOUNT_CONFIG: 'Missing AccountConfig or credentials',
+  MISSING_ORDER_ID: 'Missing orderInfo.OrderId',
+  VTEX_FETCH_ERROR: 'Error fetching order from VTEX',
+}
+
+
+// TODO: FIELDS si no existen fields NO debe guardar en master data
+
+module.exports.handler = async (event) => {
+  try {
+    const { isValid, error, records } = validateEvent(event);
+    if(!isValid && error !== null){
+      Logger.error('Event validation failed:', error);
+      return { statusCode: 400, body: JSON.stringify({ message: error }) };
+    }
+
+    const result = await validateRecords(records)
+    if (result.errors > 0) {
+      Logger.error(`Processing completed with ${result.errors} errors.`);
+      return { statusCode: 500, body: JSON.stringify({ message: `Processing completed with ${result.errors} errors.` }) };
+    }
+  
+    return { statusCode: 200, body: JSON.stringify({ message: 'Processing completed successfully.' }) };
+  } catch (error) {
+    Logger.error('Error processing records:', error);
+    return { statusCode: 500, body: JSON.stringify({ message: error.message }) };
+  }
+};  
+
+const validateEvent = (event) => {
+  if(!event || !Array.isArray(event.Records) || event.Records.length === 0){
+    return { isValid: false, error: ERROR_MESSAGES.NO_RECORDS, records:[] };
+  }
+  return { isValid: true, error: null, records: event.Records };
+};
+
+const validateRecords = async (records) => {
+  let errors = 0;
+  for (const record of records) {
+    try {
+      await processingRecords(record);
+    } catch (error) {
+      Logger.error('Error processing record', record, error);
+      errors++;
+    }
+  }
+  return { errors };
+};
+
+const processingRecords = async (record) => {
+  Logger.debug(`Processing record: ${record.body}`);
+
+  const data = JSON.parse(record.body);
+  Logger.setAccount(data?.accountConfig);
+
+  if (!data){
+    Logger.error('Invalid JSON in record body:', record.body);
+    throw new Error(ERROR_MESSAGES.INVALID_JSON);
+  }
+
+  const accountConfig = await validateAccountConfig(data.accountConfig);
+  if (!accountConfig) {
+    Logger.error('Invalid account configuration');
+    return null;
+  }
+
+  const orderInfoVtex = await fetchOrderFromVtex(data?.orderInfo, data);
+  
+  if (!orderInfoVtex) {
+    Logger.error(`Failed to fetch order from VTEX for OrderId: ${data?.orderInfo?.OrderId}`);
+    return null;
+  }
+
+  const idsPromotions = await getIdsPromotionsOrder(orderInfoVtex);
+  const detailsPromotions = await fetchDetailPromotionProductOrder(data.accountConfigParent, idsPromotions);
+  Logger.debug(JSON.stringify(detailsPromotions, null, 2));
+
+  let mappedPromotions = [];
+  if (detailsPromotions.length > 0){
+    const fields = data.accountConfig?.AdditionalFieldsPromotionsInOrder?.fields;
+    mappedPromotions = await validatePromotionsConfiguration(fields, detailsPromotions);
+  }
+
+  const saveOrderVtex = await saveOrderPromotionsHistoryMD2(data, orderInfoVtex, mappedPromotions);
+  if (!saveOrderVtex) {
+    Logger.debug('Failed to save order promotions history');
+    return null;
+  }
+  
+  return true;
+};
+
+const validateAccountConfig = (accountConfig) => {
+  if (!accountConfig || !accountConfig.AccountName || !accountConfig.Credentials) {
+    Logger.error(ERROR_MESSAGES.MISSING_ACCOUNT_CONFIG);
+    return null;
+  }
+  return accountConfig;
+};
+
+const fetchOrderFromVtex = async (orderInfo, data) => {
+  const orderId = orderInfo?.OrderId;
+
+  if (!orderId) {
+    Logger.error(ERROR_MESSAGES.MISSING_ORDER_ID);
+    return null;
+  }
+
+  const vtexApi = await initVtexApi(data.accountConfig);
+  const vtexParent = await initVtexApi(data.accountConfigParent);
+
+  try {
+
+    Logger.debug("FETCH seller order:", {
+      url: `${vtexApi.baseURL}/oms/pvt/orders/${orderId}`,
+      method: "GET",
+      account: data.accountConfig?.AccountName
+    });
+
+    let response = await vtexApi.fetch(`/oms/pvt/orders/${orderId}`, { method: "GET" });
+    
+    const parentOrderId = response?.data?.marketplaceOrderId;
+    if (!parentOrderId) {
+      Logger.error(`No marketplace order ID found for seller order ${orderId}`);
+      return null;
+    }
+
+    Logger.debug("FETCH parent order:", {
+      url: `${vtexParent.baseURL}/oms/pvt/orders/${parentOrderId}`,
+      method: "GET",
+      account: data.accountConfigParent?.AccountName,
+      parentOrderId: parentOrderId
+    });
+
+    let responseParent = await vtexParent.fetch(`/oms/pvt/orders/${parentOrderId}`, {
+      method: "GET",
+    });
+
+    Logger.debug("VTEX Order Response:", responseParent?.data); 
+    const convertedOrder = Convert.orderToJson(response.data, responseParent.data, data.accountConfig);
+    return convertedOrder;
+
+  } catch (error) {
+    Logger.error(ERROR_MESSAGES.VTEX_FETCH_ERROR, error);
+    return null;
+  }
+};
+
+const getIdsPromotionsOrder = async (orderInfoVtex) => {
+  Logger.debug("Order ratesAndBenefitsData:", orderInfoVtex?.ratesAndBenefitsData);
+  
+  const promotions = orderInfoVtex?.ratesAndBenefitsData?.rateAndBenefitsIdentifiers;
+  
+  if (!promotions || promotions.length === 0) {
+    Logger.debug("No promotions found in order");
+    return [];
+  }
+  
+  const idsPromotions = [];
+  for (const promo of promotions){
+    idsPromotions.push(promo.id);
+  }
+  
+  Logger.debug(`Found ${idsPromotions.length} promotion IDs:`, idsPromotions);
+  return idsPromotions;
+}
+
+const fetchDetailPromotionProductOrder = async (accountConfig, idsPromotions) => {
+  Logger.debug("Fetching promotion details for IDs:", idsPromotions);
+  
+  if (!idsPromotions || idsPromotions.length === 0) {
+    Logger.debug("No promotion IDs to fetch");
+    return [];
+  }
+
+  const vtexApi = await initVtexApi(accountConfig);
+  
+  try {
+    const promotionPromises = idsPromotions.map(async (id) => {
+      try {
+        const response = await vtexApi.fetch(`/rnb/pvt/calculatorconfiguration/${id}`, { method: "GET" });
+        
+        if (response && response.status === 200 && response.data) {
+          return response.data;
+        }
+
+      } catch (error) {
+        Logger.error(`Error fetching promotion ${id}:`, error.message);
+        return null;
+      }
+    });
+
+    const results = await Promise.all(promotionPromises);    
+    const validResults = results.filter(result => result !== null);
+    return validResults;
+    
+  } catch (error) {
+    Logger.error('Error fetching promotion details from VTEX:', error);
+    return [];
+  }
+}
+
+const validatePromotionsConfiguration = async (fields, detailsPromotions) => {
+  if (!fields || !detailsPromotions || detailsPromotions.length === 0) {
+    Logger.debug('Fields or detailsPromotions are empty');
+    return [];
+  }
+
+  const mappedPromotions = [];
+
+  for (let i = 0; i < detailsPromotions.length; i++) {
+    const detail = detailsPromotions[i];
+    const mappedPromotion = {};
+
+    for (const [fieldName, fieldConfig] of Object.entries(fields)) {
+      
+      // Caso 1: Configuración simple (mapeo directo de valores)
+      if (fieldConfig && typeof fieldConfig === 'object' && !fieldConfig.alias && !fieldConfig.values) {
+        const fieldValue = detail[fieldName];
+        
+        if (fieldValue && fieldConfig[fieldValue]) {
+          mappedPromotion[fieldName] = fieldConfig[fieldValue];
+        } else {
+          mappedPromotion[fieldName] = fieldValue;
+        }
+      }
+      // Caso 2: Configuración compleja (con alias y values)
+      else if (fieldConfig && typeof fieldConfig === 'object' && fieldConfig.alias) {
+        const { alias, values } = fieldConfig;
+        const fieldValue = detail[fieldName];
+        
+        if (fieldValue && values && values[fieldValue]) {
+          mappedPromotion[alias] = values[fieldValue];
+        } else if (fieldValue) {
+          mappedPromotion[alias] = fieldValue;
+        } else {
+          mappedPromotion[alias] = null;
+        }
+      }
+      // Caso 3: Configuración simple (campo directo)
+      else {
+        if (detail.hasOwnProperty(fieldName)) {
+          mappedPromotion[fieldName] = detail[fieldName];
+        } else {
+          mappedPromotion[fieldName] = null;
+        }
+      }
+    }
+
+    mappedPromotion.promotionId = detail?.idCalculatorConfiguration || detail?.id || null
+    mappedPromotions.push(mappedPromotion);
+  }
+  return mappedPromotions;
+}
+
+
+const saveOrderPromotionsHistoryMD2 = async (data, orderInfoVtex, mappedPromotions) => {
+
+  if (!data || !orderInfoVtex) {
+    Logger.debug("Data or orderInfo is missing");
+    return false;
+  }
+
+  const accountConfig = data.accountConfig;
+  const acronymEntity = accountConfig?.AdditionalFieldsPromotionsInOrder?.acronymEntity;
+
+  const transformedPromotions = (mappedPromotions || []).map(promotion => {
+    const { promotionId, ...fields } = promotion;
+    return {
+      id: promotionId,
+      fields: fields
+    };
+  });
+
+  const payload = {
+    id: orderInfoVtex?.id,
+    detailPromotions: transformedPromotions
+  };
+
+  const vtexApi = await initVtexApi(accountConfig);
+
+  try {
+
+    const result = await vtexApi.fetch(`/dataentities/${acronymEntity}/documents`, {
+      method: "PATCH",
+      data: payload
+    }, false);
+    
+    if (!result) {
+      Logger.info("Order promotions history - data already exists with same content (status 304)");
+      return true;
+    }
+    
+    if ((result.status >= 200 && result.status < 300) || result.status === 304) {
+      Logger.info("Order promotions history saved successfully");
+      return true;
+    } else if (result.status >= 400) {
+      Logger.error("Failed to save order promotions history:", result);
+      return false;
+    }
+    
+    return true;
+  } catch (error) {
+    Logger.error("Error saving order promotions history:", error);
+    Logger.error("ERROR DETAILS:", error.response?.data || error.message);
+    return false;
+  }
+};
+
+const initVtexApi = async (accountConfig) => {
+  return new VtexApi(
+    accountConfig?.AccountName,
+    accountConfig?.Credentials?.key,
+    accountConfig?.Credentials?.token
+  );
+};

package/src/functions/affiliates/affiliates-hook-consumer.js

@@ -0,0 +1,87 @@
+const VtexApi = require("../../vtex/clients/VtexApi");
+const AccountData = require("../../entities/account");
+const SkuData = require("../../entities/sku");
+const AWSServices = require("../../common/utils/aws-services");
+const Logger = require("../../common/utils/logger");
+
+const SQS_AFFILIATE_HOOK_QUEUE_URL = process.env.SQS_AFFILIATE_HOOK_QUEUE_URL;
+const SQS_AFFILIATE_HOOK_DQL_QUEUE_URL = process.env.SQS_AFFILIATE_HOOK_DQL_QUEUE_URL;
+const MAX_ATTEMPS = process.env.MAX_ATTEMPS || 5;
+
+/**
+ *
+ * @param {import("aws-lambda").SQSEvent} event
+ * @returns
+ */
+const consumer = async (event) => {
+  let attemps = 0;
+  for (const record of event.Records) {
+    try {
+      const request = JSON.parse(record.body);
+      attemps = request.attemps || 0;
+      const skuId = request.IdSku;
+      const accountName = request.An;
+      if (!skuId || !accountName) {
+        throw new Error("Invalid SKU or Account Name");
+      }
+      const data = await AccountData.getAccountDataByAccountName(accountName);
+      Logger.setAccount(data);
+      Logger.debug("Message Body: ", record.body, ". Type: ", typeof record.body);
+      Logger.debug("Data: ", data);
+      if (!data) {
+        Logger.debug("Data INVALID: ", data);
+        throw new Error("Account not found");
+      }
+      const apiClient = new VtexApi(data?.AccountName, data?.Credentials?.key, data?.Credentials?.token);
+      Logger.debug("VTEX API Client: ", apiClient);
+      const response = await apiClient.fetch(`/catalog_system/pvt/sku/stockkeepingunitbyid/${skuId}`, {
+        method: "GET",
+      });
+      if (response?.status < 200 || response?.status > 299) {
+        throw new Error("Error getting SKU in VTEX");
+      }
+      Logger.debug("Response: ", response.data);
+      const skuIdentifier = response.data?.AlternateIds?.RefId || response.data?.AlternateIds?.Ean;
+      const sku = {
+        AccountNameAndSku: `${accountName}${skuIdentifier}`,
+        ParentAccountName: accountName,
+        Sku: skuIdentifier,
+        Ean: response.data?.AlternateIds?.Ean,
+        SkuId: parseInt(skuId),
+        Name: response.data?.NameComplete,
+        Type: "SKU",
+      };
+      const saved = await SkuData.addSku(sku);
+      Logger.debug("Sku added: ", saved);
+    } catch (error) {
+      Logger.error(error);
+      if (
+        attemps < MAX_ATTEMPS &&
+        error?.message !== "Account not found" &&
+        error?.message !== "Invalid SKU or Account Name"
+      ) {
+        try {
+          await AWSServices.sendSQSMessage(SQS_AFFILIATE_HOOK_QUEUE_URL, JSON.parse(record.body));
+        } catch (error) {
+          Logger.error("Sending message to Queue: ", error);
+        }
+      } else {
+        try {
+          await AWSServices.sendSQSMessage(
+            SQS_AFFILIATE_HOOK_DQL_QUEUE_URL,
+            JSON.stringify({
+              body: record.body,
+              error: error?.message,
+            })
+          );
+        } catch (error) {
+          Logger.error("Sending message to DQL Queue: ", error);
+        }
+      }
+    }
+  }
+};
+
+module.exports = {
+  consumer,
+};

package/src/functions/affiliates/affiliates-hook-producer.js

@@ -0,0 +1,45 @@
+const AWSServices = require("../../common/utils/aws-services");
+const ApiResponse = require("../../common/utils/api-response");
+const AFFILIATE_HOOK_QUEUE_URL = process.env.AFFILIATE_HOOK_QUEUE_URL;
+const Logger = require("../../common/utils/logger");
+
+/**
+ *
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns
+ */
+const producer = async (event) => {
+  let statusCode = 200;
+  let message;
+  if (!event.body) {
+    return ApiResponse.response(400, "No body was found");
+  }
+  try {
+    Logger.debug("Event: ", event.body, typeof event.body);
+    const request = JSON.parse(event.body);
+    const skuModified = request?.HasStockKeepingUnitModified || request?.hasStockKeepingUnitModified || request?.StockModified || request?.PriceModified || 0;
+    if (skuModified && skuModified != 0) {
+      await AWSServices.sendSQSMessage(AFFILIATE_HOOK_QUEUE_URL, JSON.parse(event.body));
+    } else {
+      Logger.error(
+        `No SKU modified, no message sent to queue...Sku: ${request?.IdSku} and Account: ${request?.An}. Body: ${request}`
+      );
+    }
+    message = "Message accepted!";
+  } catch (error) {
+    Logger.error(error);
+    message = error;
+    statusCode = 500;
+  }
+
+  return {
+    statusCode,
+    body: JSON.stringify({
+      message,
+    }),
+  };
+};
+
+module.exports = {
+  producer,
+};

package/src/functions/clients/clients-audience.js

@@ -0,0 +1,62 @@
+const AccountData = require("../../entities/account");
+const ApiResponse = require("../../common/utils/api-response");
+const ClientData = require("../../entities/clients");
+const AudiencePrice = require("../../integrations/audience/Audience");
+const Logger = require("../../common/utils/logger");
+
+/**
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns {Promise<ApiResponse>}
+ */
+const handler = async (event) => {
+    const { client_id: clientId } = event.requestContext.authorizer.claims || {};
+    const email = event?.queryStringParameters?.email ? decodeURIComponent(event.queryStringParameters.email.trim().replace(/\s/g, "+")) : null;
+    const accountNameURL = event?.queryStringParameters?.an ? event?.queryStringParameters?.an : null;
+    const accountName = accountNameURL || null;
+
+    if (!accountName) {
+        return ApiResponse.response(400, { approved: false, message: "AccountName is Required" });
+    }
+
+    let configAccount = await AccountData.getAccountDataByAccountName(accountName);
+    if (!configAccount) {
+        Logger.error("Account not found");
+        return ApiResponse.response(400, { approved: false, message: "Account not found" });
+    }
+
+    if (!configAccount.SavePriceAudience) {
+        return ApiResponse.response(400, { approved: false, message: "You do not have permission to access this resource" });
+    }
+
+    if (!email) {
+        return ApiResponse.response(400, { approved: false, message: "Email is Required" });
+    }
+
+    const audiencePrice = new AudiencePrice(configAccount.AccountName, configAccount?.Credentials?.key, configAccount?.Credentials?.token);
+
+    try {
+        const audienceResponse = await audiencePrice.createAudiencePrice(email);
+
+        if (!audienceResponse) {
+            return ApiResponse.response(400, { approved: false, message: "Error creating audience" });
+        }
+
+        const priceList = await audiencePrice.getAudiencePriceById(audienceResponse);
+
+        if (!priceList || priceList?.length === 0) {
+            return ApiResponse.response(404, { approved: false, message: "Audience price mapping not found. Verify if the ID is correct or exists." });
+        }
+
+        return ApiResponse.response(200, { approved: true, priceList });
+    } catch (error) {
+        if (error.response?.status === 404) {
+            return ApiResponse.response(404, { approved: false, message: "Resource not found on VTEX. Please verify the endpoint or ID." });
+        }
+        Logger.error("Unexpected error:", error);
+        return ApiResponse.response(500, { approved: false, message: "Internal server error." });
+    }
+};
+
+module.exports = {
+    handler,
+};