dcos-core-monalisav2-latam 1.1.3 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcos-core-monalisav2-latam",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },

package/src/functions/clients/clients-suggested-product-consumer.js

@@ -3,107 +3,6 @@ const VtexApi = require("../../vtex/clients/VtexApi");
 
 const DATA_ENTITY_CLIENT_ACRONYM = process.env.DATA_ENTITY_CLIENT_ACRONYM || 'CT';
 
-const buildProductJson = (sku, status, quantity, type, priority) => ({
-  refId: sku.sku,
-  status,
-  quantity: quantity || sku.quantity,
-  type,
-  priority: priority || sku.priority
-});
-
-const getClientUserId = async (vtexApi, pdv, an) => {
-  try {
-    const clientId = pdv;
-    const searchResult = await vtexApi.fetch(`/dataentities/${DATA_ENTITY_CLIENT_ACRONYM}/search?_fields=_all&id=${clientId}`, {});
-    if (searchResult?.status === 200 && searchResult.data?.length > 0) {
-      return searchResult.data[0]?.id;
-    }
-    return null;
-  } catch (error) {
-    Logger.error("Error getting client userId", error);
-    return null;
-  }
-};
-
-const getCatalogProductStatus = async (vtexApi, skuId) => {
-  try {
-    const skuData = await vtexApi.fetch(`/catalog_system/pvt/sku/stockkeepingunitbyid/${skuId}`, {});
-
-    if (skuData?.status === 200 && skuData.data) {
-      const { IsActive, ProductId } = skuData.data;
-
-      if (!IsActive) return 'inactive';
-
-      const productData = await vtexApi.fetch(`/catalog_system/pvt/products/productget/${ProductId}`, {
-        validateStatus: () => true
-      });
-
-      if (productData?.status === 200 && productData.data) {
-        const { IsVisible, IsActive: productActive } = productData.data;
-
-        if (!productActive) return 'inactive';
-        if (!IsVisible) return 'not_visible';
-        return 'active';
-      }
-    }
-
-    return 'invalid';
-  } catch (error) {
-    Logger.error("Error getting catalog product status", error);
-    return 'invalid';
-  }
-};
-
-const saveSuggestedProducts = async (vtexApi, userId, productsData, an, entityProductSuggested) => {
-  try {
-    const orderDate = new Date().toISOString();
-    const data = {
-      id: `${userId}_${Date.now()}`,
-      userId,
-      orderDate,
-      type: 'suggested',
-      productsRegular: productsData?.regular,
-      productsIncremental: productsData?.incremental,
-      an
-    };
-
-    await vtexApi.fetch(`/dataentities/${entityProductSuggested}/documents`, {
-      method: 'POST',
-      data,
-      headers: {
-        'authorization': 'Basic Og=='
-      }
-    });
-
-    Logger.log("Suggested products saved successfully", { userId, orderDate });
-  } catch (error) {
-    Logger.error("Error saving suggested products", error);
-  }
-};
-
-const saveOriginalDataToClient = async (vtexApi, pdv, originalData, an) => {
-  try {
-    const clientId = `${pdv}${an}dist1`;
-    const updateData = {
-      productsRegular: originalData.productsRegular || [],
-      productsIncremental: originalData.productsIncremental || [],
-      lastSuggestedProductsUpdate: new Date().toISOString()
-    };
-
-    await vtexApi.fetch(`/dataentities/${DATA_ENTITY_CLIENT_ACRONYM}/documents/${clientId}`, {
-      method: 'PUT',
-      data: updateData,
-      headers: {
-        'authorization': 'Basic Og=='
-      }
-    });
-
-    Logger.log("Original data saved to client", { pdv });
-  } catch (error) {
-    Logger.error("Error saving original data to client", error);
-  }
-};
-
 const consumer = async (event) => {
   try {
     const records = event.Records || [];
@@ -115,45 +14,46 @@ const consumer = async (event) => {
         parentAccount,
         key,
         token,
-        pdv,
-        productsRegular,
-        productsIncremental,
-        originalData,
-        nameEntityProductSuggested
+        suggestedProductEntityName,
+        Startemail,
+        Domainemail,
+        ...client
       } = messageBody;
 
-      Logger.log("Processing suggested products for client", { pdv, an });
-
+      // Referencia a la API de VTEX sobre el marketplace asociado
       const vtexApi = new VtexApi(parentAccount, key, token);
 
-      const userId = await getClientUserId(vtexApi, pdv, an);
-      console.log("Fetched userId:", userId);
-      if (!userId) {
-        Logger.error("Client userId not found", { pdv, an });
-        continue;
-      }
-
-      const regularProducts = [];
-      const incrementalProducts = [];
-
-      for (const sku of productsRegular) {
-        const status = await getCatalogProductStatus(vtexApi, sku.sku);
-        regularProducts.push(buildProductJson(sku, status, sku.quantity, 'regular', sku.priority));
-      }
+      const { clientId, productsRegular, productsIncremental } = client;
 
-      for (const sku of productsIncremental) {
-        const status = await getCatalogProductStatus(vtexApi, sku.sku);
-        incrementalProducts.push(buildProductJson(sku, status, sku.quantity, 'incremental', sku.priority));
-      }
-
-      await saveSuggestedProducts(vtexApi, userId, {
-        regular: regularProducts,
-        incremental: incrementalProducts
-      }, an, nameEntityProductSuggested);
+      // Objeto de datos para el producto sugerido
+      const suggestedProductData = {
+        orderDate: new Date().toISOString(),
+        clientId,
+        type: 'SUGGESTED_ORDER',
+        productsRegular,
+        productsIncremental,
+      };
+      const email = `${Startemail}+${clientId}@${Domainemail}`;
+      // Consulta del userProfileId
+      await findUserProfileId(vtexApi, email, suggestedProductData);
+
+      // Insertar datos en entidad de Productos Sugeridos
+      await vtexApi.fetch(`/dataentities/${suggestedProductEntityName}/documents`, {
+        method: 'PATCH',
+        data: suggestedProductData
+      });
 
-      await saveOriginalDataToClient(vtexApi, pdv, originalData, an);
+      // Insertar datos en Clientes Totales
+      await vtexApi.fetch(`/dataentities/${DATA_ENTITY_CLIENT_ACRONYM}/documents`, {
+        method: 'PATCH',
+        data: {
+          id: clientId,
+          productsRegular: JSON.stringify(productsRegular),
+          productsIncremental: JSON.stringify(productsIncremental),
+        }
+      });
 
-      Logger.log("Suggested products processed successfully", { pdv, userId });
+      Logger.log("Suggested products processed successfully", { an, clientId });
     }
   } catch (error) {
     Logger.error("Error in suggested products consumer", error);
@@ -161,6 +61,22 @@ const consumer = async (event) => {
   }
 };
 
-module.exports = {
-  consumer
-};
+/**
+ * Consulta el userProfile del usuario con base al email.
+ * @param {*} vtexApi Instancia de conexión a la API de VTEX.
+ * @param {String} email Correo electrónico del usuario
+ * @param {Object} suggestedProductData Objeto donde se consolida la información de producto sugerido.
+ * @throws Si la consulta del profile genera un error, o el userProfile no está correcto.
+ */
+async function findUserProfileId(vtexApi, email, suggestedProductData) {
+  const searchResult = await vtexApi.fetch(`/checkout/pub/profiles?email=${encodeURIComponent(email)}`, {});
+  if (searchResult?.status == 200) {
+    const { userProfileId, isComplete } = searchResult.data;
+    if (!(userProfileId && isComplete)) {
+      throw new Error(`User with id ${email} is not valid`);
+    }
+    suggestedProductData.id = userProfileId;
+  }
+}
+
+module.exports = { consumer };

package/src/functions/clients/helpers/suggested-product-mdlz.js

@@ -2,232 +2,276 @@ const AWSServices = require("../../../common/utils/aws-services");
 const ApiResponse = require("../../../common/utils/api-response");
 const Logger = require("../../../common/utils/logger");
 const AccountData = require("../../../entities/account");
+const SkuData = require("../../../entities/sku");
 const VtexApi = require("../../../vtex/clients/VtexApi");
 
-const SQS_CLIENT_PRODUCT_QUEUE_URL = process.env.SQS_CLIENT_PRODUCT_QUEUE_URL;
-const DEFAULT_MIN_PRODUCTS_COUNT = process.env.MIN_PRODUCTS_COUNT || 5;
+const {
+  SQS_CLIENT_PRODUCT_QUEUE_URL,
+  MIN_PRODUCTS_COUNT = 5
+} = process.env;
 
-const validateBody = (event, minProductsCount = DEFAULT_MIN_PRODUCTS_COUNT) => {
-  if (!event.body) {
-    return { valid: false, error: ApiResponse.response(400, "Body is required") };
-  }
-
-  const body = JSON.parse(event.body);
-  const { an, clients } = body;
-
-  if (!an || typeof an !== 'string') {
-    return { valid: false, error: ApiResponse.response(400, "Field 'an' is required and must be a string") };
-  }
-
-  if (!clients || !Array.isArray(clients) || clients.length === 0) {
-    return { valid: false, error: ApiResponse.response(400, "Field 'clients' is required and must be a non-empty array") };
-  }
+const suggestedProductMdlz = async (event) => {
+  try {
+    const { an, clients } = JSON.parse(event.body);
+    // return ApiResponse.response(200, { an, clients });
 
-  for (const client of clients) {
-    if (!Array.isArray(client.productsRegular)) {
-      return { valid: false, error: ApiResponse.response(400, "Field 'productsRegular' must be an array") };
+    const account = await AccountData.getAccountDataByAccountName(an);
+    if (!account) {
+      return ApiResponse.response(404, "Account not found");
     }
-    if (!Array.isArray(client.productsIncremental)) {
-      return { valid: false, error: ApiResponse.response(400, "Field 'productsIncremental' must be an array") };
+
+    // Se extraen las propiedades del account requeridas
+    const {
+      Credentials, ProductSuggestedConfig = {},
+      IndexClientRegister,
+      Startemail,
+      Domainemail
+    } = account;
+    if (!Credentials?.key || !Credentials?.token) {
+      return ApiResponse.response(400, "VTEX credentials not configured for account");
     }
-    if (client.productsRegular.length < minProductsCount) {
-      return { valid: false, error: ApiResponse.response(400, `Field 'productsRegular' must have at least ${minProductsCount} elements`) };
+    if (!IndexClientRegister?.length) {
+      return ApiResponse.response(400, "IndexClientRegister not configured for account");
     }
-    if (client.productsIncremental.length < minProductsCount) {
-      return { valid: false, error: ApiResponse.response(400, `Field 'productsIncremental' must have at least ${minProductsCount} elements`) };
+    // Se valida que exista el índice 'an'
+    if (!IndexClientRegister.includes('an')) {
+      return ApiResponse.response(400, "IndexClientRegister must have a 'an' property");
     }
-  }
-
-  return { valid: true, data: body };
-};
-
-const validateSkusInVtex = async (skus, vtexApi) => {
-  if (!skus || skus.length === 0) {
-    Logger.info("No SKUs to validate");
-    return { validSkus: [], invalidSkus: [] };
-  }
-
-  try {
-    const skuIds = skus.map(s => s.sku);
-    Logger.info(`Requesting VTEX validation for SKUs: [${skuIds.join(', ')}]`);
 
-    const vtexSkus = await vtexApi.getDetailSkuById(skuIds);
-    Logger.info(`VTEX API returned ${Array.isArray(vtexSkus) ? vtexSkus.length : 'invalid'} results`);
+    // Se obtiene las propiedades de la configuración de ProductSuggestedConfig
+    const {
+      minProductsCount = MIN_PRODUCTS_COUNT,
+      entityName: suggestedProductEntityName = 'suggestedProducts'
+    } = ProductSuggestedConfig;
 
-    const validSkus = [];
-    const invalidSkus = [];
-
-    if (!vtexSkus || !Array.isArray(vtexSkus)) {
-      Logger.warn("VTEX API returned invalid response");
-      return { validSkus: [], invalidSkus: skus };
+    // Se agrupan los ítems de cada una de las listas por el "sku", de modo que no se tengan items con duplicados.
+    const skusList = {};
+    for (const client of clients) {
+      removeDuplicatesSku(client.productsRegular, skusList);
+      removeDuplicatesSku(client.productsIncremental, skusList);
     }
 
-    skus.forEach(sku => {
-      const found = vtexSkus.find(v => String(sku?.sku) === String(v?.Id));
-      if (found && found.IsActive !== false) {
-        validSkus.push(sku);
-      } else {
-        invalidSkus.push(sku);
-      }
-    });
+    // Se consulta la información de cada uno de los SKU's
+    await getSkuData(skusList, account);
 
-    Logger.info(`Validation completed: ${validSkus.length} valid, ${invalidSkus.length} invalid`);
-    return { validSkus, invalidSkus };
-  } catch (error) {
-    return { validSkus: [], invalidSkus: skus };
-  }
-};
-
-const processClient = async (client, vtexApi, accountName, account) => {
-  try {
-    const { pdv, productsRegular = [], productsIncremental = [] } = client;
-
-    const suggestedConfig = account?.ProductSuggestedConfig
-    const entityName = suggestedConfig?.entityName || 'suggestedProducts';
-    const minProductsCount = suggestedConfig?.minProductsCount || DEFAULT_MIN_PRODUCTS_COUNT;
-
-    const regularValidation = await validateSkusInVtex(productsRegular, vtexApi);
-    const incrementalValidation = await validateSkusInVtex(productsIncremental, vtexApi);
-
-    const hasMinimumValid = regularValidation.validSkus.length >= minProductsCount &&
-      incrementalValidation.validSkus.length >= minProductsCount;
-
-    if (!hasMinimumValid) {
-      return {
-        pdv,
-        success: false,
-        error: `Minimum ${minProductsCount} valid SKUs required`,
-        regularValid: regularValidation.validSkus.length,
-        incrementalValid: incrementalValidation.validSkus.length,
-        originalData: client
-      };
+    // Se valida la información de cada uno de los registros de "clients"
+    const validBody = validateClientsData(clients, minProductsCount, IndexClientRegister, an, skusList);
+    if (!validBody.success) {
+      return ApiResponse.response(207, validBody.data);
     }
 
-    const dataSend = {
-      an: accountName,
-      parentAccount: account?.ParentAccountName,
-      key: account?.Credentials?.key,
-      token: account?.Credentials?.token,
-      pdv,
-      productsRegular: regularValidation.validSkus,
-      productsIncremental: incrementalValidation.validSkus,
-      invalidSkusRegular: regularValidation.invalidSkus,
-      invalidSkusIncremental: incrementalValidation.invalidSkus,
-      originalData: client,
-      nameEntityProductSuggested: entityName
-    };
-
-    if (SQS_CLIENT_PRODUCT_QUEUE_URL) {
-      try {
-        await AWSServices.sendSQSMessage(SQS_CLIENT_PRODUCT_QUEUE_URL, dataSend);
-        Logger.info(`Message sent to SQS for client ${pdv}`);
-      } catch (sqsError) {
-        Logger.error(`Failed to send SQS message for client ${pdv}`, {
-          error: sqsError.message
+    do {
+      // Se extrae las primeras filas de la lista para ejecutar las Promises
+      let dataToProcess = clients.splice(0, 10);
+      await Promise.allSettled(dataToProcess.map(client => {
+        return new Promise((resolve, reject) => {
+          const sqsData = {
+            ...client,
+            an,
+            parentAccount: account?.ParentAccountName,
+            key: account?.Credentials?.key,
+            token: account?.Credentials?.token,
+            suggestedProductEntityName,
+            Startemail,
+            Domainemail
+          }
+          AWSServices.sendMessageToSqs(SQS_CLIENT_PRODUCT_QUEUE_URL, sqsData).then(resolve).catch(reject);
         });
-      }
-    } else {
-      Logger.warn(`SQS URL not configured`);
-    }
-
-    return {
-      pdv,
-      success: true,
-      validRegular: regularValidation.validSkus.length,
-      validIncremental: incrementalValidation.validSkus.length,
-      invalidRegular: regularValidation.invalidSkus.length,
-      invalidIncremental: incrementalValidation.invalidSkus.length,
-      warnings: regularValidation.invalidSkus.length > 0 || incrementalValidation.invalidSkus.length > 0
-        ? "Some SKUs were excluded as they don't exist in VTEX" : null
-    };
+      })).catch(Logger.error);
+    } while (clients.length);
 
+    return ApiResponse.response(200, { message: 'Message accepted!' });
   } catch (error) {
-    Logger.error(`Critical error in processClient for PDV: ${client?.pdv}`, {
+    Logger.error("Critical error in suggestedProductMdlz", {
       error: error.message,
-      stack: error.stack,
-      pdv: client?.pdv
+      stack: error.stack
     });
-    throw error;
+    return ApiResponse.response(500, "Internal server error");
   }
 };
 
-const suggestedProductMdlz = async (event) => {
-  try {
-    const { an, clients } = JSON.parse(event.body);
+/**
+ * Valida la información de la lista de clientes
+ * @param {Object[]} clients Lista de clientes
+ * @param {Number} minProductsCount Cantidad mínima requerida para el producto sugerido.
+ * @param {String[]} indexClientRegister Lista de índices para el Id del cliente.
+ * @param {Object} skusList Objeto donde se consolida la lista de SKU´s.
+ * @returns 
+ */
+function validateClientsData(clients, minProductsCount, indexClientRegister, an, skusList) {
+  const response = { success: true }, notProcessedItems = [];
 
-    const account = await AccountData.getAccountDataByAccountName(an);
-    if (!account) {
-      return ApiResponse.response(404, "Account not found");
+  for (const client of clients) {
+    let remain = [], clientId = '';
+    for (let prop of indexClientRegister) {
+      if (prop == 'an') {
+        clientId += an;
+      } else {
+        if (client.hasOwnProperty(prop)) {
+          clientId += client[prop] ?? '';
+        } else {
+          remain.push(prop);
+        }
+      }
     }
-
-    if (!account?.Credentials?.key || !account?.Credentials?.token) {
-      return ApiResponse.response(400, "VTEX credentials not configured for account");
+    if (remain.length) {
+      client.error = `The properties ${remain.join(',')} are required`;
+      notProcessedItems.push(client);
+      continue;
     }
 
-    const suggestedConfig = account?.ProductSuggestedConfig;
-    const minProductsCount = suggestedConfig?.minProductsCount || DEFAULT_MIN_PRODUCTS_COUNT;
+    // Se valida si las propiedades existen en cada cliente
+    if (!client?.productsRegular || !client?.productsIncremental) {
+      client.error = `Validate the following properties productsRegular and productsIncremental are required`;
+      notProcessedItems.push(client);
+      continue;
+    }
 
-    const validation = validateBody(event, minProductsCount);
-    if (!validation.valid) {
-      return validation.error;
+    // Se valida si la longitud de alguno de los ítems del cliente es menos al número mínimo de productos
+    if (client.productsRegular?.length < minProductsCount || client.productsIncremental?.length < minProductsCount) {
+      client.error = `Validate the following properties productsRegular and productsIncremental minimum ${minProductsCount} elements`;
+      notProcessedItems.push(client);
+      continue;
     }
 
-    const vtexApi = new VtexApi(
-      account.AccountName,
-      account.Credentials.key,
-      account.Credentials.token
-    );
+    client.clientId = clientId;
+    setItemInformation(client.productsRegular, 'REGULAR', skusList);
+    setItemInformation(client.productsIncremental, 'INCREMENTAL', skusList);
+  }
 
-    const results = [];
-    const failedClients = [];
+  // Si hay ítems no procesados, se retorna el mensaje de error
+  if (notProcessedItems.length) {
+    response.success = false;
+    response.data = {
+      message: 'Not all items were processed.',
+      notProcessedItems
+    };
+  }
 
-    for (const client of clients) {
-      try {
-        const result = await processClient(client, vtexApi, an, account);
-        if (result.success) {
-          results.push(result);
-        } else {
-          failedClients.push(result);
-        }
-      } catch (error) {
-        Logger.error("Error processing client", {
-          pdv: client.pdv,
-          error: error.message,
-          stack: error.stack
-        });
-        failedClients.push({
-          pdv: client.pdv,
-          success: false,
-          error: "Internal processing error",
-          originalData: client
-        });
+  return response;
+}
+
+/**
+ * Consulta la información de los SKU definidos en la petición.
+ * @param {*} skusList Lista de SKU's.
+ * @param {*} account Información del account sobre el cual se realiza la consulta.
+ */
+async function getSkuData(skusList, account) {
+  let skuRefUsed = account?.SkuRefUsed;
+  if (typeof skuRefUsed !== "boolean") {
+    skuRefUsed = true;
+  }
+
+  // Instancia para consumo de la API de VTEX
+  const vtexApi = new VtexApi(
+    account.AccountName,
+    account.Credentials.key,
+    account.Credentials.token
+  );
+
+  const items = Object.keys(skusList);
+  do {
+    // Se extrae las primeras filas de la lista para ejecutar las Promises
+    let rowsData = items.splice(0, 10);
+    await Promise.allSettled(rowsData.map(sku => {
+      return new Promise((resolve, reject) => {
+        // Se consulta el SKU en MonalisaV2
+        getSkuInformation(sku, account, skuRefUsed).then(skuId => {
+          // Se consulta en VTEX información del producto
+          skusList[sku].SkuId = skuId;
+          vtexApi.getDetailSkuById([skuId]).then(res => {
+            const { IsActive, ProductIsVisible } = res[0];
+            skusList[sku].IsActive = IsActive;
+            skusList[sku].ProductIsVisible = ProductIsVisible;
+            resolve(sku);
+          }).catch(reject);
+        }).catch(reject);
+      });
+    })).catch(Logger.error);
+  } while (items.length);
+}
+
+/**
+ * Consulta de información del sku en MonalisaV2.
+ * @param {String} sku SKU del producto.
+ * @param {Object} account Información del account en MonalisaV2.
+ * @param {Boolean} skuRefUsed 
+ * @returns 
+ */
+async function getSkuInformation(sku, account, skuRefUsed) {
+  return new Promise((resolve, reject) => {
+    if (account?.ValidateSkuPriceInventoryInProcess === true) {
+      resolve(sku);
+    } else {
+      if (skuRefUsed) {
+        SkuData.getSkuByParentAccountNameAndSku(account?.ParentAccountName, sku).then(res => {
+          if (res?.SkuId) {
+            const { SkuId } = res;
+            resolve(SkuId);
+          } else {
+            reject(new Error(`SKU ${sku} not found`));
+          }
+        }).catch(reject);
+      } else {
+        SkuData.getSkuByParentAccountNameAndEan(account?.ParentAccountName, sku).then(res => {
+          if (res?.[0]) {
+            const { SkuId } = res[0];
+            resolve(SkuId);
+          } else {
+            reject(new Error(`SKU ${sku} not found`));
+          }
+        }).catch(reject);
       }
     }
-
-    const response = failedClients.length > 0
-      ? {
-        message: "Not all clients were processed successfully",
-        processedClients: results.length,
-        failedClients
+  })
+}
+
+/**
+ * Recorre la lista de productos para eliminar registros con "sku" duplicado.
+ * @param {Object[]} items Lista de ítems
+ * @param {Object} skusList Objeto donde se consolida la lista de SKU´s.
+ */
+function removeDuplicatesSku(items, skusList) {
+  const indexes = {};
+  // Se recorre la lista en orden invertido, para que en caso de encontrar registros con "sku" duplicado se eliminen y quede solamente el elemento de la última posición.
+  if (items?.length) {
+    for (let i = items.length - 1; i >= 0; i--) {
+      const { sku } = items[i];
+      !skusList.hasOwnProperty(sku) && (skusList[sku] = {});
+      if (indexes.hasOwnProperty(sku)) {
+        items.splice(i, 1);
+      } else {
+        indexes[sku] = true;
       }
-      : {
-        message: "All clients processed successfully",
-        processedClients: results.length,
-        results
-      };
-
-    const statusCode = failedClients.length > 0 ? 207 : 200;
-    Logger.info(`Process completed with status ${statusCode}, processed: ${results.length}, failed: ${failedClients.length}`);
-
-    return ApiResponse.response(statusCode, response);
-
-  } catch (error) {
-    Logger.error("Critical error in suggestedProductMdlz", {
-      error: error.message,
-      stack: error.stack
-    });
-    return ApiResponse.response(500, "Internal server error");
+    }
   }
-};
+}
+
+/**
+ * Organiza la información de los SKU en cada una de las listas de productos del cliente.
+ * @param {Object[]} list Lista de ítems de producto sugerido.
+ * @param {Object} skusList Objeto donde se consolida la información de los SKU.
+ * @param {Object} skusList Objeto donde se consolida la información de los SKU que no fueron encontrados.
+ */
+function setItemInformation(list, productType, skusList) {
+  for (let item of list) {
+    item.type = productType;
+    const { sku } = item;
+    // Se elimina la propiedad "sku", para luego insertar este valor en la entidad de productos sugeridos
+    delete item.sku;
+    if (skusList?.[sku]) {
+      const { SkuId, IsActive, ProductIsVisible } = skusList[sku];
+      item.refId = sku;
+      item.skuId = SkuId;
+      if (IsActive) {
+        item.status = ProductIsVisible ? 'active' : 'not_visible';
+      } else {
+        item.status = 'inactive';
+      }
+    } else {
+      item.status = 'invalid';
+    }
+  }
+}
 
 module.exports = suggestedProductMdlz;