dcos-core-monalisav2-latam 1.0.0

package/src/functions/prices/prices-consumer.js

@@ -0,0 +1,236 @@
+const VtexApi = require("../../vtex/clients/VtexApi")
+const AWSServices = require("../../common/utils/aws-services")
+const SkuData = require("../../entities/sku")
+const { roundPrice } = require("../../common/utils/util");
+const SQS_PRICES_DQL_QUEUE_URL = process.env.SQS_INVENTORY_DQL_QUEUE_URL
+const SQS_PRICES_QUEUE_URL = process.env.SQS_INVENTORY_QUEUE_URL
+const MAX_ATTEMPS = process.env.MAX_ATTEMPS || 3
+const CotrolPrice = require("../../entities/controlprice")
+const Logger = require("../../common/utils/logger");
+
+const consumer = async (event) => {
+  for (const record of event.Records) {
+    Logger.debug("Message Body: ", record.body, ". Type: ", typeof record.body)
+
+    let { an, key, token, hoursValidStockPrice, ValidateSkuPriceInventoryInProcess, ParentAccountName, SkuRefUsed, RoundUpDecimalPrice } = JSON.parse(record.body)
+    let { data } = JSON.parse(record.body)
+
+    // obtener sku vtex
+    let skuInprocess= null
+
+    if (ValidateSkuPriceInventoryInProcess === true) {
+      try{
+        skuInprocess= await SkuData.getSkuVtex({ account: ParentAccountName, sku: data?.sku, SkuRefUsed })
+
+      } catch(error) {
+        Logger.error('Error get sku vtex.', error)
+
+        try{
+          await SkuData.saveLogProductsNotFount({ an, key, token, entity: "logpricesnotfound", sku: data?.sku, value: JSON.stringify(data) })
+        }catch(e){
+          Logger.error('error save log price')
+        }
+        return false
+      }
+    }
+
+    try {
+      const vtexApi = new VtexApi(an, key, token)
+      const skuId = skuInprocess ? skuInprocess : data?.sku
+      let priceM = 0
+      
+      delete data.sku
+
+      // Encontrar precio máximo redondeado
+      for (let i = 0; i < data.fixedPrices.length; i++) {
+        if(priceM < data.fixedPrices[i]?.value) {
+          priceM = data.fixedPrices[i]?.value ?? 0
+        }
+      }
+
+      if((!data?.basePrice && priceM > 0) || (data?.basePrice === 0  && priceM > 0)){
+        data.basePrice = priceM;
+        if(data?.costPrice) {
+          data.costPrice = priceM;
+        }
+      }
+
+      // Validacion valores ya informados
+      const validPriceInternal= await CotrolPrice?.validNotificationPriceVtex({
+        skuId: skuId,
+        account: an,
+        hoursUpdate: hoursValidStockPrice ?? 24,
+        data:data
+      })
+
+      if(validPriceInternal === false){
+        return false;
+      }
+      // fin validacion valores informados
+      
+      let response= { status: 200 }
+
+      const isGeneralPricing = data?.sc || data?.priceTableId ? false : true;
+
+      response = isGeneralPricing
+        ? await setPricesGeneral(data, vtexApi, skuId, RoundUpDecimalPrice)
+        : await setPricesPerTableId(data, vtexApi, skuId, RoundUpDecimalPrice);
+
+      if (response.status >= 200 && response.status < 300) {
+        // Fin  Proceso de impuestos
+      } else {
+        const attemps = JSON.parse(record.body)?.attemps || 0;
+        Logger.error( "Error updating prices. Status: ", response.status,". Message: ", response?.data?.message, " - Try: ", attemps)
+
+        if (attemps < MAX_ATTEMPS) {
+          await AWSServices.sendSQSMessage(SQS_PRICES_QUEUE_URL,
+            JSON.stringify({
+              an,
+              authKey,
+              token,
+              data,
+              attemps: attemps + 1,
+            })
+          )
+        } else {
+          throw new Error("Max attemps reached.");
+        }
+      }
+    } catch (error) {
+      Logger.error(error)
+
+      try {
+        await AWSServices.sendSQSMessage(
+          SQS_PRICES_DQL_QUEUE_URL,
+          JSON.stringify({
+            body: record.body,
+            error: error?.message,
+          })
+        )
+      } catch (error) {
+        Logger.error("Sending message to DQL Queue: ", error)
+      }
+    }
+  }
+}
+
+const setPricesGeneral = async (data, vtexApi, skuId, RoundUpDecimalPrice) => {
+  let response = { status: 200 }
+
+    // rounded prices
+    applyRoundUpDecimalPrice(data, RoundUpDecimalPrice);
+
+  if (data?.basePrice > 0) {
+    let fixedPricesSave = []
+    
+    for (let x = 0; x < data?.fixedPrices?.length; x++) {
+      if (data?.fixedPrices[x]?.value > 0) {
+        fixedPricesSave = [...fixedPricesSave, data?.fixedPrices[x]]
+      }
+    }
+
+    try {
+      response = await vtexApi.fetchApiURL(`/pricing/prices/${skuId}/`, {
+        method: "PUT",
+        data: {
+          basePrice: data.basePrice,
+          costPrice: data.costPrice ?? data.basePrice,
+          fixedPrices: fixedPricesSave,
+        },
+      })
+      return response
+    } catch (error) {
+      Logger.error('response update price', error)
+    }
+    
+
+  } else {
+
+    try{
+      const response = await vtexApi.fetchApiURL(`/pricing/prices/${skuId}/`, {
+        method: "DELETE"
+      })
+      return response
+
+    } catch (error) {
+      Logger.error('response Delete price error', error)
+    }
+  }
+  return response
+}
+
+const setPricesPerTableId = async (data, vtexApi, skuId, RoundUpDecimalPrice) => {
+  let response = { status: 200 }
+
+  // rounded prices
+  applyRoundUpDecimalPrice(data, RoundUpDecimalPrice);
+
+  if (!data?.sc && !data?.priceTableId) {
+    Logger.error('No exists sc or priceTableId properties')
+    return { status: 404, data: { message: 'No exists sc or priceTableId propertie' } }
+  }
+
+  let priceTableId = ''
+  if (data?.sc){
+    priceTableId = data?.sc
+  }else{
+    priceTableId = data?.priceTableId
+  }
+
+  if (data?.basePrice > 0) {
+    try {
+      response = await vtexApi.fetchApiURL(`/pricing/prices/${skuId}/fixed/${priceTableId}`, {
+        method: "POST",
+        data: [{
+          value: data?.basePrice,
+          listPrice: data?.listPrice ?? data?.basePrice,
+          minQuantity: 1,
+        }],
+      })
+      return response
+    } catch (error) {
+      Logger.error('response error update price by table id', error)
+    }
+    
+
+  } else {
+
+    try {
+      response = await vtexApi.fetchApiURL(`/pricing/prices/${skuId}/fixed/${priceTableId}`, {
+        method: "delete",
+      })
+      return response
+    } catch (error) {
+      Logger.error('response error update price by table id', error)
+    }
+
+  }
+  return response
+}
+
+const applyRoundUpDecimalPrice = (data, RoundUpDecimalPrice) => {
+  if (RoundUpDecimalPrice && RoundUpDecimalPrice?.isActive) {
+    if (data?.basePrice) {
+      data.basePrice = roundPrice(data.basePrice, RoundUpDecimalPrice);
+    }
+    if (data?.listPrice) {
+      data.listPrice = roundPrice(data.listPrice, RoundUpDecimalPrice);
+    }
+    if (data?.costPrice) {
+      data.costPrice = roundPrice(data.costPrice, RoundUpDecimalPrice);
+    }
+    if (data?.fixedPrices) {
+      data.fixedPrices = data.fixedPrices.map((fixedPrice) => {
+        return {
+          ...fixedPrice,
+          value: roundPrice(fixedPrice.value, RoundUpDecimalPrice),
+          listPrice: roundPrice(fixedPrice.listPrice, RoundUpDecimalPrice),
+        };
+      });
+    }
+  }
+}
+
+module.exports = {
+  consumer,
+};

package/src/functions/prices/prices-producer.js

@@ -0,0 +1,323 @@
+const ApiResponse = require("../../common/utils/api-response");
+const AWSServices = require("../../common/utils/aws-services");
+const ClientData = require("../../entities/clients");
+const AccountData = require("../../entities/account");
+const SkuData = require("../../entities/sku");
+const DistributorData = require("../distributors/distributor");
+const Logger = require("../../common/utils/logger");
+const LIMIT_ITEMS_TO_PROCESS = process?.env?.LIMIT_ITEMS_TO_PROCESS || 150;
+const SQS_PRICE_QUEUE_URL = process?.env?.SQS_PRICE_QUEUE_URL;
+const SQS_PROCESSTAX_QUEUE_URL = process?.env?.SQS_PROCESSTAX_QUEUE_URL ?? null;
+
+/**
+ *
+ * @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");
+  }
+
+  const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+  Logger.log(JSON.stringify(JSON.parse(event.body)), clientId);
+
+  try {
+    let request = JSON.parse(event.body);
+    const scope = event?.requestContext?.authorizer?.claims?.scope;
+    const accountName = request?.an;
+    const prices = orderPricesASC(request?.prices);
+    let pricesDiscount = [];
+
+    if (!prices || prices?.length > LIMIT_ITEMS_TO_PROCESS) {
+      return ApiResponse.response(404, "Prices limit of items exceeded");
+    }
+    if (!event?.internalService) {
+      if (!scope?.includes("admin")) {
+        const isValid = await ClientData.validateAccount(clientId, accountName);
+        if (!isValid) {
+          Logger.error("Account not found: ", accountName, ". ClientId: ", clientId);
+          return ApiResponse.response(404, "Account not found");
+        }
+      }
+    }
+
+    // se valida el account para determinar si los precios vienen de un proceso interno, o una ejecucion HTTP
+    const account = event?.accountData && event?.internalService === true 
+      ? event?.accountData 
+      : await AccountData.getAccountDataByAccountName(accountName);
+
+    if (!account) {
+      Logger.error("Account not found: ", accountName, ". ClientId: ", clientId)
+      return ApiResponse.response(404, "Account not found")
+    }
+
+    const count = Object.keys(account?.PriceList).length
+    if (!account || !account?.PriceList || count < 1) {
+      return ApiResponse.response(404, "Warehouse not found")
+    }
+
+    let skuRefUsed = account?.SkuRefUsed
+    if (typeof skuRefUsed !== "boolean") {
+      skuRefUsed = true;
+    }
+
+    let notProcessed = [];
+
+    for (let item of prices) {
+      let copySku = item?.sku
+      let copyItem = item
+
+      try {
+        let notFoundByEan = false
+        let skuData = null
+
+        //Si esta activado el manejo de sku por código de distribuidor 
+        try {
+          const skuDistributorManagement = account?.SkuDistributorManagement || false
+          const refIdVtex = await DistributorData.getDistributorByErpCode(accountName, item?.sku, skuDistributorManagement)
+
+          item.sku = refIdVtex
+          copyItem.sku = refIdVtex
+          pricesDiscount = [...pricesDiscount, copyItem]
+
+        } catch (error) {
+          Logger.error("Error al obtener distribuidor por sku:", error);
+        }
+
+        if (skuRefUsed) {
+          skuData = account?.ValidateSkuPriceInventoryInProcess === true 
+            ? { SkuId: item?.sku } 
+            : await SkuData.getSkuByParentAccountNameAndSku(account?.ParentAccountName, item?.sku);
+
+        } else {
+          skuData = account?.ValidateSkuPriceInventoryInProcess === true 
+            ? [{ SkuId: item?.sku }] 
+            : await SkuData.getSkuByParentAccountNameAndEan(account?.ParentAccountName, item?.sku);
+
+          if (!skuData || skuData.length < 1) {
+            notFoundByEan = true;
+          } else {
+            skuData = skuData?.[0];
+          }
+        }
+
+        if ((!skuData || !skuData?.SkuId) && !notFoundByEan) {
+          item.message = "SKU not found";
+          notProcessed.push(item);
+
+        } else if (notFoundByEan && !skuRefUsed) {
+          item.message = "SKU not found by Ean";
+          notProcessed.push(item);
+
+        } else {
+
+          let fixedPrices = []
+          let namesFixedPrices = []
+          let messageError = ""
+          item.sku = skuData?.SkuId
+
+          // Si viene sc se prioriza sobre pricetableId y sobre fixed Prices
+          if (item?.sc) {
+            delete item.priceTableId // si viene priceTabledId junto con sc se elimina ya que es prioritario sc
+          }else if (item?.priceTableId) {
+            item.priceTableId = `L${item.priceTableId}` // se asigna un prefijo para la actualizacion de precios basado en un priceTableId
+          }
+          
+          for (let fixedPrice of item?.fixedPrices) {
+
+            let priceList = Object.values(account?.PriceList)?.[0];
+            fixedPrice.minQuantity = fixedPrice?.minQuantity || 1;
+
+            if (fixedPrice?.listId && !namesFixedPrices.includes(fixedPrice?.listId)) {
+              namesFixedPrices = [...namesFixedPrices, fixedPrice?.listId];
+              priceList = account?.PriceList?.[fixedPrice?.listId];
+              if (!priceList) {
+                messageError = "Price list" + fixedPrice?.listId + " not found. ";
+
+                fixedPrice.tradePolicyId = `L${fixedPrice?.listId}`;
+                delete fixedPrice.listId;
+                fixedPrices.push(fixedPrice);
+              } else {
+                fixedPrice.tradePolicyId = priceList;
+                delete fixedPrice.listId;
+                fixedPrices.push(fixedPrice);
+              }
+            }
+
+          }
+
+          if (item?.fixedPrices) {
+            item.fixedPrices = fixedPrices;
+            item.sku = skuData?.SkuId;
+
+            if (account?.SetValueListPriceAll === true) {
+              item = setListPriceAll(item)
+            }
+            await sendDataToSQS({ accountName, account, skuRefUsed, item })
+
+          }else {
+            item.sku = copySku;
+            Logger.error("Not all prices were processed. ", item);
+            item.message = messageError;
+            notProcessed.push(item);
+          }
+        }
+      } catch (error) {
+        item.sku = copySku;
+        Logger.error(error);
+        notProcessed.push(item);
+      }
+    }
+    // Inicio  Proceso de impuestos
+    request = { ...request, prices: pricesDiscount };
+    Logger.debug("request.prices", JSON.stringify(request.prices));
+    const listTaxes = getListTaxes(request) ?? [];
+
+    if (listTaxes && Object.keys(listTaxes).length > 0) {
+      const accountParent = await AccountData.getAccountDataByAccountName(account?.ParentAccountName);
+      const resSendTax = await sendSQStax({
+        data: listTaxes,
+        dataAccount: account,
+        dataAccountParent: accountParent
+      });
+    }
+
+    if (notProcessed.length > 0) {
+      const message = {
+        message: "Not all items were processed.",
+        notProcessedItems: notProcessed,
+      };
+      return ApiResponse.response(207, message);
+    }
+
+    message = "Message accepted!";
+
+  } catch (error) {
+    Logger.error(error);
+    message = error;
+    statusCode = 500;
+  }
+  return ApiResponse.response(statusCode, message);
+};
+
+/**
+ * Envio de datos a la cola AWS SQS
+ * @param data -- objeto con la informacion necesaria de precios para enviar a la cola de SQS
+ **/
+const sendDataToSQS = async ({ accountName, account, skuRefUsed, item }) => {
+
+  const dataSend = {
+    an: accountName,
+    hoursValidStockPrice:account?.HoursValidStockPrice ?? 24,
+    ValidateSkuPriceInventoryInProcess:account?.ValidateSkuPriceInventoryInProcess ?? false,
+    ParentAccountName:account?.ParentAccountName,
+    SkuRefUsed: skuRefUsed,
+    RoundUpDecimalPrice:account?.RoundUpDecimalPrice ?? null,
+    key:account?.Credentials?.key,
+    token:account?.Credentials?.token,
+    data:item,
+  };
+  await AWSServices.sendSQSMessage(SQS_PRICE_QUEUE_URL, dataSend);
+}
+
+/**
+ * Asignacion de lista de precios en todas las propiedades del item 
+ * @param item -- objeto item precio
+ **/
+const setListPriceAll = (item) => {
+  for (const it in item) {
+    if (it === 'basePrice') {
+      item[it] = item?.listPrice;
+    }
+    if (it === 'fixedPrices') {
+      for (let i = 0; i < item?.fixedPrices?.length; i++) {
+        item.fixedPrices[i].value = item.fixedPrices[i]?.listPrice;
+      }
+    }
+  }
+
+  return item;
+};
+
+/**
+ * Funcion para ordenar los precios notificados por el ERP 
+ **/
+const orderPricesASC = (prices) => {
+  let listPrices = [];
+
+  if (prices && prices?.length > 0) {
+    listPrices = prices?.sort((a, b) => (parseFloat(a?.basePrice) - parseFloat(b?.basePrice)));
+  }
+
+  return listPrices;
+};
+
+/**
+ * set list taxes request 
+ **/
+const getListTaxes = (resq) => {
+  if (!resq?.an || !resq?.prices || resq?.prices?.length == 0) {
+    return [];
+  }
+
+  let listTaxes = {};
+  for (let i = 0; i < resq.prices.length; i++) {
+    let itemsTaxes = resq?.prices[i]?.taxes ?? [];
+    let skuIt = resq?.prices[i]?.sku ?? null;
+    if (itemsTaxes?.length > 0 && skuIt) {
+      for (let j = 0; j < itemsTaxes.length; j++) {
+        let tax = itemsTaxes[j];
+        if (tax?.value > 0) {
+          let idTax = `${tax?.type}-${String(tax?.name).replace(/ /g, '').toLocaleLowerCase()}-${tax?.value}-tax-${resq.an}-`;
+          if (typeof listTaxes[idTax] !== 'object') {
+            listTaxes[idTax] = {
+              type: null,
+              name: null,
+              value: 0,
+              type: "percentual",
+              skus: [],
+            };
+          }
+          if (!listTaxes[idTax].skus?.includes(skuIt)) {
+            listTaxes[idTax].type = tax?.type ?? "percentual";
+            listTaxes[idTax].name = tax?.name ?? null;
+            listTaxes[idTax].value = tax?.value ?? null;
+            listTaxes[idTax].an = resq?.an ?? null;
+            listTaxes[idTax].skus = [...listTaxes[idTax].skus, skuIt];
+          } else {
+          }
+        } else {
+        }
+      }
+    }
+  }
+
+  return listTaxes;
+};
+
+/**
+ * Envio de SQS para salvar dentro de VTEX 
+ * @param datasend  -- Objeto con envio de parametros salvar impuesto
+ **/
+const sendSQStax = async (datasend) => {
+  if (!SQS_PROCESSTAX_QUEUE_URL || !datasend) {
+    return "Error create sqs tax";
+  }
+  return new Promise(async (res, err) => {
+    try {
+      await AWSServices.sendSQSMessage(SQS_PROCESSTAX_QUEUE_URL, datasend);
+      res("Notification sqs tax successfully");
+    } catch (err) {
+      Logger.error('error crear SQS tax', err);
+      res("Error create sqs tax");
+    }
+  });
+}
+
+module.exports = {
+  producer,
+};