dcos-core-monalisav2-latam 1.0.0

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

@@ -0,0 +1,74 @@
+"use strict";
+const ClientData = require("../../entities/clients");
+const AccountData = require("../../entities/account");
+const OrderData = require("../../entities/orders");
+const VtexApi = require("../../vtex/clients/VtexApi");
+const ApiResponse = require("../../common/utils/api-response");
+const Logger = require("../../common/utils/logger");
+
+const cancel = async (event) => {
+  const orderId = event.pathParameters?.orderId;
+  const clientId = event.requestContext?.authorizer?.claims?.client_id;
+  const scope = event?.requestContext?.authorizer?.claims?.scope;
+  ApiResponse.validateRequiredParam("ClientId", clientId);
+  ApiResponse.validateRequiredParam("OrderId", orderId);
+  const dataOrder = await OrderData.getOrderDataByOrderId(orderId);
+  if (!dataOrder || dataOrder.length === 0) {
+    return ApiResponse.response(404, "Order not found");
+  }
+  for (let i = 0; i < dataOrder.length; i++) {
+    const accountNameForOrder = dataOrder[i].AccountNameForOrder;
+    const acountValid = scope.includes("admin")
+      ? true
+      : await ClientData.validateAccount(clientId, accountNameForOrder);
+    if (acountValid) {
+      const accountData = await AccountData.getAccountDataByAccountName(accountNameForOrder);
+      const apiClient = new VtexApi(
+        accountData.AccountName,
+        accountData.Credentials?.key,
+        accountData.Credentials?.token
+      );
+      Logger.setAccount(accountData);
+      let reason = "Orden cancelada";  
+      if(event?.body && event.body != ''){
+        try{
+          reason = JSON.parse(event.body)?.reason ?? "Orden cancelada";
+        }catch (e){
+          Logger.error(e);
+          reason = "Orden cancelada";
+        }     
+      }
+      Logger.debug("VTEX API Client: ", apiClient);
+      const response = await apiClient.fetch(`/oms/pvt/orders/${orderId}/cancel`, {
+        method: "POST",
+        data: {
+          reason: reason,
+        },
+      });
+
+      if (response.status >= 200 || response.status < 300) {        
+        const responseConfirm = await apiClient.fetch(`/oms/pvt/orders/${orderId}/cancel`, {
+          method: "POST",
+          data: {
+            reason: reason,
+          },
+        });
+        if (responseConfirm.status !== 200) {
+          return ApiResponse.response(200, "Order already cancelled");
+        }else{
+          return ApiResponse.response(response.status, "Order cancelled");
+        }
+      }else{
+        return ApiResponse.response(response.status, "Order cancelled");
+      }
+    } else {
+      Logger.error("Data INVALID: ", acountValid);
+      return ApiResponse.response(401, "Account not valid!");
+    }
+  }
+  return ApiResponse.response(500, "Internal Server Error");
+};
+
+module.exports = {
+  cancel,
+};

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

@@ -0,0 +1,280 @@
+"use strict";
+const ClientData = require("../../entities/clients");
+const OrderData = require("../../entities/orders");
+const AccountData = require("../../entities/account");
+const VtexApi = require("../../vtex/clients/VtexApi");
+const ApiResponse = require("../../common/utils/api-response");
+const Convert = require("../../common/MondelezCastOrder");
+const TaxPromotionsData = require("../../entities/taxpromotion");
+const Logger = require("../../common/utils/logger");
+/**
+ *
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns
+ */
+const getOrders = async (event) => {
+  try {
+    //Modify this search data
+    
+    const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+    const orderId = event?.pathParameters?.orderId;
+
+    const order = await OrderData.getOrderDataByOrderId(orderId);
+    if (!order) {
+      return ApiResponse.response(404, "Order not found");
+    }
+    Logger.log("Order: ", orderId);
+    for (let i = 0; i < order.length; i++) {
+      const accountNameForOrder = order[i].AccountNameForOrder;
+      const validateAccount = await ClientData.validateAccount(clientId, accountNameForOrder);
+      if (validateAccount) {
+        const data = await AccountData.getAccountDataByAccountName(accountNameForOrder);
+        const parentAccount = await AccountData.getAccountDataByAccountName(data.ParentAccountName);
+        Logger.setAccount(parentAccount);
+        if (data && parentAccount) {
+          const apiClient = new VtexApi(data?.AccountName, data?.Credentials?.key, data?.Credentials?.token);
+          const apiClientParent = new VtexApi(
+            parentAccount?.AccountName,
+            parentAccount?.Credentials?.key,
+            parentAccount?.Credentials?.token
+          );
+          Logger.debug("VTEX API Client: ", apiClient);
+          const response = await apiClient.fetch(`/oms/pvt/orders/${orderId}`, {
+            method: "GET",
+          });
+          Logger.debug("Response order: ", response);
+          if (response.status >= 200 && response.status < 300) {
+            Logger.debug("Response: ", response.data);
+            const parentOrderId = response?.data?.marketplaceOrderId;
+            if (!parentOrderId) {
+              return ApiResponse.response(404, "Order not found. Parent Order ID not found");
+            }
+            const responseParent = await apiClientParent.fetch(`/oms/pvt/orders/${parentOrderId}`, {
+              method: "GET",
+            });
+            if (responseParent.status >= 200 && responseParent.status < 300) {
+              Logger.debug("Response Parent: ", responseParent.data);
+              const orderDataAndPromotionERP = data?.BindIdExternalPromotion === true ? await TaxPromotionsData.bindIdExternalPromotionToOrderData(responseParent.data) : responseParent.data;
+              let orderMondelez = Convert.orderToJson(response.data, orderDataAndPromotionERP, data);
+              let email = orderMondelez?.clientProfileData?.email;
+              Logger.debug("Email: ", email, typeof email);
+              if (email) {
+                try {
+                  const responseMailParent = await apiClientParent.fetchOrderMail(email);
+                  Logger.debug("Mail Parent: ", responseMailParent);
+                  Logger.debug("Mail Parent: ", responseMailParent?.data?.email);
+                  orderMondelez.clientProfileData.email = responseMailParent?.data?.email;
+                } catch (error) {
+                  Logger.error(error);
+                }
+              }
+              //obtener cliente Masterdat VTEX
+              const idCT = (orderMondelez?.clientProfileData?.email)?.split("+")[1]?.split("@")[0].toString();
+              const responseCT = await apiClientParent.fetch(`/dataentities/${data?.AcronymClientVtex}/search?_fields=_all&id=${idCT}`, {
+                method: "GET",
+              });
+
+              orderMondelez.clientProfileData.customerClassTwo = null;
+              orderMondelez.clientProfileData.customerID = null;
+              orderMondelez.clientProfileData.pdv = null;
+              if (responseCT.status >= 200 && responseCT.status < 300 && responseCT.data && responseCT.data.length > 0) {
+                orderMondelez.clientProfileData.customerClassTwo = responseCT.data[0].customerClassTwo;
+                orderMondelez.clientProfileData.customerID = responseCT?.data[0]?.pdv;
+                orderMondelez.clientProfileData.pdv = responseCT?.data[0]?.pdv;
+                orderMondelez.clientProfileData.priceTables = responseCT?.data[0]?.priceTables;
+              }
+
+              //obtener campos adicionales
+              try {
+                const fieldsAdditionalInfo = data?.AdditionalInfoOrderFromClient?.fields?.join(",");
+                const responseAdditionalInfo = fieldsAdditionalInfo && fieldsAdditionalInfo !== "" ? await apiClient.fetch(`/dataentities/${data?.AdditionalInfoOrderFromClient?.nameEntity}/documents/${orderId}?_fields=${fieldsAdditionalInfo}`, {
+                  method: "GET",
+                }) : { status: 200, data: [] };
+
+                Logger.debug("responseAdditionalInfo: ", responseAdditionalInfo);
+                Logger.debug("responseCT: ", responseCT);
+
+                if (responseAdditionalInfo?.status >= 200 && responseAdditionalInfo?.status < 300 && responseAdditionalInfo?.data) {
+                  const dataItems = responseAdditionalInfo?.data ?? {};
+                  for (const dataItem in dataItems) {
+                    Logger.debug("dataItem: ", dataItem);
+                    orderMondelez.clientProfileData[dataItem] = dataItems[dataItem] ?? responseCT?.data[0]?.[dataItem] ?? null;
+                  }
+                } else {
+                  for (let j = 0; j < data?.AdditionalInfoOrderFromClient?.fields?.length; j++) {
+                    let keyClient = data?.AdditionalInfoOrderFromClient?.fields[j];
+                    if (keyClient && keyClient !== "") {
+                      orderMondelez.clientProfileData[keyClient] = responseCT?.data[0]?.[keyClient] ?? null;
+                    }
+                  }
+                }
+              } catch (errorSetFields) {
+                Logger.error('Error set AdditionalInfoOrderFromClient', errorSetFields);
+              }
+
+              //obtener campos adicionales
+
+              if (data?.ObjectZeroTax === true) {
+                orderMondelez.items = setObjectZeroTax(orderMondelez.items);
+              }
+
+              if (data?.ChannelWarehouse) {
+                orderMondelez.shippingAddress.logisticsInfo.deliveryIds = orderMondelez?.shippingAddress?.logisticsInfo?.deliveryIds?.map(it => {
+                  it.warehouse = "";
+                  for (let wr in data?.ChannelWarehouse) {
+                    if (data?.ChannelWarehouse[wr] == it?.warehouseId) {
+                      it.warehouse = wr;
+                    }
+                  }
+
+                  return it;
+                });
+              }
+
+              // adjuntar campos adicionales a las promociones de la orden
+              orderMondelez = await getAdditionalInfoPromotionsOrder(orderMondelez, data, apiClient);
+              
+              try {
+                //Additional Info Fields Sku Distributors
+                Logger.debug("Sku Distributors Management: ", data?.SkuDistributorManagementAdditionalInfo);
+                orderMondelez = await setItemsSkuDistributors(orderMondelez, data);
+                Logger.debug("Order Mondelez: ", orderMondelez);
+              } catch (error) {
+                Logger.error("GetOrder: ", error);
+              }
+
+              return ApiResponse.response(200, orderMondelez);
+            } else {
+              return ApiResponse.response(responseParent.status, responseParent.data);
+            }
+          } else {
+            return ApiResponse.response(response.status, response.data);
+          }
+        }
+      }
+    }
+    return ApiResponse.response(404, "Order not found");
+  } catch (error) {
+    Logger.error(error);
+    return ApiResponse.response(error?.statusCode || 500, {
+      message: error.message,
+    });
+  }
+};
+
+const setObjectZeroTax = (items) => {
+  if (!items || typeof items != 'object') {
+    return null;
+  }
+
+  for (var i = 0; i < items.length; i++) {
+    let exitTax = items[i]?.priceTags?.find(it => (String(it.name).indexOf("tax@price") > -1));
+
+    if (items[i]?.priceTags?.length === 0 || exitTax?.length === 0) {
+      items[i].priceTags = [...items[i]?.priceTags, {
+        "name": "tax@price",
+        "value": 0,
+        "isPercentual": true,
+        "identifier": null,
+        "rawValue": 0,
+        "valueNominal": 0,
+        "rawValueNominal": 0,
+        "rate": null,
+        "jurisCode": null,
+        "jurisType": null,
+        "jurisName": null
+      }];
+    }
+  }
+
+  return items;
+}
+
+const getAdditionalInfoPromotionsOrder = async (data, account, apiClient) => {
+  if (!account 
+      || !account?.AdditionalFieldsPromotionsInOrder 
+      || !account.AdditionalFieldsPromotionsInOrder?.isActive
+      || !account.AdditionalFieldsPromotionsInOrder?.acronymEntity
+      || Object.keys(account.AdditionalFieldsPromotionsInOrder?.fields).length === 0) return data;
+
+  try {
+    const OrderId = data?.id;
+    const acronymEntity = account?.AdditionalFieldsPromotionsInOrder?.acronymEntity;
+    const responseAdditionalInfo = await apiClient.fetch(`/dataentities/${acronymEntity}/documents/${OrderId}?_fields=detailPromotions`, {
+      method: "GET",
+    });
+    
+
+    if (responseAdditionalInfo?.status >= 200 && responseAdditionalInfo?.status < 300 && responseAdditionalInfo?.data) {
+      const promotions = responseAdditionalInfo?.data?.detailPromotions ?? [];
+      
+      for (const promo of promotions) {
+        const identifiersBenefits = data?.ratesAndBenefitsData?.rateAndBenefitsIdentifiers || [];
+        for (let i = 0; i < identifiersBenefits.length; i++) {
+          const identifier = identifiersBenefits[i];
+          if (identifier?.id === promo?.id) {
+            data.ratesAndBenefitsData.rateAndBenefitsIdentifiers[i] = { ...identifier, ...promo?.fields };
+          }
+        }
+
+        for (let itemIndex = 0; itemIndex < data.items.length; itemIndex++) {
+          const item = data.items[itemIndex];
+          for (let priceTagIndex = 0; priceTagIndex < item.priceTags.length; priceTagIndex++) {
+            const priceTag = item.priceTags[priceTagIndex];
+            if (priceTag?.identifier === promo?.id) {
+              data.items[itemIndex].priceTags[priceTagIndex] = { ...priceTag, ...promo?.fields };
+            }
+          }
+        }
+      }
+      return data;
+    } else {
+      return data;
+    }
+  } catch (errorSetFields) {
+    return data;
+  }
+}
+
+//Additional Info Fields Sku Distributors
+const setItemsSkuDistributors = async (orderMondelez, data) => {
+  if (!data || !data?.SkuDistributorManagementAdditionalInfo) {
+    return orderMondelez;
+  }
+  //TODO: Implement logic for Sku Distributors Management of Orders
+  const items = orderMondelez?.items;
+  const skuRefUsed = data?.SkuRefUsed;
+  if (typeof skuRefUsed !== "boolean") {
+    Logger.debug("Sku or ReferenceCode filter not defined, use default: ", skuRefUsed);
+    skuRefUsed = true;
+  }
+
+  if (!items) {
+    Logger.error("Orders without items.");
+    return orderMondelez;
+  }
+  const apiClient = new VtexApi(data?.AccountName, data?.Credentials?.key, data?.Credentials?.token);
+  Logger.debug("VTEX API Client: ", apiClient);
+  const responseAdditionalInfo = data?.SkuDistributorManagementAdditionalInfo && data?.SkuDistributorManagementAdditionalInfo !== "" ? await apiClient.fetch(`/dataentities/${data?.SkuDistributorManagementAdditionalInfo?.entityName}/documents/${orderMondelez.id}?_fields=_all`, {
+    method: "GET",
+  }) : { status: 200, data: [] };
+  Logger.debug("responseAdditionalInfo in setItemsSkuDistributors: ", responseAdditionalInfo?.data);
+  if (responseAdditionalInfo?.status >= 200 && responseAdditionalInfo?.status < 300 && responseAdditionalInfo?.data) {
+    const dataItems = responseAdditionalInfo?.data?.items ?? [];
+    let itemsOrder = orderMondelez?.items ?? [];
+    orderMondelez.items = itemsOrder.map(itemOrder => {
+      const distributorData = dataItems.find(it => skuRefUsed ? it.refId == itemOrder.sku : it.ean == itemOrder.ean);
+      if (distributorData && distributorData.ERPCode) {
+        itemOrder.sku = distributorData.ERPCode;
+      }
+      return itemOrder;
+    });
+  }
+
+  return orderMondelez;
+};
+
+
+module.exports = {
+  getOrders,
+};

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

@@ -0,0 +1,137 @@
+const OrderData = require("../../entities/orders");
+const AccountData = require("../../entities/account");
+const Convert = require("../../common/MondelezCastOrder");
+const VtexApi = require("../../vtex/clients/VtexApi");
+const TaxPromotionsData = require("../../entities/taxpromotion");
+const Logger = require("../../common/utils/logger");
+
+const fs = require("fs");
+const csv = require("csv");
+const AWS = require("aws-sdk");
+const s3 = new AWS.S3();
+const BUCKET_NAME = process.env.BUCKET_NAME;
+
+const consumer = async (event) => {
+  for (const record of event.Records) {
+    Logger.debug("Message Body: ", record.body);
+    try {
+      let order = JSON.parse(record.body);
+      const dateValue = stringDateVtexToDate(order?.orderInfo?.CurrentChange);
+      const orderToUpdate = {
+        AccountNameForOrder: order?.orderInfo?.Origin?.Account,
+        OrderId: order?.orderInfo?.OrderId,
+        StatusDate: dateValue,
+        OrderState: order?.orderInfo?.State,
+        Domain: order?.orderInfo?.Domain,
+        Key: order?.orderInfo?.Origin?.Key
+      };
+      const orderSaved = await OrderData.addOrder(orderToUpdate);
+      const accountConfig = order?.accountConfig;
+      const configuredSftp = accountConfig?.SftpUsed || false;
+      const directory = accountConfig?.SftpDirectory?.orders;
+      if (accountConfig && configuredSftp && directory) {
+        const parentAccount = await AccountData.getAccountDataByAccountName(accountConfig.ParentAccountName);
+        if (parentAccount) {
+          const apiClient = new VtexApi(
+            accountConfig?.AccountName,
+            accountConfig?.Credentials?.key,
+            accountConfig?.Credentials?.token
+          );
+          const apiClientParent = new VtexApi(
+            parentAccount?.AccountName,
+            parentAccount?.Credentials?.key,
+            parentAccount?.Credentials?.token
+          );
+          const response = await apiClient.fetch(`/oms/pvt/orders/${order?.orderInfo?.OrderId}`, {
+            method: "GET",
+          });
+          if (response.status >= 200 && response.status < 300) {
+            const parentOrderId = response?.data?.marketplaceOrderId;
+            if (!parentOrderId) {
+              Logger.error("Order not found. Parent Order ID not found");
+              throw new Error("Order not found. Parent Order ID not found");
+            }
+            const responseParent = await apiClientParent.fetch(`/oms/pvt/orders/${parentOrderId}`, {
+              method: "GET",
+            });
+            if (responseParent.status >= 200 && responseParent.status < 300) {
+              const orderDataAndPromotionERP = accountConfig?.BindIdExternalPromotion === true ? await TaxPromotionsData.bindIdExternalPromotionToOrderData(responseParent.data) : responseParent.data;
+              let orderMondelez = Convert.orderToJson(response.data, orderDataAndPromotionERP);
+              let email = orderMondelez?.clientProfileData?.email;
+              if (email) {
+                try {
+                  const responseMailParent = await apiClientParent.fetchOrderMail(email);
+                  orderMondelez.clientProfileData.email = responseMailParent?.data?.email;
+                } catch (error) {
+                  Logger.error(error);
+                }
+              }
+              const csvData = Convert.convertJsonOrderToCsv(orderMondelez);
+              let csvDataString = "";
+              await readStream(
+                csv.stringify(
+                  csvData.csvData,
+                  { header: true, columns: csvData.csvHeaders, delimiter: ";" },
+                  (err, output) => {
+                    if (err) {
+                      Logger.error("Error CSV: ", err);
+                    }
+                    csvDataString = output;
+                  }
+                )
+              );
+              const fileName = orderMondelez.id + "_" + orderMondelez.status + "_" + dateValue + ".csv";
+              const params = {
+                Bucket: BUCKET_NAME,
+                Key: `${directory}${fileName}`,
+                Body: csvDataString,
+                ContentType: "text/csv",
+                ACL: "public-read",
+              };
+              await s3.putObject(params).promise();
+            }
+          }
+        }
+      }
+    } catch (error) {
+      Logger.error(error);
+    }
+  }
+};
+
+function readStream(stream) {
+  return new Promise((resolve, reject) => {
+    let csvString = "";
+
+    stream.on("readable", () => {
+      let chunk;
+      while ((chunk = stream.read()) !== null) {
+        csvString += chunk;
+      }
+    });
+
+    stream.on("end", () => {
+      resolve(csvString);
+    });
+
+    stream.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+
+function stringDateVtexToDate(date) {
+  Logger.debug("Date: ", date);
+  let dateValue = date;
+  try {
+    dateValue = new Date(date).toISOString();
+  } catch (error) {
+    Logger.error(error);
+  }
+  Logger.debug("Date: ", dateValue);
+  return dateValue;
+}
+
+module.exports = {
+  consumer,
+};

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

@@ -0,0 +1,170 @@
+const AWSServices = require("../../common/utils/aws-services");
+const ApiResponse = require("../../common/utils/api-response");
+const { isStateInNotificationProviders } = require("../../common/utils/validate-state-order");
+const Logger = require("../../common/utils/logger");
+const ORDER_HOOK_QUEUE_URL = process.env.ORDER_HOOK_QUEUE_URL;
+const SQS_ROUTEFLOW_QUEUE_URL = process.env.SQS_ROUTEFLOW_QUEUE_URL;
+const SQS_SKU_DISTRIBUTOR_QUEUE_URL = process.env.SQS_SKU_DISTRIBUTOR_QUEUE_URL;
+// NOTIFICATIONS
+const SQS_NOTIFICATION_ORDER_STATUS_QUEUE_URL = process.env.SQS_NOTIFICATION_ORDER_STATUS_QUEUE_URL
+// ADDITIONAL FIELDS PROMOTIONS ORDER
+const SQS_PROMOTIONS_ORDER_QUEUE_URL = process.env.SQS_PROMOTIONS_ORDER_QUEUE_URL;
+
+const AccountData = require("../../entities/account");
+
+const producer = async (event) => {
+  let statusCode = 200;
+  let message;
+  if (!event.body) {
+    return ApiResponse.response(400, "No body was found");
+  }
+  try {
+    Logger.debug("all-event: ", event);
+    const appKey = event?.headers?.MDLZ_AppKey ?? event?.headers?.mdlz_appkey;
+    const appToken = event?.headers?.MDLZ_AppToken ?? event?.headers?.mdlz_apptoken;
+
+    if (!appKey || !appToken) {
+      Logger.error("Authorizer credentials is required.");
+    }
+
+    const {Domain, OrderId, CurrentChange, State, Origin} = JSON.parse(event.body);
+    if(!Domain){
+      Logger.error("Domain property is required.");
+    }
+    if(!OrderId){
+      Logger.error("OrderId property is required.");
+    }
+    if(!CurrentChange){
+      Logger.error("CurrentChange property is required.");
+    }
+    if(!State){
+      Logger.error("State property is required.");
+    }
+
+    const accountConfig = Origin?.Account ? await AccountData.getAccountDataByAccountName(Origin?.Account) : {};
+    Logger.setAccount(accountConfig);
+    Logger.debug("account-config: ", accountConfig);
+
+    if(!accountConfig){
+      Logger.error("Account config not found.");
+    }
+    if(!accountConfig?.MDLZAppKey || !accountConfig?.MDLZAppToken){
+      Logger.error("Credentials not found.");
+    }
+    if(accountConfig?.MDLZAppKey !== appKey || accountConfig?.MDLZAppToken !== appToken){
+      Logger.error("Credentials incorrect.");
+    }
+
+    if(Domain && OrderId && CurrentChange && State && accountConfig && accountConfig?.MDLZAppKey === appKey && accountConfig?.MDLZAppToken === appToken){
+      const orderInfo = JSON.parse(event.body);
+      const accountConfigParent = await AccountData.getAccountDataByAccountName(accountConfig?.ParentAccountName);
+      const orderData = {
+        orderInfo,
+        accountConfig,
+        accountConfigParent,
+      };
+      await AWSServices.sendSQSMessage(ORDER_HOOK_QUEUE_URL, orderData);
+      await sendAdditionalFields(orderData);
+      await sendAdditionalFieldsSkuDistributors(orderData);
+      
+      // Send notification status order to user
+      await sendNotificationAtQueue(orderData)
+      // Save additional fields promotions in order
+      await sendAdditionalFieldsPromotionsByOrder(orderData)
+
+      message = "Message accepted!";
+    } else {
+      message = "Message no accepted!";
+    }
+
+  } catch (error) {
+    Logger.error(error);
+    message = error;
+    statusCode = 500;
+  }
+  return ApiResponse.response(statusCode, message);
+};
+
+async function sendAdditionalFieldsPromotionsByOrder(orderData) {
+
+    if (!SQS_PROMOTIONS_ORDER_QUEUE_URL || !orderData) {
+      Logger.error('ERROR send order to promotions queue: missing queueUrl or orderData');
+      return false;
+    }
+
+    const promotionsConfig = orderData?.accountConfig?.AdditionalFieldsPromotionsInOrder;
+    if (!promotionsConfig) {
+      return false;
+    }
+
+    const { isActive, initialState } = promotionsConfig;
+    if (isActive && initialState === orderData?.orderInfo?.State) {
+      await AWSServices.sendSQSMessage(SQS_PROMOTIONS_ORDER_QUEUE_URL, orderData);
+      return true;
+    }
+    return false
+}
+
+async function sendAdditionalFields(orderToUpdate) {
+  const additionalFields = orderToUpdate?.accountConfig?.AdditionalInfoOrderFromClient;
+
+  if(additionalFields && 
+    additionalFields?.initialState !== "" && 
+    additionalFields?.initialState !== "" && 
+    additionalFields?.initialState === orderToUpdate?.orderInfo?.State &&
+    additionalFields?.fields?.length > 0 && 
+    additionalFields?.nameEntity !== ""
+    
+  ){
+    await AWSServices.sendSQSMessage(SQS_ROUTEFLOW_QUEUE_URL, orderToUpdate);
+    return true;
+  }
+
+  return false;
+}
+
+async function sendAdditionalFieldsSkuDistributors(orderToUpdate) {
+  const additionalFields = orderToUpdate?.accountConfig?.SkuDistributorManagementAdditionalInfo;
+
+  if(additionalFields && 
+    additionalFields?.initialState &&
+    additionalFields?.initialState !== "" &&
+    additionalFields?.initialState === orderToUpdate?.orderInfo?.State &&
+    additionalFields?.entityName !== "" && 
+    additionalFields?.isActive !== "" &&
+    additionalFields?.isActive === true
+  ) {
+    await AWSServices.sendSQSMessage(SQS_SKU_DISTRIBUTOR_QUEUE_URL, orderToUpdate);
+    
+    return true;
+  }
+  
+  return false;
+}
+
+// Builder to send notifications of the status of the generated order to the users.
+async function sendNotificationAtQueue(orderData){
+
+  if(!SQS_NOTIFICATION_ORDER_STATUS_QUEUE_URL || !orderData){
+    Logger.error('ERROR in queue')
+    return false
+  }
+
+  const notificationOrderVTEX = orderData?.accountConfig?.NotificationsVTEX
+  const stateOrder = orderData?.orderInfo?.State
+
+  const isActiveNotifications = notificationOrderVTEX?.isActive
+  const notificationProviders = notificationOrderVTEX?.NotificationProviders ?? []
+
+  const isValidState = isStateInNotificationProviders({isActiveNotifications, notificationProviders, stateOrder})
+
+  if(isValidState){
+    await AWSServices.sendSQSMessage(SQS_NOTIFICATION_ORDER_STATUS_QUEUE_URL, orderData)
+    return true;
+  }
+  return false
+}
+
+module.exports = {
+  producer,
+};