dcos-core-monalisav2-latam 1.0.0

package/src/functions/clients/clients-producer.js

@@ -0,0 +1,362 @@
+const AWSServices = require("../../common/utils/aws-services");
+const ApiResponse = require("../../common/utils/api-response");
+
+const ClientData = require("../../entities/clients");
+const AccountData = require("../../entities/account");
+
+const Logger = require("../../common/utils/logger");
+const VtexApi = require("../../vtex/clients/VtexApi");
+
+const suggestedProductMdlz = require("./helpers/suggested-product-mdlz");
+
+const LIMIT_ITEMS_TO_PROCESS = process?.env?.LIMIT_ITEMS_TO_PROCESS || 150;
+const SQS_CLIENT_QUEUE_URL = process.env.SQS_CLIENT_QUEUE_URL;
+
+/**
+ *
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns
+ */
+const producer = async (event) => {
+  // Se extrae el method y el path del endpoint asociado a la función lambda
+  const { httpMethod, resource } = event;
+
+  // Si el endpoint corresponde a la creación de registros
+  if (httpMethod == 'POST' && resource == '/clients') {
+    return handleCreateClient(event);
+  }
+
+  // Si el endpoint corresponde a la consulta de registros
+  if (httpMethod == 'GET' && resource == '/clients/{an}/{method}') {
+    return handleFindClients(event);
+  }
+
+  if (httpMethod == 'POST' && resource == '/internal_process/suggestedProductMdlz') {
+    return suggestedProductMdlz(event);
+  }
+
+  return ApiResponse.response(400, 'Resource not available');
+};
+
+const handleCreateClient = async (event) => {
+  let statusCode = 200, message;
+
+  if (!event.body) {
+    return ApiResponse.response(400, "No body was found");
+  }
+
+  try {
+    Logger.log(JSON.stringify(event));
+    const request = JSON.parse(event.body);
+
+    const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+    const scope = event?.requestContext?.authorizer?.claims?.scope;
+    const accountName = request?.an;
+    const clients = request?.clients;
+
+    if (clients?.length >= LIMIT_ITEMS_TO_PROCESS) {
+      Logger.error("Clients size INVALID: ", clients?.length);
+      return errorResponse(404, "Clients limit of items exceeded");
+    }
+
+    if (!event?.internalService) {
+      if (!scope?.includes("admin")) {
+        const validateAccount = await ClientData.validateAccount(clientId, accountName);
+        if (!validateAccount) {
+          Logger.error("Account not found: ", accountName, ". ClientId: ", clientId);
+          return ApiResponse.response(404, "Account not found");
+        }
+      }
+    }
+    const account = event?.accountData && event?.internalService === true ? event?.accountData : await AccountData.getAccountDataByAccountName(accountName);
+    const parentAccount = await AccountData.getAccountDataByAccountName(account?.ParentAccountName);
+    Logger.setAccount(account);
+    Logger.debug("Account-Data: ", account);
+    Logger.debug("Parent-Account-Data: ", parentAccount);
+
+    //for each client
+    let notProcessed = [];
+
+    for (let item of clients) {
+      try {
+        Logger.debug("Object client to process: ", item);
+        const priceTableParam = item?.additional_information?.priceTable;
+        let priceTableVtex = null;
+        if (priceTableParam && priceTableParam !== "") {
+          priceTableVtex = account?.PriceList?.[priceTableParam];
+          item.additional_information.priceTable = priceTableVtex ?? `L${priceTableParam}`;
+        }
+
+        const dataSend = {
+          an: accountName,
+          parentAccount: parentAccount?.AccountName,
+          key: parentAccount?.Credentials?.key,
+          token: parentAccount?.Credentials?.token,
+          ...item,
+        };
+
+        // start valid fields requerid
+        let validRequired = validFieldsRequerid({ item: item, config: account });
+        if (validRequired?.valid === false) {
+          item.error = validRequired?.error;
+          notProcessed = [...notProcessed, item];
+        } else if (validDataClientFirstLevel({ data: item, ParametersClusterClient: account?.ParametersClusterClient }) === false) {
+          item.error = `validate the following properties ${JSON.stringify(account?.ParametersClusterClient)}`;
+          notProcessed = [...notProcessed, item];
+        } else {
+          Logger.debug("Datasend for SQS: ", dataSend);
+          await AWSServices.sendSQSMessage(SQS_CLIENT_QUEUE_URL, dataSend);
+        }
+
+      } catch (error) {
+        Logger.error("Error while client was processing: ", error);
+        notProcessed.push(item);
+      }
+    }
+
+    if (notProcessed.length > 0) {
+      Logger.debug("Not Processed: ", notProcessed);
+      const message = {
+        message: "Not all items were processed.",
+        notProcessedItems: notProcessed,
+      };
+      return ApiResponse.response(207, message);
+    }
+
+    message = "Message accepted!";
+  } catch (error) {
+    Logger.error("Error clients producer: ", error);
+    statusCode = 500;
+  }
+  return ApiResponse.response(statusCode, message);
+};
+
+const handleFindClients = async (event) => {
+  const { headers, pathParameters, queryStringParameters, internalService, requestContext } = event;
+  const { an: accountName, method } = pathParameters;
+
+  const { client_id: clientId, scope } = requestContext?.authorizer?.claims ?? {};
+
+  if (!internalService) {
+    if (!scope?.includes("admin")) {
+      const validateAccount = await ClientData.validateAccount(clientId, accountName);
+      if (!validateAccount) {
+        Logger.error("Account not found: ", accountName, ". ClientId: ", clientId);
+        return ApiResponse.response(404, "Account not found");
+      }
+    }
+  }
+
+  // Se valida el valor del método de búsqueda de registros
+  if (!['search', 'scroll'].includes(method)) {
+    return ApiResponse.response(400, `Method '${method}' is not allowed`);
+  }
+
+  // Se consulta los datos del account en DynamoDB
+  let { accountData = null } = event;
+  if (!(accountData && internalService)) {
+    accountData = await AccountData.getAccountDataByAccountName(accountName);
+  }
+
+  // Se obtiene los datos del account "padre"
+  const parentAccount = await AccountData.getAccountDataByAccountName(accountData?.ParentAccountName);
+  Logger.setAccount(accountData);
+
+  const { AccountName, Credentials, AcronymClientVtex } = parentAccount;
+  const { key, token } = Credentials;
+
+  Logger.debug('AccountName', AccountName);
+  Logger.debug('Method', method);
+
+  const apiClient = new VtexApi(AccountName, key, token);
+  let requestUrl = `/dataentities/${AcronymClientVtex}/${method}`, options = {
+    // Propiedad de AXIOS que permite retornar una respuesta sin importar el código HTTP retornado en la petición
+    validateStatus: () => true
+  };
+
+  // En caso que venga en los Query Params el atributo "an", se elimina el valor enviado
+  if (queryStringParameters.hasOwnProperty('an')) {
+    delete queryStringParameters.an;
+  }
+
+  // Se establece la Query Param "_fields" para indicar los campos a retornar en la consulta, en caso que este parámetro no venga
+  if (!queryStringParameters.hasOwnProperty('_fields') || !queryStringParameters['_fields']) {
+    queryStringParameters['_fields'] = '_all';
+  }
+
+  // Se verifica la condicional definida en la consulta
+  if (queryStringParameters.hasOwnProperty('_where')) {
+    // Se valida que en el Query Params "_where" no tenga consulta por el campo "an"
+    let match = queryStringParameters['_where'].match(/\b(an)\b/g)
+    if (match) {
+      queryStringParameters['_where'] = `(an=${accountName})`;
+    } else {
+      queryStringParameters['_where'] = `${queryStringParameters['_where']} AND (an=${accountName})`
+    }
+  } else {
+    queryStringParameters['_where'] = `(an=${accountName})`;
+  }
+
+  if (method == 'search') {
+    requestUrl = setQueryParams(requestUrl, queryStringParameters);
+
+    // Se obtiene el parámetro de Headers
+    const { 'rest-range': restRange = 'resources=0-100' } = headers;
+    Logger.debug('Header REST-Range', restRange);
+    options.headers = { 'REST-Range': restRange };
+  }
+
+  if (method == 'scroll') {
+    // En caso que a la petición se envíe el Query Param "_token", se establece solamente dicha propiedad en la petición a VTEX
+    if (queryStringParameters?.token) {
+      requestUrl = setQueryParams(requestUrl, { '_token': queryStringParameters.token });
+    } else {
+      requestUrl = setQueryParams(requestUrl, queryStringParameters);
+    }
+  }
+
+  // Se ejecuta la consulta a VTEX
+  let resultQuery = await apiClient.fetch(requestUrl, options, false);
+  if (resultQuery) {
+    // Se extrae el código de respuesta, cuerpo y cabecera de la respuesta de la petición
+    const { status, data, headers } = resultQuery;
+    const {
+      'x-vtex-md-token': xVtexMdToken,
+      'rest-content-range': restContentRange
+    } = headers;
+
+    // Se retorna la respuesta proveniente de VTEX
+    return ApiResponse.response(status, data, {
+      ...(xVtexMdToken && { 'X-VTEX-MD-TOKEN': xVtexMdToken }),
+      ...(restContentRange && { 'REST-Content-Range': restContentRange })
+    });
+  } else {
+    return ApiResponse.response(400, 'Error en handleFindClients');
+  }
+};
+
+/**
+ * Metodo que valida campos con un texto espesifico en su valor. 
+ **/
+const validDataClientFirstLevel = ({ data = null, ParametersClusterClient = null }) => {
+  if (data && ParametersClusterClient && typeof ParametersClusterClient == 'object') {
+    let valid = true;
+    for (let index in ParametersClusterClient) {
+      try {
+        if (data[index] && typeof ParametersClusterClient[index] == 'object' && !ParametersClusterClient[index].includes(data[index])) {
+          valid = false;
+        }
+      } catch (e) {
+        Logger.error(e);
+        valid = false;
+      }
+    }
+
+    return valid;
+  } else {
+    return true;
+  }
+};
+
+/**
+ * Metodo para realizar validacion de campos requeridos de clientes 
+ * @param item -- objeto del registro cliente enviado
+ * @param config -- objeto con la informacion de configuracion del account
+ **/
+const validFieldsRequerid = ({
+  item = null,
+  config = null
+}) => {
+
+  // Valicadion lista de parametros requeridos por la marca para insertar registro a entidad de datos
+  if (config?.ParametersRequiredClient && typeof config?.ParametersRequiredClient === 'object') {
+    for (let key in config?.ParametersRequiredClient) {
+      if (config?.ParametersRequiredClient[key] && config?.ParametersRequiredClient[key] != '') {
+        try {
+          let exitRegister = null;
+          eval(`exitRegister= ${config?.ParametersRequiredClient[key]}`);
+
+          if (!exitRegister || exitRegister == '') {
+            return {
+              valid: false,
+              error: `validate the following properties ${config?.ParametersRequiredClient[key]} is Required.`
+            };
+          }
+        } catch (error) {
+          Logger.error(error);
+          return {
+            valid: false,
+            error: "Error configurations ParametersRequiredClient"
+          };
+        }
+      }
+    }
+  }
+
+  // validacion parametor requiridos index
+  if (config?.IndexClientRegister && typeof config?.IndexClientRegister === 'object' && config?.IndexClientRegister?.length > 0) {
+    for (let key in config?.IndexClientRegister) {
+      if (config?.IndexClientRegister[key] && config?.IndexClientRegister[key] != '') {
+        try {
+          let valueIndex = config?.IndexClientRegister[key], validIndex = false;
+
+          if (valueIndex === 'an') {
+            validIndex = true;
+          } else if (item[valueIndex] && item[valueIndex] != '' && typeof item[valueIndex] === 'string') {
+            validIndex = true;
+          } else if (item?.address[valueIndex] && item?.address[valueIndex] != '' && typeof item?.address[valueIndex] === 'string') {
+            validIndex = true;
+          } else if (item?.additional_information[valueIndex] && item?.additional_information[valueIndex] != '' && typeof item?.additional_information[valueIndex] === 'string') {
+            validIndex = true;
+          }
+
+          if (validIndex === false) {
+            return {
+              valid: false,
+              error: `validate the following properties ${valueIndex} is requerid and type string for create index.`
+            };
+          }
+
+        } catch (error) {
+          Logger.error(error);
+          return {
+            valid: false,
+            error: "Error configurations ParametersRequeridClient"
+          };
+        }
+      }
+    }
+  } else {
+    return {
+      valid: false,
+      error: "Error configurations IndexClientRegister is requerid"
+    };
+  }
+
+  return {
+    valid: true,
+    error: null
+  };
+};
+
+const setQueryParams = (url, queryParams, allowEmpty = true) => {
+  let queryText = ''
+  for (let key in queryParams) {
+    if (key && (allowEmpty || !queryParams[key])) {
+      if (queryText) {
+        queryText += '&'
+      }
+      queryText += `${key}=${queryParams[key]}`
+    }
+  }
+
+  if (queryText) {
+    queryText = '?' + queryText
+  }
+
+  return url + queryText
+};
+
+module.exports = {
+  producer
+};

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

@@ -0,0 +1,166 @@
+const Logger = require("../../common/utils/logger");
+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 || [];
+
+    for (const record of records) {
+      const messageBody = JSON.parse(record.body);
+      const {
+        an,
+        parentAccount,
+        key,
+        token,
+        pdv,
+        productsRegular,
+        productsIncremental,
+        originalData,
+        nameEntityProductSuggested
+      } = messageBody;
+
+      Logger.log("Processing suggested products for client", { pdv, an });
+
+      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));
+      }
+
+      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);
+
+      await saveOriginalDataToClient(vtexApi, pdv, originalData, an);
+
+      Logger.log("Suggested products processed successfully", { pdv, userId });
+    }
+  } catch (error) {
+    Logger.error("Error in suggested products consumer", error);
+    throw error;
+  }
+};
+
+module.exports = {
+  consumer
+};