dcos-core-monalisav2-latam 1.0.0

package/src/functions/financialpolicy/assign-financialpolicy.js

@@ -0,0 +1,111 @@
+const ApiResponse = require("../../common/utils/api-response");
+const AccountData = require("../../entities/account");
+const ClientData = require("../../entities/clients");
+const MobilvendorApi = require("../../integrations/mobilvendor/MobilvendorApi");
+const FinancialPolicyApi = require("../../integrations/financialPolicy/FinancialPolicyApi");
+const Logger = require("../../common/utils/logger");
+
+/**
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * Service name: assign-financialpolicy.js
+ * Lambda name: assing_financialpolicy
+ * Consumer service: src/functions/financialpolicy/assign-financialpolicy.handler
+ * end Point: POST /financialpolicy/{orderFormId}
+ * @returns
+ */
+
+const handler = async (event) => {
+    const { orderFormId } = event.pathParameters;
+    const { client_id: clientId } = event.requestContext.authorizer.claims;
+    const { assign = true, creditDays = 0 } = JSON.parse(event.body) || {};
+    try {
+        const listAccounts = await ClientData.getClient(clientId);
+        const accountName = listAccounts.AccountNames.values[0] || null;
+        if (!accountName) {
+            return ApiResponse.response(400, { approved: false, message: "AccountName is Required" });
+        }
+        let configAccount = await AccountData.getAccountDataByAccountName(accountName);
+        if (!configAccount) {
+            return ApiResponse.response(400, { approved: false, message: "Account not found" });
+        }
+        if (configAccount.ParentAccountName !== configAccount.AccountName) {
+            configAccount = await AccountData.getAccountDataByAccountName(configAccount.ParentAccountName);
+        }
+        if (!orderFormId) {
+            return ApiResponse.response(400, { approved: false, message: "orderForm is Required" });
+        }
+        try {
+            if (!configAccount.FinancialPolicyEcu?.isActive) {
+                return ApiResponse.response(401, { approved: false, message: "Financial Policy is not active" });
+            }
+            const providerApiName = configAccount?.FinancialPolicyEcu?.providerApi || 'MobilvendorApi';
+            let ApiClass;
+            try {
+                ApiClass = eval(providerApiName);
+            } catch (evalError) {
+                Logger.error(`Provider ${providerApiName} not found, falling back to MobilvendorApi`);
+                ApiClass = MobilvendorApi;
+            }
+            if (!ApiClass) {
+                Logger.error('API class not found, falling back to MobilvendorApi');
+                ApiClass = MobilvendorApi;
+            }
+            const responseApi = new ApiClass(
+                configAccount.AccountName,
+                configAccount.Credentials.key,
+                configAccount.Credentials.token,
+                configAccount.AcronymClientVtex,
+                configAccount.FinancialPolicyEcu
+            );
+            const orderForm = await responseApi.getOrderFormById(orderFormId);
+            const email = orderForm?.clientProfileData?.email ?? null;
+            const responseMasterDataCT = email ? await responseApi.getClientById(email) : null;
+            const accountNameWl = responseMasterDataCT?.an ?? null;
+            if (accountNameWl) {
+                const configAccountWl = await AccountData.getAccountDataByAccountName(accountNameWl);
+                if (configAccountWl?.FinancialPolicyEcu && responseApi.setConfig) {
+                    responseApi.setConfig(configAccountWl.FinancialPolicyEcu);
+                } else if(!responseApi.setConfig) {
+                    return ApiResponse.response(400, { approved: false, message: "Function setConfig not found" });
+                } else {
+                    return ApiResponse.response(400, { approved: false, message: "AccountWl not found" });
+                }
+            }
+            if (!assign) {
+                await responseApi.deleteCustomData(orderFormId, orderForm?.customData);
+                return ApiResponse.response(401, { approved: false, message: "unapproved credit" });
+            }
+            const responseApiBalance = await responseApi.getCustomerBalance(orderForm, creditDays, responseMasterDataCT);
+            const bodyOrderFormCustomData = {
+                approved: responseApiBalance.approved || false,
+                withCredit: responseApiBalance.withCredit || false,
+                paymentTerm: responseApiBalance.paymentTerm || 0,
+                maximumCreditAmount: responseApiBalance.maximumCreditAmount || 0,
+                paymentMethodCode: responseApiBalance.paymentMethodCode || "-",
+                creditDays: responseApiBalance.creditDays || 0,
+                paymentMethodName: responseApiBalance.paymentMethodName || "-",
+            };
+            if (!responseApiBalance.approved) {
+                await responseApi.deleteCustomData(orderFormId, orderForm?.customData);
+                return ApiResponse.response(401, { approved: false, message: "unapproved credit" });
+            }
+            const updateOrderFormCustomData = await responseApi.updateOrderFormCustomData(
+                orderFormId,
+                configAccount.FinancialPolicyEcu.configVtex.id,
+                bodyOrderFormCustomData
+            );
+            if (!updateOrderFormCustomData) {
+                return ApiResponse.response(401, { approved: false, message: "Error updating customData orderForm" });
+            }
+            return ApiResponse.response(200, bodyOrderFormCustomData);
+        } catch (error) {
+            Logger.error('Error creating API instance:', error);
+            return ApiResponse.response(404, { approved: false, message: "Error creating API instance" });
+        }
+    } catch (error) {
+        Logger.error("Error clients producer:", error);
+        return ApiResponse.response(401, { approved: false, message: "Error login mobilvendor" });
+    }
+};
+
+module.exports = { handler };

package/src/functions/financialpolicy/get-financialpolicy.js

@@ -0,0 +1,91 @@
+const ApiResponse = require("../../common/utils/api-response");
+const AccountData = require("../../entities/account");
+const ClientData = require("../../entities/clients");
+const MobilvendorApi = require("../../integrations/mobilvendor/MobilvendorApi");
+const FinancialPolicyApi = require("../../integrations/financialPolicy/FinancialPolicyApi");
+const Logger = require("../../common/utils/logger");
+
+/**
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * Service name: get-financialpolicy.js
+ * Lambda name: get_financialpolicy
+ * Consumer service: src/functions/financialpolicy/get-financialpolicy.handler
+ * end Point: GET /financialpolicy/{orderFormId}
+ * @returns {Promise<ApiResponse>}
+ */
+const handler = async (event) => {
+    const { orderFormId } = event.pathParameters || {};
+    const { client_id: clientId } = event.requestContext.authorizer.claims || {};
+    try {
+        const listAccounts = await ClientData.getClient(clientId);
+        const accountName = listAccounts.AccountNames.values[0] || null;
+        if (!accountName) {
+            return ApiResponse.response(400, { approved: false, message: "AccountName is Required" });
+        }
+        let configAccount = await AccountData.getAccountDataByAccountName(accountName);
+        if (!configAccount) {
+            return ApiResponse.response(400, { approved: false, message: "Account not found" });
+        }
+        if (configAccount.ParentAccountName !== configAccount.AccountName) {
+            configAccount = await AccountData.getAccountDataByAccountName(configAccount.ParentAccountName);
+        }
+        Logger.setAccount(configAccount);
+        if (!orderFormId) {
+            return ApiResponse.response(404, { approved: false, message: "orderForm is not found" });
+        }
+        try {
+            const providerApiName = configAccount?.FinancialPolicyEcu?.providerApi || 'MobilvendorApi';
+            let ApiClass;
+            try {
+                ApiClass = eval(providerApiName);
+                Logger.debug(`Provider ${providerApiName} found`);
+                Logger.debug(ApiClass);
+            } catch (evalError) {
+                Logger.warn(`Provider ${providerApiName} not found, falling back to MobilvendorApi`);
+                ApiClass = MobilvendorApi;
+            }
+            if (!ApiClass) {
+                Logger.warn('API class not found, falling back to MobilvendorApi');
+                ApiClass = MobilvendorApi;
+            }
+            const responseApi = new ApiClass(
+                configAccount.AccountName,
+                configAccount.Credentials.key,
+                configAccount.Credentials.token,
+                configAccount.AcronymClientVtex,
+                configAccount.FinancialPolicyEcu
+            );
+            const orderForm = await responseApi.getOrderFormById(orderFormId);
+            const email = orderForm?.clientProfileData?.email ?? null;
+            const responseMasterDataCT = email ? await responseApi.getClientById(email) : null;
+            const accountNameWl = responseMasterDataCT?.an ?? null;
+            if (accountNameWl) {
+                const configAccountWl = await AccountData.getAccountDataByAccountName(accountNameWl);
+                if (configAccountWl?.FinancialPolicyEcu && responseApi.setConfig) {
+                    responseApi.setConfig(configAccountWl.FinancialPolicyEcu);
+                } else if(!responseApi.setConfig){
+                    return ApiResponse.response(400, { approved: false, message: "Function setConfig not found" });
+                }else{
+                    return ApiResponse.response(400, { approved: false, message: "AccountWl not found" });
+                }
+            }
+            const responseBalance = await responseApi.getCustomerBalance(orderForm, null, responseMasterDataCT);
+            if (!responseBalance) {
+                return ApiResponse.response(404, { approved: false, message: "Client not found" });
+            }
+            return ApiResponse.response(200, {
+                withCredit: responseBalance.customerWithCredit || false,
+                maximumCreditAmount: responseBalance.maximumCreditAmount || 0,
+                paymentTerm: responseBalance.paymentTerm || 0
+            });
+        } catch (error) {
+            Logger.error('Error creating API instance:', error);
+            return ApiResponse.response(404, { approved: false, message: "Error creating API instance" });
+        }
+    } catch (error) {
+        Logger.error("Error clients producer:", error);
+        return ApiResponse.response(404, { approved: false, message: "Error clients producer" });
+    }
+};
+
+module.exports = { handler };

package/src/functions/financialpolicy/index.js

@@ -0,0 +1,28 @@
+
+const ApiResponse = require("../../common/utils/api-response");
+const financialpolicyget = require("./get-financialpolicy");
+const financialpolicyassing = require("./assign-financialpolicy");
+
+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 "/financialpolicy/{orderFormId}":
+          switch(method){
+            case "GET":
+              return await financialpolicyget?.handler(req,res);
+            case "POST":
+              return await financialpolicyassing?.handler(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!."});
+  }  
+}

package/src/functions/inventory/catalog-sync-consumer.js

@@ -0,0 +1,17 @@
+const AccountData = require("../../entities/account");
+const { handler: catalogSyncHandler } = require("./catalog-sync-handler");
+
+exports.processCatalogSync = async (accountName, actionProcess, values) => {
+    const accountConfig = await AccountData.getAccountDataByAccountName(accountName);
+    if (!accountConfig) {
+        throw new Error("Account configuration not found");
+    }
+
+    if (actionProcess === 'catalog-sync') {
+        await catalogSyncHandler({
+            source: 'cron',
+            pathParameters: { accountName },
+            ...values
+        });
+    }
+};

package/src/functions/inventory/catalog-sync-handler.js

@@ -0,0 +1,311 @@
+const ApiResponse = require("../../common/utils/api-response");
+const AWSServices = require("../../common/utils/aws-services");
+const AccountData = require("../../entities/account");
+const Logger = require("../../common/utils/logger");
+const axios = require('axios');
+const GeneralRequiredError = require("../../common/validation/GeneralErrorValidation.js");
+
+const INVENTORY_SKU_DATA_TABLE = process.env.INVENTORY_SKU_DATA_TABLE;
+const SQS_AFFILIATE_HOOK_QUEUE_URL = process.env.SQS_AFFILIATE_HOOK_QUEUE_URL;
+
+async function handler(event) {
+  let accountName;
+  if (event.source === 'cron') {
+      accountName = event.accountName;
+    } 
+    // Manejo para llamada HTTP
+    else {
+      accountName = event.pathParameters?.accountName;
+      if (!accountName) {
+        return ApiResponse.response(400, { error: "accountName is required in URL path" });
+      }
+    }
+
+  try {
+    if (!accountName) {
+      return ApiResponse.response(400, { error: "accountName is required in URL path" });
+    }
+
+    const account = await AccountData.getAccountDataByAccountName(accountName);
+    if (!account) {
+      return ApiResponse.response(404, { error: `Account ${accountName} not found` });
+    }
+
+    Logger.setAccount(account);
+    const result = await syncCatalogForAccount(account);
+    return ApiResponse.response(200, { 
+      message: "Catalog synchronization completed successfully",
+      stats: result.stats
+    });
+  } catch (error) {
+    Logger.error("Catalog sync failed", { 
+      error: error.message, 
+      stack: error.stack,
+      accountName: event.pathParameters?.accountName 
+    });
+    return ApiResponse.response(500, { error: error.message });
+  }
+}
+
+async function syncCatalogForAccount(account) {
+  Logger.info(`Starting catalog synchronization for account: ${account.AccountName}`);
+  
+  try {
+    const authToken = await authenticateWithVtex(account);
+    Logger.info("VTEX authentication successful");
+    
+    const [vtexCatalog, dynamoCatalog] = await Promise.all([
+      getVtexCatalog(account, authToken),
+      getDynamoCatalog(account)
+    ]);
+    
+    Logger.info(`Data retrieved: ${vtexCatalog.length} items from VTEX, ${dynamoCatalog.length} items from DynamoDB`);
+    
+    return await syncCatalogs(account, vtexCatalog, dynamoCatalog);
+  } catch (error) {
+    Logger.error(`Catalog synchronization failed: ${error.message}`);
+    throw error;
+  }
+}
+
+async function authenticateWithVtex(account) {
+  const { key, token } = account.Credentials || {};
+  if (!key || !token) {
+    throw new GeneralRequiredError("Missing VTEX credentials");
+  }
+
+  try {
+    const response = await axios({
+      method: 'post',
+      url: `https://api.vtexcommercestable.com.br/api/vtexid/apptoken/login?an=${account.AccountName}`,
+      headers: {
+        'X-VTEX-API-AppKey': key,
+        'X-VTEX-API-AppToken': token,
+        'Content-Type': 'application/json'
+      },
+      data: {
+        appkey: key,
+        apptoken: token
+      },
+      timeout: 10000
+    });
+    
+    if (response.data?.authStatus !== "Success") {
+      throw new Error(`VTEX authentication failed: ${response.data?.authStatus || 'Invalid response'}`);
+    }
+    
+    return response.data.token;
+  } catch (error) {
+    Logger.error(`VTEX authentication error: ${error.message}`);
+    throw new Error(`VTEX authentication failed: ${error.message}`);
+  }
+}
+
+async function getVtexCatalog(account, authToken) {
+  const BASE_URL = `https://${account.AccountName}.vtexcommercestable.com.br`;
+
+  Logger.info(`Fetching VTEX catalog for account ${account.AccountName}`);
+
+  try {
+    const data = `Filters[SkuId]=&Filters[IsVisible]=&Filters[ProductName]=&Filters[BrandId]=&Filters[CategoryIds]=&Filters[StoreId]=0&Filters[IsActive]=true&Filters[SellerId]=&Fields[]=StockKeepingUnitId&Fields[]=StockKeepingUnitName&Fields[]=ActivateSkuIfPossible&Fields[]=StockKeepingUnitIsActive&Fields[]=StockKeepingUnitEan&Fields[]=ReferenceStockKeepingUnitId&Fields[]=RewardValue&Fields[]=ProductId&Fields[]=ProductName&Fields[]=ProductDescriptionShort&Fields[]=ProductIsActive&Fields[]=DepartmentId&Fields[]=CategoryId&Fields[]=CategoryName&Fields[]=BrandId&Fields[]=BrandName&Fields[]=DepartmentName&Fields[]=Height&Fields[]=Width&Fields[]=Length&Fields[]=WeightKg&Fields[]=RealHeight&Fields[]=RealWidth&Fields[]=RealLength&Fields[]=RealWeight&Fields[]=CubicWeight&Fields[]=MeasurementUnit&Fields[]=UnitMultiplier&Fields[]=StockKeepingUnitIsKit&Fields[]=EstimatedDateArrival&Fields[]=ManufacturerCode&Fields[]=ProductRefId&Fields[]=CommercialCondition&Fields[]=ProductIsVisible&Fields[]=ProductDescription&Fields[]=ProductLinkId&Fields[]=ProductReleaseDate&Fields[]=ProductKeyWords&Fields[]=ProductTitle&Fields[]=ProductMetaTagDescription&Fields[]=ProductSupplierId&Fields[]=ProductShowWithoutStock&Fields[]=Stores&Fields[]=Accessories&Fields[]=Similar&Fields[]=Suggestions&Fields[]=Attachments&Fields[]=ShowTogether&Rows=2000`;
+    
+    const headers = {
+      'accept': 'application/json',
+      'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
+      'cookie': `VtexIdclientAutCookie=${authToken}`
+    };
+    
+    const axiosConfig = {
+      method: 'post',
+      url: `${BASE_URL}/admin/API/StockKeepingUnitReport/LoadContent/`,
+      headers: headers,
+      data: data,
+      timeout: 30000
+    };
+    
+    const response = await axios(axiosConfig);
+    
+    if (!response.data) {
+      throw new Error('Empty response received from VTEX API');
+    }
+    
+    if (!response.data.Data && response.data.data) {
+      Logger.warn("Data field found with lowercase 'd' instead of uppercase 'D'");
+      response.data.Data = response.data.data;
+    }
+    
+    if (!Array.isArray(response.data.Data)) {
+      throw new Error(`Expected Data to be an array, got ${typeof response.data.Data}: ${JSON.stringify(response.data).substring(0, 500)}`);
+    }
+    
+    const items = response.data.Data;
+    Logger.info(`Retrieved ${items.length} items from VTEX catalog`);
+    
+    return items;
+  } catch (error) {
+    const errorInfo = {
+      message: error.message,
+      stack: error.stack,
+      code: error.code,
+      name: error.name
+    };
+    
+    if (error.response) {
+      errorInfo.responseStatus = error.response.status;
+      errorInfo.responseStatusText = error.response.statusText;
+      errorInfo.responseHeaders = error.response.headers;
+      errorInfo.responseData = error.response.data 
+        ? (typeof error.response.data === 'string' 
+           ? error.response.data.substring(0, 1000) 
+           : JSON.stringify(error.response.data).substring(0, 1000)) 
+        : null;
+    }
+    
+    Logger.error(`Failed to fetch VTEX catalog:`, errorInfo);
+    throw new Error(`Failed to fetch VTEX catalog: ${error.message}`);
+  }
+}
+
+async function getDynamoCatalog(account) {
+  Logger.info("Fetching catalog data from DynamoDB");
+
+  try {
+    let allItems = [];
+    let lastEvaluatedKey = null;
+    
+    do {
+      const params = {
+        TableName: INVENTORY_SKU_DATA_TABLE,
+        FilterExpression: "ParentAccountName = :accountName",
+        ExpressionAttributeValues: {
+          ":accountName": { S: account.AccountName }
+        },
+        ExclusiveStartKey: lastEvaluatedKey
+      };
+      
+      const result = await AWSServices.dynamoScan(params);
+      
+      const items = (result.Items || []).map(item => AWSServices.unmarshall(item));
+      allItems = allItems.concat(items);
+      
+      lastEvaluatedKey = result.LastEvaluatedKey;
+      
+      Logger.debug(`Retrieved ${items.length} items from DynamoDB, total so far: ${allItems.length}`);
+    } while (lastEvaluatedKey);
+    
+    Logger.info(`Retrieved ${allItems.length} total items from DynamoDB`);
+    return allItems;
+  } catch (error) {
+    Logger.error(`Error fetching DynamoDB catalog: ${error.message}`);
+    throw new Error(`Failed to fetch DynamoDB catalog: ${error.message}`);
+  }
+}
+
+async function sendToAffiliateHookQueue(accountName, skuId) {
+  try {
+    const messageBody = {
+      IdSku: skuId,
+      An: accountName
+    };
+    
+    await AWSServices.sendSQSMessage(SQS_AFFILIATE_HOOK_QUEUE_URL, messageBody);
+    return true;
+  } catch (error) {
+    Logger.error(`Error sending SKU ${skuId} to affiliate hook queue:`, error);
+    return false;
+  }
+}
+
+async function syncCatalogs(account, vtexCatalog, dynamoCatalog) {
+  Logger.info("Starting catalog comparison and synchronization");
+  
+  try {
+    const vtexMap = new Map();
+    vtexCatalog.forEach(item => {
+      if (item.StockKeepingUnitId) {
+        vtexMap.set(item.StockKeepingUnitId.toString(), item);
+      }
+    });
+    
+    const dynamoMap = new Map();
+    dynamoCatalog.forEach(item => {
+      const skuId = item.SkuId || item.Sku || 
+                   (item.AccountNameAndSku && item.AccountNameAndSku.replace(account.AccountName, ''));
+      if (skuId) {
+        dynamoMap.set(skuId.toString(), item);
+      }
+    });
+    
+    const itemsToDelete = [];
+    dynamoMap.forEach((dynamoItem, skuId) => {
+      if (!vtexMap.has(skuId)) {
+        itemsToDelete.push({
+          AccountNameAndSku: dynamoItem.AccountNameAndSku,
+          ParentAccountName: account.AccountName
+        });
+      }
+    });
+    
+    let itemsSentToQueue = 0;
+    for (const [skuId, vtexItem] of vtexMap.entries()) {
+      await sendToAffiliateHookQueue(account.AccountName, skuId);
+      itemsSentToQueue++;
+      
+      if (itemsSentToQueue % 50 === 0) {
+        Logger.info(`Progress: ${itemsSentToQueue}/${vtexMap.size} items sent to queue`);
+      }
+    }
+    
+    Logger.info(`Synchronization analysis complete: ${itemsToDelete.length} items to delete, ${itemsSentToQueue} items sent to queue`);
+    
+    if (itemsToDelete.length > 0) {
+      Logger.info(`Deleting ${itemsToDelete.length} items from DynamoDB`);
+      await batchDeleteItems(itemsToDelete);
+    }
+    
+    const stats = {
+      vtexItems: vtexCatalog.length,
+      dynamoItemsBefore: dynamoCatalog.length,
+      itemsDeleted: itemsToDelete.length,
+      itemsSentToQueue: itemsSentToQueue,
+    };
+    
+    Logger.info("Catalog synchronization completed successfully", stats);
+    return { stats };
+  } catch (error) {
+    Logger.error(`Error synchronizing catalogs: ${error.message}`);
+    throw new Error(`Failed to synchronize catalogs: ${error.message}`);
+  }
+}
+
+async function batchDeleteItems(items) {
+  const BATCH_SIZE = 25;
+  const batches = Math.ceil(items.length / BATCH_SIZE);
+  
+  Logger.info(`Starting batch delete operation: ${items.length} items in ${batches} batches`);
+  
+  for (let i = 0; i < batches; i++) {
+    const batchItems = items.slice(i * BATCH_SIZE, (i + 1) * BATCH_SIZE);
+    
+    const requestItems = {};
+    requestItems[INVENTORY_SKU_DATA_TABLE] = batchItems.map(item => ({
+      DeleteRequest: {
+        Key: AWSServices.marshall({
+          AccountNameAndSku: item.AccountNameAndSku,
+          ParentAccountName: item.ParentAccountName
+        })
+      }
+    }));
+    
+    try {
+      await AWSServices.dynamoBatchWrite({ RequestItems: requestItems });
+      Logger.debug(`Completed delete batch ${i + 1}/${batches}`);
+    } catch (error) {
+      Logger.error(`Error in delete batch ${i + 1}/${batches}: ${error.message}`);
+    }
+  }
+  
+  Logger.info('Batch delete operation completed');
+}
+
+module.exports = { handler };

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

@@ -0,0 +1,119 @@
+const VtexApi = require("../../vtex/clients/VtexApi");
+const AWSServices = require("../../common/utils/aws-services");
+const ControlStock = require("../../entities/controlstock");
+const SkuData = require("../../entities/sku");
+const convertQuantity = require("../../common/utils/product-unit-converter");
+const Logger = require("../../common/utils/logger");
+
+const SQS_INVENTORY_DQL_QUEUE_URL = process.env.SQS_INVENTORY_DQL_QUEUE_URL;
+const SQS_INVENTORY_QUEUE_URL = process.env.SQS_INVENTORY_QUEUE_URL;
+const MAX_ATTEMPS = process.env.MAX_ATTEMPS || 3;
+
+const consumer = async (event) => {
+  for (const record of event.Records) {
+    let { an, key, token, warehouse, sku, skuRefId, quantity, hoursValidStockPrice, ValidateSkuPriceInventoryInProcess, ParentAccountName, SkuRefUsed, accountConfig, individualUnits } = JSON.parse(record.body);
+    try {
+
+      // obtener sku vtex
+      if(ValidateSkuPriceInventoryInProcess===true){
+        try{
+          sku= await SkuData.getSkuVtex({account: ParentAccountName, sku: sku, SkuRefUsed: SkuRefUsed});
+        } catch(esku){
+          Logger.error('Error get sku vtex.', esku);
+          try{
+          await SkuData.saveLogProductsNotFount({an:an, key:key, token: token, entity:"logstocknotfound", sku:sku, value: JSON.stringify({warehouse:warehouse, sku:sku, quantity:quantity })});
+        }catch(e){
+          Logger.error('error save log price', e);
+        }
+          return false;
+        }
+      }
+
+      quantity = await getQuantity(sku, skuRefId, quantity, accountConfig, individualUnits);
+
+      // Validacion valores ya informados
+      const validStockInternal= await ControlStock.validNotificationStockVtex({
+        skuId: sku,
+        account: an,
+        warehouse: warehouse,
+        hoursUpdate: hoursValidStockPrice ?? 24,
+        quantity: quantity
+      });
+
+      if(validStockInternal === false){
+        Logger.debug('inventario ya informado. No se notifica a VTEX. ', {sku, warehouse, quantity});
+        return false;
+      }
+      // fin validacion valores informados
+
+      const vtexApi = new VtexApi(an, key, token);
+      const response = await vtexApi.fetch(`/logistics/pvt/inventory/skus/${sku}/warehouses/${warehouse}`, {
+        method: "PUT",
+        data: {
+          quantity: quantity,
+        },
+      });
+      if (response.status >= 200 && response.status < 300) {
+        Logger.debug("Inventory updated successfully.");
+      } else {
+        const attemps = JSON.parse(record.body)?.attemps || 0;
+        Logger.error(
+          "Error updating inventory. Status: ",
+          response.status,
+          ". Message: ",
+          response?.data?.message,
+          " - Try: ",
+          attemps
+        );
+        if (attemps < MAX_ATTEMPS) {
+          await AWSServices.sendSQSMessage(
+            SQS_INVENTORY_QUEUE_URL,
+            JSON.stringify({
+              an,
+              key,
+              token,
+              warehouse,
+              sku,
+              quantity,
+              attemps: attemps + 1,
+            })
+          );
+        } else {
+          throw new Error("Max attemps reached.");
+        }
+      }
+    } catch (error) {
+      Logger.error(error);
+      try {
+        await AWSServices.sendSQSMessage(
+          SQS_INVENTORY_DQL_QUEUE_URL,
+          JSON.stringify({
+            body: record.body,
+            error: error?.message,
+          })
+        );
+      } catch (error) {
+        Logger.error("Sending message to DQL Queue: ", error);
+      }
+    }
+  }
+};
+
+const getQuantity = async (skuVtex, skuRefId, quantity, accountConfig, individualUnits) => {
+  try {
+    if(accountConfig?.ProductUnitConversion?.isActive) {
+      quantity = await convertQuantity(skuVtex, skuRefId, quantity, accountConfig, individualUnits);
+    }
+  } catch (conversionError) {
+    Logger.error('ProductUnitConversion: Error en conversión, usando cantidad original', {
+      skuRefId,
+      originalQuantity: quantity,
+      error: conversionError.message
+    });
+  }
+  return quantity;
+}
+
+module.exports = {
+  consumer,
+};