dcos-core-monalisav2-latam 1.0.0

package/src/functions/orders/orders-status-producer.js

@@ -0,0 +1,443 @@
+"use strict";
+const AWSServices = require("../../common/utils/aws-services");
+const ApiResponse = require("../../common/utils/api-response");
+const AccountData = require("../../entities/account");
+const ClientData = require("../../entities/clients");
+const OrderData = require("../../entities/orders");
+const SkuData = require("../../entities/sku");
+const VtexApi = require("../../vtex/clients/VtexApi");
+const Constants = require("../../common/utils/constants");
+const DistributorData = require("../distributors/distributor");
+const Status = require("../../common/utils/status");
+const Logger = require("../../common/utils/logger");
+
+const ORDER_STATUS_QUEUE_URL = process.env.ORDER_STATUS_QUEUE_URL;
+const LIMIT_ITEMS_TO_PROCESS = process?.env?.LIMIT_ITEMS_TO_PROCESS || 150;
+const isArrayEmpty = (arr) => !Array.isArray(arr) || arr.length === 0;
+var totalCHangesDuplicates = 0;
+
+const producer = async (event) => {
+  let statusCode = 202;
+  let message;
+
+  const client_id = event?.requestContext?.authorizer?.claims?.client_id;
+  Logger.log(JSON.stringify(JSON.parse(event.body)), client_id);
+
+  try {
+    // Validacon de variables iniciales
+    let listData = await validData({ event: event });
+
+    if (listData.errors.length === 0) {
+
+      const dataSend = {
+        an: listData?.data?.account?.AccountName,
+        key: listData?.data?.account?.Credentials?.key,
+        token: listData?.data?.account?.Credentials?.token,
+        request: listData?.data?.request,
+        orderId: listData?.data?.sellerOrderId,
+        SetValueInvoiceOrderForced: listData?.data?.account?.SetValueInvoiceOrderForced
+      };
+      await AWSServices.sendSQSMessage(ORDER_STATUS_QUEUE_URL, dataSend);
+
+      message = "Message accepted!";
+    } else {
+      // con errores
+      return ApiResponse.response(404, { errors: listData.errors });
+    }
+
+  } catch (error) {
+    Logger.error("Error order status producer: ", error);
+    message = error;
+    statusCode = 500;
+  }
+  return ApiResponse.response(statusCode, message);
+};
+
+const validData = async ({ event = null }) => {
+  let errorInitial = await validInitial({ event: event });
+  if (errorInitial.errors.length === 0) {
+    let resData = { data: {}, errors: [] };
+    let request = event.body ? JSON.parse(event.body) : null;
+
+    resData.data.account = errorInitial?.data?.account;
+    resData.data.sellerOrderId = errorInitial?.data?.sellerOrderId;
+    resData.data.request = errorInitial?.data?.request;
+
+    // Validacion errores changes y documents
+    const apiClient = new VtexApi(errorInitial?.data?.account?.AccountName, errorInitial?.data?.account?.Credentials?.key, errorInitial?.data?.account?.Credentials?.token);
+    const orderClientVtexResponse = await apiClient.fetch(Constants.GET_ORDER.replace("{orderId}", errorInitial?.data?.sellerOrderId), {
+      method: "GET",
+    });
+
+    if (orderClientVtexResponse?.data?.status == 'cancel' || orderClientVtexResponse?.data?.status == 'canceled') {
+      resData.errors = [...resData.errors, 'order canceled'];
+      return resData;
+    }
+
+    if (request?.documents?.type == 'return') {
+      // Se valida la información de los datos de devolución de la orden
+      const errors = await validReturnedItems(request, orderClientVtexResponse);
+      resData.errors = [...errors];
+    } else {
+      let errorChanges = await validChanges({ event: event, orderClientVtexResponse: orderClientVtexResponse, account: errorInitial?.data?.account });
+      let errorDocuments = await validDocuments({ event: event, orderClientVtexResponse: orderClientVtexResponse });
+
+      if (errorChanges.errors.length === 0 && resData?.data?.request?.changes?.itemsRemoved) {
+        resData.data.request.changes.itemsRemoved = errorChanges?.itemsRemoved;
+      }
+
+      if (totalCHangesDuplicates > 0 && resData?.data?.request?.documents?.invoiceValue) {
+        resData.data.request.documents.invoiceValue = (parseFloat(resData.data.request.documents.invoiceValue) - parseFloat(totalCHangesDuplicates));
+      }
+
+      for (var i = 0; i < errorChanges.errors.length; i++) {
+        resData.errors = [...resData.errors, errorChanges.errors[i]];
+      }
+      for (var i = 0; i < errorDocuments.length; i++) {
+        resData.errors = [...resData.errors, errorDocuments[i]];
+      }
+    }
+
+    return resData;
+  } else { // errores iniciales
+    return { data: {}, errors: errorInitial.errors };
+  }
+}
+
+const validInitial = async ({ event = null }) => {
+  let errors = { errors: [], data: {} }
+  if (event) {
+    let request = event.body ? JSON.parse(event.body) : null;
+    if (!request) {
+      Logger.error("No body was found: ", event.body);
+      errors.errors = [...errors.errors, "No body was found"];
+    }
+
+    errors.data.request = request;
+
+    const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+    const scope = event?.requestContext?.authorizer?.claims?.scope;
+    const pathParameters = event.pathParameters;
+
+    if (!pathParameters) {
+      errors.errors = [...errors.errors, "Payload request no valid."];
+    }
+    const sellerOrderId = pathParameters?.orderId;
+
+    if (!sellerOrderId) {
+      Logger.error("Parameter order id not found: ", sellerOrderId);
+      errors.errors = [...errors.errors, "Order id no specified."];
+    } else {
+      errors.data.sellerOrderId = sellerOrderId;
+    }
+
+
+    const order = await OrderData.getOrderDataByOrderId(sellerOrderId);
+    if (!order || isArrayEmpty(order)) {
+      errors.errors = [...errors.errors, "Order not found"];
+    }
+    const orderAccountName = order[0]?.AccountNameForOrder;
+
+    if (!event?.internalService) {
+      if (!scope?.includes("admin")) {
+        const validateAccount = await ClientData.validateAccount(clientId, orderAccountName);
+        if (!validateAccount) {
+          errors.errors = [...errors.errors, "Invalid credentials for Account Name."];
+        }
+      }
+    }
+
+    if (orderAccountName) {
+      const account = await AccountData.getAccountDataByAccountName(orderAccountName);
+      if (!account) {
+        errors.errors = [...errors.errors, "Account config not found"];
+      } else {
+        errors.data.account = account;
+      }
+    } else {
+      errors.errors = [...errors.errors, "Account config not found"];
+    }
+  }
+
+  return errors;
+}
+
+const validChanges = async ({ event = null, orderClientVtexResponse = null, account = null }) => {
+  let errors = [], itemsRemoved = [];
+  let request = event.body ? JSON.parse(event.body) : null;
+  const pathParameters = event.pathParameters;
+  const sellerOrderId = pathParameters?.orderId;
+  const changes = request?.changes;
+  if (event && changes && typeof changes == 'object') {
+
+    if (changes && changes.discountValue && changes.discountValue < 0) {
+      errors = [...errors, "Discount value not allowed."];
+    }
+
+    if (orderClientVtexResponse.status >= 200 && orderClientVtexResponse.status < 300) {
+      const packages = null;
+
+      if (typeof packages == 'object' && packages && packages.length > 0) {
+        errors = [...errors, "order already has changes applied."];
+      } else {
+        let skuRefUsed = account?.SkuRefUsed;
+        if (typeof skuRefUsed !== "boolean") {
+          Logger.error("Sku or ReferenceCode filter not defined, use default: ", skuRefUsed);
+          skuRefUsed = true;
+        }
+        let newItemsToChangeArray = [], itemsToChange = request?.changes?.itemsRemoved;
+
+        if (itemsToChange && typeof itemsToChange == 'object') {
+          for (let item of itemsToChange) {
+            if (item.sku) {
+              let skuData = null;
+              //Si esta activado el manejo de sku por código de distribuidor 
+              try {
+                const skuDistributorManagement = account?.SkuDistributorManagement || false;
+                item.sku = await DistributorData.getDistributorByErpCode(account?.AccountName, item?.sku, skuDistributorManagement);
+              } catch (error) {
+                Logger.error("Error al obtener distribuidor por sku:", error);
+              }
+              if (skuRefUsed) {
+                skuData = await SkuData.getSkuByParentAccountNameAndSku(account?.ParentAccountName, item?.sku);
+              } else {
+                skuData = await SkuData.getSkuByParentAccountNameAndEan(account?.ParentAccountName, item?.sku);
+                if (!skuData || skuData.length === 0) {
+                  Logger.error("Not found sku: ", item, ". Db data:", skuData);
+                  skuData = null;
+                } else if (skuData[0]) {
+                  skuData = skuData[0];
+                } else {
+                  skuData = null;
+                }
+              }
+              let itemOrderVtex = null;
+              if (!skuData) {
+                Logger.error("Not found sku: ", item, ". Db data:", skuData);
+                errors = [...errors, `Sku ${item.sku} not found`];
+              } else {
+                itemOrderVtex = orderClientVtexResponse?.data?.items?.find(
+                  (element) => Number(element?.id) === skuData?.SkuId
+                );
+
+                if (itemOrderVtex) {
+                  if (itemOrderVtex?.quantity < item?.quantity) {
+                    Logger.error("Not found sku: ", item, ". Vtex data:", itemOrderVtex, ". Sku data: ", skuData);
+                    // errors= [...errors, `Sku ${item.sku} quantity is greater than the quantity in the Vtex Order ${sellerOrderId}`];
+                  }
+
+                } else {
+                  Logger.error("Not found sku: ", item, ". Vtex data:", itemOrderVtex, ". Sku data: ", skuData);
+                  errors = [...errors, `Sku ${item.sku} not found in Vtex Order ${sellerOrderId}`];
+                }
+              }
+
+              if (!item?.quantity) {
+                errors = [...errors, `Sku ${item.sku} quantity is required.`];
+              }
+              if (item?.price === null) {
+                errors = [...errors, `Sku ${item.sku} price is required.`];
+              }
+
+              if (skuData?.SkuId && item?.quantity) {
+                newItemsToChangeArray = [...newItemsToChangeArray, { id: skuData?.SkuId, price: item.price, quantity: item.quantity }]
+              }
+
+            } else {
+              Logger.error("Not found sku: ", item);
+              errors = [...errors, `Sku ${JSON.stringify(item)} not found`];
+            }
+          }
+        }
+
+        if (itemsToChange && typeof itemsToChange == 'object' && itemsToChange.length === newItemsToChangeArray.length) {
+          itemsRemoved = newItemsToChangeArray;
+        } else if (itemsToChange && typeof itemsToChange == 'object') {
+          Logger.error("Error in itemsRemoved: ", request?.changes?.itemsRemoved, newItemsToChangeArray);
+          errors = [...errors, `Remove items error ${JSON.stringify({ itemsRemove: request?.changes?.itemsRemoved, relations: newItemsToChangeArray })}`];
+        }
+      }
+    }
+  }
+
+  return { errors: errors, itemsRemoved: itemsRemoved };
+}
+
+const validDocuments = async ({ event = null, orderClientVtexResponse = null }) => {
+  let errors = [];
+  let request = event.body ? JSON.parse(event.body) : null;
+  const documentI = request?.documents;
+  if (event && documentI) {
+
+    if (documentI && documentI.invoiceValue && documentI.invoiceValue <= 0) {
+      errors = [...errors, "Invoice value not allowed."];
+    }
+
+    // Si existe documents, validar y corregir el formato de fecha
+    if (documentI?.issuanceDate) {
+      try {
+        const date = new Date(documentI.issuanceDate);
+        if (isNaN(date.getTime())) {
+          request.documents.issuanceDate = new Date().toISOString();
+        } else {
+          request.documents.issuanceDate = date.toISOString();
+        }
+      } catch (error) {
+        request.documents.issuanceDate = new Date().toISOString();
+      }
+    }
+
+    if (orderClientVtexResponse.status >= 200 && orderClientVtexResponse.status < 300) {
+      totalCHangesDuplicates = getTotalChangesDuplicate({ order: orderClientVtexResponse?.data });
+      let totalInvoiceAddDpCg = (parseFloat(orderClientVtexResponse?.data?.value) + parseFloat(totalCHangesDuplicates));
+      if (documentI &&
+        documentI.invoiceValue &&
+        documentI.invoiceValue > totalInvoiceAddDpCg) {
+        errors = [...errors, "Invoice value is greater than the value in the Vtex Order"];
+      }
+
+      let totalInvoiceValue = 0;
+      const packages = orderClientVtexResponse?.data.packageAttachment?.packages || [];
+      if (packages && typeof packages == 'object') {
+        for (let pkg of packages) {
+          if (pkg.type === "Output") {
+            totalInvoiceValue += pkg.invoiceValue;
+          }
+        }
+      }
+
+      const pendingInvoiceValue = (parseFloat(totalInvoiceAddDpCg) - parseFloat(totalInvoiceValue));
+      if ((documentI && documentI.invoiceValue && documentI.invoiceValue > pendingInvoiceValue) || pendingInvoiceValue <= 0) {
+        errors = [...errors, "Invoice value is greater than the pending value to be invoiced in the Vtex Order"];
+      }
+    }
+  }
+  return errors;
+}
+
+/**
+ * Valida que los datos de devolución concuerde con la información de la orden en VTEX.
+ * @param {*} request Datos enviados en la petición a la función Lambda.
+ * @param {*} orderClientVtexResponse Datos de la orden en VTEX.
+ * @returns 
+ */
+const validReturnedItems = async (request, orderClientVtexResponse) => {
+  const { invoiceValue, returnItems } = request.documents;
+
+  if (returnItems.length == 0) {
+    return [`Return items must have at least one item`];
+  }
+
+  // Se consulta las propiedades requeridas de la orden en VTEX, para luego agruparlas
+  const { status, items, packageAttachment } = orderClientVtexResponse?.data;
+
+  // Se valida si la orden se encuentra en estado Cancelado
+  if ([Status.CANCEL, Status.CANCELED].includes(status)) {
+    return [`Order is Canceled`];
+  }
+
+  // Se verifica si la orden se encuentra en estado facturado
+  if (status !== Status.INVOICED) {
+    return [`Order isn't in status Invoiced (${status})`];
+  }
+
+  // Se agrupan los ítems de la lista returnItems
+  const groupReturnedItems = {};
+  for (let returnedItem of returnItems) {
+    const { sku, quantity } = returnedItem;
+    if (!groupReturnedItems.hasOwnProperty(sku)) {
+      groupReturnedItems[sku] = quantity;
+    } else {
+      groupReturnedItems[sku] += quantity;
+    }
+  }
+
+  const groupItems = {};
+  items.forEach((item, index) => {
+    const { id, refId, sellingPrice } = item;
+    groupItems[index] = { id, refId, quantity: 0, sellingPrice };
+  });
+
+  // Se valida las modificaciones ocurridas en la orden (adicionar o remover ítems de la orden)
+  if (packageAttachment?.packages?.length) {
+    for (let packageInfo of packageAttachment.packages) {
+      const { type, items } = packageInfo;
+      for (let item of items) {
+        const { itemIndex, quantity } = item;
+        if (groupItems.hasOwnProperty(itemIndex)) {
+          // Unidades facturadas
+          if (type == 'Output') {
+            groupItems[itemIndex].quantity += quantity;
+          }
+          // Unidades devueltas
+          if (type == 'Input') {
+            groupItems[itemIndex].quantity -= quantity;
+          }
+        }
+      }
+    }
+  }
+
+  // Se obtiene el valor máximo que se puede retornar, y se agrupan las cantidades del producto
+  let maxReturned = 0, skuItems = {};
+  for (let index in groupItems) {
+    const { refId, quantity, sellingPrice } = groupItems[index];
+    maxReturned += (quantity * sellingPrice);
+    if (!skuItems.hasOwnProperty(refId)) {
+      skuItems[refId] = quantity;
+    } else {
+      skuItems[refId] += quantity;
+    }
+  }
+
+  // Se valida que las unidades a retornar del producto no sea mayor a las unidades que se compraron
+  let errors = [];
+  for (let sku in groupReturnedItems) {
+    const { [sku]: qty } = groupReturnedItems;
+    if (skuItems.hasOwnProperty(sku)) {
+      const { [sku]: quantity } = skuItems;
+      if (qty == 0) {
+        errors.push(`Units for SKU ${sku} must be greater than zero`);
+      } else if (qty > quantity) {
+        errors.push(`Units for SKU ${sku} (${qty}) is greater than the buyed units (${quantity})`);
+      }
+    } else {
+      errors.push(`SKU ${sku} not found in order`);
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Total de cambios con duplicidad 
+ **/
+const getTotalChangesDuplicate = ({ order = null }) => {
+  if (order) {
+    let totalChangesDuplicate = 0;
+    let changesDuplicate = [];
+    let reasonChanges = [];
+    let listChange = order?.changesAttachment?.changesData ?? [];
+
+    for (var i = 0; i < listChange.length; i++) {
+      let nameValue = `${listChange[i].reason}${listChange[i].discountValue}-${listChange[i].itemsRemoved?.map(it => `${it.id}-${it.quantity}-${it.price}`)?.join('|')}`;
+      if (!reasonChanges.includes(nameValue) && listChange[i]?.itemsRemoved?.length > 0) {
+        reasonChanges = [...reasonChanges, nameValue];
+      } else if (listChange[i]?.itemsRemoved?.length > 0) {
+        changesDuplicate = [...changesDuplicate, listChange[i]];
+      }
+    }
+
+    for (var i = 0; i < changesDuplicate.length; i++) {
+      totalChangesDuplicate += parseFloat(changesDuplicate[i]?.discountValue);
+    }
+
+    return totalChangesDuplicate;
+  } else {
+    return 0;
+  }
+}
+
+module.exports = {
+  producer,
+};

package/src/functions/prices/index.js

@@ -0,0 +1,75 @@
+
+const ApiResponse = require("../../common/utils/api-response");
+const promotionAndTax = require("./promotion-and-tax");
+const helpperVtex = require("../vtex/vtex-helpers");
+
+module.exports.handler= async (req,res)=>{
+  const resource= req?.resource ?? null;
+  const method= req?.httpMethod ? String(req?.httpMethod).toUpperCase() : null;
+
+  if(resource && method){
+    switch(resource){
+      case "/api/rnb/pvt/calculatorconfiguration":
+          switch(method){
+            case "POST":
+              return await promotionAndTax?.createorupdate(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/api/rnb/pvt/{type}/calculatorconfiguration":
+          switch(method){
+            case "GET":
+              return await promotionAndTax?.gettaxesorpromotions(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/api/rnb/pvt/calculatorconfiguration/{idCalculatorConfiguration}":
+          switch(method){
+            case "GET":
+              return await promotionAndTax?.gettaxorpromotion(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/api/rnb/pvt/archive/calculatorconfiguration/{idCalculatorConfiguration}":
+          switch(method){
+            case "POST":
+              return await promotionAndTax?.archivetaxorpromotion(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/api/catalog_system/pub/products/search":
+          switch(method){
+            case "GET":
+              return await helpperVtex?.list_products_vtex(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/api/catalog_system/pub/category/tree/{categoryLevels}":
+          switch(method){
+            case "GET":
+              return await helpperVtex?.list_categories_vtex(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+      case "/api/catalog_system/pub/brand/list":
+          switch(method){
+            case "GET":
+              return await helpperVtex?.list_brands_vtex(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+        break;
+
+      default:
+        return ApiResponse.response(400, {error: "error resource!."}); 
+    }
+  }else{
+    return ApiResponse.response(400, {error: "error resource!."});
+  }  
+}