dcos-core-monalisav2-latam 1.0.0

package/src/functions/orders/orders-notifications-handler.js

@@ -0,0 +1,137 @@
+"use strict";
+const ClientData = require("../../entities/clients");
+const OrderData = require("../../entities/orders");
+const ApiResponse = require("../../common/utils/api-response");
+const Logger = require("../../common/utils/logger");
+/**
+ *
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns
+ */
+module.exports.notifications = async (event) => {
+  try {
+    const account = event?.queryStringParameters?.an;
+    var from = event?.queryStringParameters?.from;
+    var to = event?.queryStringParameters?.to;
+    const state = event?.queryStringParameters?.state;
+    const minutesWaiting = event?.queryStringParameters?.minutesWaiting ?? 6;
+    const limitPerPage = event?.queryStringParameters?.limit;
+    const page = parseInt(event?.queryStringParameters?.p); // || 1
+    const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+
+    Logger.log("Event: ", account, from, to, state, page, clientId);
+
+    ApiResponse.validateRequiredParam("account parameter 'an'", account);
+    ApiResponse.validateRequiredParam("from parameter 'from'", from);
+    ApiResponse.validateRequiredParam("to parameter 'to'", to);
+
+    if (page < 1) {
+      return ApiResponse.response(400, "The page starts with '1'.");
+    }
+
+    if (validarFecha(from)) {
+      from = obtenerFechaDesdeCadena(from, 0, null).toISOString();
+    } else {
+      return ApiResponse.response(400, "El formato de fecha 'from' no es válido");
+    }
+    if (validarFecha(to)) {
+      to = obtenerFechaDesdeCadena(to, parseInt(minutesWaiting), state).toISOString();
+    } else {
+      return ApiResponse.response(400, "El formato de fecha 'to' no es válido");
+    }
+
+    const dateFrom = new Date(from);
+    const dateTo = new Date(to);
+
+    if (isNaN(dateFrom) || isNaN(dateTo)) {
+      return ApiResponse.response(400, "Una o ambas fechas no están en un formato válido");
+    } else if (dateFrom >= dateTo) {
+      return ApiResponse.response(400, "La fecha 'from' debe ser menor que la fecha 'to'");
+    }
+    const validAccount = await ClientData.validateAccount(clientId, account);
+    if (!validAccount) {
+      Logger.error("Data INVALID: ", validAccount);
+      return ApiResponse.response(404, "Account not found");
+    }
+
+    let limitPage= limitPerPage && Number.isNaN(parseInt(limitPerPage))==false ? parseInt(limitPerPage) : 100;
+    
+    const total = await OrderData.getOrdersByAccountNameBetweenDatesCountTotals(account, from, to, state);
+    let countPageT= parseInt((total/limitPage));
+    if((parseInt(countPageT)*limitPage) < total){
+      countPageT++;
+    }
+    if(countPageT < page && page > 1){
+      return {
+        statusCode: 200,
+        body: JSON.stringify(tranformedData([], page, total, limitPage), null, 2),
+      };
+    }
+    const orders = await OrderData.getOrdersByAccountNameBetweenDates(account, from, to, state, page, total, limitPage);
+    const response = tranformedData(orders, page, total, limitPage);
+    return {
+      statusCode: 200,
+      body: JSON.stringify(response, null, 2),
+    };
+  } catch (error) {
+    Logger.error(error);
+  }
+  ApiResponse.response(500, "Internal Server Error");
+};
+
+function validarFecha(fecha) {
+  const regex = /^\d{14}$/; // Expresión regular para validar que la cadena tenga exactamente 14 dígitos
+  return regex.test(fecha);
+}
+
+function obtenerFechaDesdeCadena(cadena, minutesPrevNow=null, state=null) {
+  const anio = parseInt(cadena.substring(0, 4));
+  const mes = parseInt(cadena.substring(4, 6));
+  const dia = parseInt(cadena.substring(6, 8));
+  const hora = parseInt(cadena.substring(8, 10));
+  const minuto = parseInt(cadena.substring(10, 12));
+  const segundo = parseInt(cadena.substring(12, 14));
+
+  if(minutesPrevNow && minutesPrevNow > 0 && state != 'cancel' && state != 'canceled' ){
+    let minutesMinus= 1000*60*minutesPrevNow;
+    let dateNow= ((new Date()).getTime()-minutesMinus);
+    let dateService= (new Date(anio, mes - 1, dia, hora, minuto, segundo)).getTime();
+    if( dateNow < dateService ){
+      return new Date(dateNow);
+    }else{
+      return new Date(anio, mes - 1, dia, hora, minuto, segundo);
+    }
+  }else{
+    return new Date(anio, mes - 1, dia, hora, minuto, segundo);
+  }
+}
+
+function tranformedData(items, page, total, limitPage=100) {
+  if(total < items?.length ){
+      total=items?.length;
+  }
+
+  let countPageT= parseInt((total/limitPage));
+  if((parseInt(countPageT)*limitPage) < total){
+    countPageT++;
+  }
+  
+  return {
+    properties: {
+      current_page: !page ? 1 : page,
+      current_page_count: countPageT,
+      total_count: total,
+    },
+    notifications: transformedOrders(items),
+  };
+}
+
+function transformedOrders(orders) {
+  return orders.map((order) => ({
+    id: order.Id,
+    orderId: order.OrderId,
+    accountName: order.AccountNameForOrder,
+    status: order.OrderState,
+    changeDate: order.StatusDate,
+  }));
+}

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

@@ -0,0 +1,461 @@
+"use strict";
+const VtexApi = require("../../vtex/clients/VtexApi");
+const AWSServices = require("../../common/utils/aws-services");
+const Constants = require("../../common/utils/constants");
+const Status = require("../../common/utils/status");
+const Logger = require("../../common/utils/logger");
+
+const SQS_ORDERS_STATUS_DQL_QUEUE_URL = process.env.SQS_ORDERS_STATUS_DQL_QUEUE_URL;
+const SQS_ORDERS_STATUS_QUEUE_URL = process.env.SQS_ORDERS_STATUS_QUEUE_URL;
+const MAX_ATTEMPTS = process.env.MAX_ATTEMPTS || 3;
+
+/**
+ * Autorizacion de pagos dentro de whitelabel VTEX
+ * @param transactions -listado de transsacciones order vtex
+ **/
+const setPaymentVtex = async ({ transactions = null, status = null, vtexApi = null }) => {
+  return new Promise(async function (resolve, reject) {
+    let responsePayment = { status: 200 };
+    if (transactions && status && vtexApi) {
+      for (const transaction of transactions) {
+        for (const paymentParent of transaction?.payments) {
+          if (paymentParent.id) {
+
+            if (status === Status.WAITING_FFMTT_AUTHORIZATION) {
+              const relativePaymentUrl = Constants.APPROVE_PAYMENT.replace("{paymentId}", paymentParent.id);
+              responsePayment = await vtexApi.fetch(relativePaymentUrl, {
+                method: "POST",
+              });
+            }
+            await delayStatusProcess(5);
+          }
+        }
+      }
+    }
+    resolve(responsePayment);
+  });
+};
+
+/**
+ * Autorizacion de pagos dentro de whitelabel VTEX
+ * @param transactions -listado de transsacciones order vtex
+ **/
+const setStartHandlingVtex = async ({ sellerOrderId = null, status = null, vtexApi = null }) => {
+  return new Promise(async function (resolve, reject) {
+    let responseHandling = { status: 200 };
+    if (sellerOrderId && status && vtexApi) {
+      if (status === Status.READY_FOR_HANDLING) {
+        const relativeHandlingUrl = Constants.START_HANDLING_ORDER.replace("{orderId}", sellerOrderId);
+        responseHandling = await vtexApi.fetch(relativeHandlingUrl, {
+          method: "POST",
+        });
+        await delayStatusProcess(5);
+      }
+    }
+    resolve(responseHandling);
+  });
+};
+
+/**
+ * Reenviar cola 
+ * @param record cuerpo de la cola
+ **/
+const resendSqs = async ({ record = null }) => {
+  return new Promise(async function (resolve, reject) {
+    if (record) {
+      const attempts = JSON.parse(record.body)?.attempts || 0;
+      let clientVtexBody = JSON.parse(record.body);
+      clientVtexBody.attempts = attempts + 1;
+
+      if (attempts < MAX_ATTEMPTS) {
+        await delayStatusProcess(3);
+        await AWSServices.sendSQSMessage(SQS_ORDERS_STATUS_QUEUE_URL, clientVtexBody);
+      } else {
+        throw new Error("Max attempts reached.");
+      }
+    }
+    resolve(true);
+  });
+};
+
+/**
+ * Reenviar canbios orden VTEX 
+ * @param changes 
+ * @param orderVtex 
+ * @param vtexApi 
+ **/
+const setChangesVtex = async ({ changes = null, orderVtex = null, vtexApi = null, sellerOrderId = null }) => {
+  return new Promise(async function (resolve, reject) {
+    if (changes && orderVtex && vtexApi && sellerOrderId) {
+      let itemsChangesRemovedArray = [];
+      for (const itemRemove of changes?.itemsRemoved) {
+        itemsChangesRemovedArray = [...itemsChangesRemovedArray, {
+          id: itemRemove.id,
+          price: itemRemove.price,
+          quantity: itemRemove.quantity
+        }];
+      }
+      let requestId = `${changes?.discountValue}-${itemsChangesRemovedArray?.map(it => `${it.id}-${it.quantity}-${it.price}`)?.join('')}-changes`;
+      let registerChangeOnOrderPayload = {
+        requestId: requestId.substring(0, 30),
+        itemsRemoved: itemsChangesRemovedArray,
+        reason: changes?.reason,
+        discountValue: changes?.discountValue,
+        incrementValue: 0,
+        itemsAdded: [],
+      };
+
+      const relativeChangeUrl = Constants.REGISTER_CHANGE_ON_ORDER.replace("{orderId}", sellerOrderId);
+      let responseChange = {};
+      let validChangeOrder = validChangesOrder({ order: orderVtex, change: registerChangeOnOrderPayload });
+      if (itemsChangesRemovedArray.length > 0 && validChangeOrder?.valid == true && validChangeOrder?.changes) {
+        responseChange = await vtexApi.fetch(relativeChangeUrl, {
+          method: "POST",
+          data: validChangeOrder?.changes,
+        });
+      } else {
+        responseChange = { status: 200 };
+      }
+    }
+    resolve(true);
+  });
+};
+
+/**
+ * Reenviar facturacion VTEX 
+ * @param documents 
+ * @param orderVtex 
+ * @param vtexApi 
+ **/
+const setInvoicedVtex = async ({ documents = null, orderVtex = null, vtexApi = null, sellerOrderId = null, SetValueInvoiceOrderForced = false }) => {
+  let invoiceValue = documents?.invoiceValue;
+  if (SetValueInvoiceOrderForced && SetValueInvoiceOrderForced != false) {
+    let sumaInvoiced = 0;
+
+    if (orderVtex?.packageAttachment?.packages) {
+      for (let inr = 0; inr < orderVtex?.packageAttachment?.packages?.length; inr++) {
+        sumaInvoiced += parseFloat(orderVtex?.packageAttachment?.packages[inr]?.invoiceValue);
+      }
+    }
+
+    if (sumaInvoiced === 0 || parseFloat(sumaInvoiced) != parseFloat(invoiceValue)) {
+      invoiceValue = parseFloat(orderVtex?.value) - parseFloat(sumaInvoiced);
+    }
+  }
+
+  return new Promise(async function (resolve, reject) {
+    let responseNotification = { status: 500 };
+    if (documents && orderVtex && vtexApi && sellerOrderId) {
+      const invoiceNotificationOrderPayload = {
+        type: "Output",
+        issuanceDate: documents?.issuanceDate,
+        invoiceNumber: documents?.invoiceNumber,
+        invoiceValue: invoiceValue,
+        invoiceKey: null,
+        invoiceUrl: documents?.invoiceUrl,
+        embeddedInvoice: null,
+        courier: "mdlz",
+        trackingNumber: documents?.invoiceNumber,
+        trackingUrl: null,
+        dispatchedDate: null,
+        items: orderVtex.items.map((item) => ({ id: item.id, quantity: item.quantity, price: item.sellingPrice }))
+      };
+
+      const relativeNotificationUrl = Constants.INVOICE_NOTIFICATION_ORDER.replace("{orderId}", sellerOrderId);
+      responseNotification = await vtexApi.fetch(relativeNotificationUrl, {
+        method: "POST",
+        data: invoiceNotificationOrderPayload,
+      });
+    }
+    resolve(responseNotification);
+  });
+};
+
+/**
+ * Validacion de aplicaion de changes en vtex
+ * @param order -- objeto de la orden dentro de vtex
+ * @param change -- cambios a aplicar dentro de la orden
+ **/
+const validChangesOrder = ({ order = null, change = null }) => {
+  if (order && change) {
+    if (order?.changesAttachment && order?.changesAttachment?.changesData && typeof order?.changesAttachment?.changesData == 'object' && order?.changesAttachment?.changesData.length > 0) {
+
+      if (change?.itemsRemoved && typeof change?.itemsRemoved == 'object' && change?.itemsRemoved.length > 0 && change?.reason && change?.discountValue) {
+        let itemsRemovedChange = [];
+        let validItemsChange = false;
+        let changepervalid = null;
+
+        for (let i = 0; i < order?.changesAttachment?.changesData.length; i++) {
+          if (order?.changesAttachment?.changesData[i]?.reason == change?.reason && order?.changesAttachment?.changesData[i]?.discountValue == change?.discountValue) {
+            validItemsChange = true;
+            changepervalid = order?.changesAttachment?.changesData[i];
+          }
+        }
+
+        if (validItemsChange == false) {
+          itemsRemovedChange = change?.itemsRemoved;
+        } else if (changepervalid && validItemsChange) {
+          let listFirts = [];
+          for (let j = 0; j < changepervalid?.itemsRemoved.length; j++) {
+            for (let x = 0; x < change?.itemsRemoved.length; x++) {
+              if (!listFirts.includes(change?.itemsRemoved[x]?.id) &&
+                ((changepervalid?.itemsRemoved[j]?.id != change?.itemsRemoved[x]?.id && changepervalid?.itemsRemoved[j]?.quantity == change?.itemsRemoved[x]?.quantity) ||
+                  (changepervalid?.itemsRemoved[j]?.id == change?.itemsRemoved[x]?.id && changepervalid?.itemsRemoved[j]?.quantity != change?.itemsRemoved[x]?.quantity))
+              ) {
+                itemsRemovedChange = [...itemsRemovedChange, change?.itemsRemoved[x]];
+              }
+              listFirts = [...listFirts, change?.itemsRemoved[x]?.id]
+            }
+          }
+        }
+        if (itemsRemovedChange.length > 0) {
+          change.itemsRemoved = itemsRemovedChange;
+          return { valid: true, changes: change, log: 'success' };
+        } else {
+          return { valid: false, changes: null, log: 'Not items removed!' };
+        }
+      } else {
+        return { valid: false, changes: null, log: 'not items removed' };
+      }
+
+    } else {
+      return { valid: true, changes: change, log: 'success' };
+    }
+  } else {
+    return { valid: false, changes: null, log: 'error in order or changes' };
+  }
+};
+
+/**
+ * Dar delay antes de iniciar un proceso
+ * @param time  // tiempo en segundos para esperar 
+ **/
+const delayStatusProcess = (time) => {
+  if (!time || time < 1) {
+    return true;
+  }
+  return new Promise((resolve, reject) => {
+    setTimeout(function () {
+      resolve(true);
+    }, (time * 1000));
+  })
+};
+
+const setChangesOrInvoiced = async (an, key, token, changes, documents, orderVtex, sellerOrderId, record) => {
+  const vtexApi = new VtexApi(an, key, token);
+  let clientVtexBody = JSON.parse(record.body);
+
+  // Aprobacion de pago
+  let responsePayment = await setPaymentVtex({ transactions: orderVtex?.paymentData?.transactions, status: orderVtex?.status, vtexApi: vtexApi });
+
+  if (
+    responsePayment?.status < 200 ||
+    responsePayment?.status > 300
+  ) {
+    Logger.error(
+      "Error updating client. Status: ",
+      responsePayment.status,
+      ". Message: ",
+      responsePayment?.data?.message
+    );
+    await resendSqs({ record: record });
+    throw new Error("Payment approve no processed for orderId: ", sellerOrderId);
+    return false;
+  } else {
+  }
+  //fin aprobacion pago
+
+  await delayStatusProcess(5);
+
+  const orderSellerVtexResponse5 = await vtexApi.fetch(Constants.GET_ORDER.replace("{orderId}", sellerOrderId), {
+    method: "GET",
+  });
+
+  const orderSellerVtexData5 = orderSellerVtexResponse5.data;
+
+  if (orderSellerVtexData5.status != Status.CANCEL &&
+    orderSellerVtexData5.status != Status.CANCELED) {
+
+    // StartHanling VTEX
+    let responseHandling = await setStartHandlingVtex({ sellerOrderId: sellerOrderId, status: orderSellerVtexData5.status, vtexApi: vtexApi });
+
+    if (
+      responseHandling?.status < 200 ||
+      responseHandling?.status > 300
+    ) {
+      await resendSqs({ record: record });
+      throw new Error("Start Handling no processed correctly.");
+      return false;
+    } else {
+    }
+    // Fin StartHanling VTEX
+
+    const orderSellerVtexResponse6 = await vtexApi.fetch(
+      Constants.GET_ORDER.replace("{orderId}", sellerOrderId),
+      {
+        method: "GET",
+      }
+    );
+    const orderSellerVtexData6 = orderSellerVtexResponse6.data;
+
+    if (changes) {
+      // Cambios en la orden
+      const resChanges = await setChangesVtex({ changes: changes, orderVtex: orderSellerVtexData6, vtexApi: vtexApi, sellerOrderId: sellerOrderId });
+      await delayStatusProcess(5);
+    }
+
+    if (documents && documents.type === "invoice") {
+      // facturacion orden VTEX
+      const body2 = JSON.parse(record.body)
+      const SetValueInvoiceOrderForced = body2?.SetValueInvoiceOrderForced ?? false;
+      const resInvoice = await setInvoicedVtex({ documents: documents, orderVtex: orderSellerVtexData6, vtexApi: vtexApi, sellerOrderId: sellerOrderId, SetValueInvoiceOrderForced: SetValueInvoiceOrderForced });
+      if (resInvoice?.status >= 200 && resInvoice?.status < 300) {
+      } else {
+        await resendSqs({ record: record });
+        throw new Error("Invoiced not processed correctly.");
+      }
+    }
+  }
+};
+
+/**
+ *
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns
+ */
+const consumer = async (event) => {
+  for (const record of event.Records) {
+    const body = JSON.parse(record.body);
+    Logger.debug("Message Body: ", body);
+    if (body) {
+      try {
+        const { an, key, token, request, orderId } = body;
+        const apiClient = new VtexApi(an, key, token);
+        const orderClientVtexResponse = await apiClient.fetch(Constants.GET_ORDER.replace("{orderId}", orderId), {
+          method: "GET",
+        });
+        if (orderClientVtexResponse?.status < 200 || orderClientVtexResponse?.status >= 300) {
+          Logger.error("Order not found: ", orderClientVtexResponse);
+          throw new Error("Order not found");
+        }
+        const orderVtex = await orderClientVtexResponse.data;
+
+        // Se valida si la petición corresponde a una devolución de productos
+        if (request?.documents?.type == 'return') {
+          await setReturnedItems(apiClient, request, orderVtex, orderId);
+        } else {
+          // En caso contrario, se procede a ejecutar la facturación
+          const changes = request?.changes;
+          const documents = request?.documents;
+
+          await setChangesOrInvoiced(an, key, token, changes, documents, orderVtex, orderId, record);
+        }
+      } catch (error) {
+        Logger.error("Register Orders status Consumer: ", error);
+        try {
+          await resendSqs({ record: record });
+          Logger.error("AxiosError: ", error?.response?.data);
+        } catch (error) {
+          Logger.error("Sending message from orders status consumer to DQL Queue:", error);
+        }
+      }
+    }
+  }
+};
+
+async function setReturnedItems(apiClient, request, orderVtex, sellerOrderId) {
+  const { documents } = request;
+  const { invoiceValue, issuanceDate, invoiceNumber, returnItems } = documents;
+  const { items, packageAttachment } = orderVtex;
+
+  const invoiceNotificationOrderPayload = {
+    type: "Input",
+    issuanceDate: issuanceDate,
+    invoiceNumber: invoiceNumber,
+    invoiceValue: invoiceValue,
+    invoiceKey: null,
+    invoiceUrl: null,
+    embeddedInvoice: null,
+    courier: "mdlz",
+    trackingNumber: invoiceNumber,
+    trackingUrl: null,
+    dispatchedDate: null,
+    items: []
+  };
+
+  // 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 recorre en un primer nivel los productos a devolver
+  for (let sku in groupReturnedItems) {
+    // Se recorre la lista de productos de la orden, para descontar las unidades del producto
+    for (let index in groupItems) {
+      const { [sku]: qty } = groupReturnedItems;
+      const { id, refId, quantity, sellingPrice } = groupItems[index];
+      if (sku == refId) {
+        if (qty > 0 && quantity > 0) {
+          // Si las unidades a devolver es menor o igual a las unidades del ítem, no se necesita buscar en otro ítem de la orden
+          if (qty <= quantity) {
+            invoiceNotificationOrderPayload.items.push({ id, quantity: qty, price: sellingPrice });
+            // Se actualiza a cero las unidades a devolver, para no tener que descontar unidades de otro ítem del mismo producto
+            groupReturnedItems[sku] = 0;
+          } else {
+            // En este caso, se entiende por devuelto todos las unidades del ítem
+            groupReturnedItems[sku] = qty - quantity;
+            invoiceNotificationOrderPayload.items.push({ id, quantity, price: sellingPrice });
+            groupItems[index].quantity = 0;
+          }
+        }
+      }
+    }
+  }
+
+  return new Promise(function (resolve, reject) {
+    const relativeNotificationUrl = Constants.INVOICE_NOTIFICATION_ORDER.replace("{orderId}", sellerOrderId);
+    apiClient.fetch(relativeNotificationUrl, {
+      method: "POST",
+      data: invoiceNotificationOrderPayload,
+    }).then(res => {
+      resolve(res)
+    }).catch(reject);
+  });
+}
+
+module.exports = {
+  consumer
+};
+