dcos-core-monalisav2-latam 1.0.0

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

@@ -0,0 +1,648 @@
+const VtexApi = require("../../vtex/clients/VtexApi");
+const AWSServices = require("../../common/utils/aws-services");
+const AccountData = require("../../entities/account");
+const AudiencePrice = require("../../integrations/audience/Audience");
+const Logger = require("../../common/utils/logger");
+
+const SQS_CLIENT_DQL_QUEUE_URL = process.env.SQS_CLIENT_DQL_QUEUE_URL;
+const SQS_CLIENT_QUEUE_URL = process.env.SQS_CLIENT_QUEUE_URL;
+const MAX_ATTEMPS = process.env.MAX_ATTEMPS || 3;
+const DATA_ENTITY_CLIENT_ACRONYM = process.env.DATA_ENTITY_CLIENT_ACRONYM;
+
+/**
+ *
+ * @param {import("aws-lambda").APIGatewayProxyEvent} event
+ * @returns
+ */
+const consumer = async (event) => {
+
+  for (const record of event.Records) {
+    const body = JSON.parse(record.body);
+    if (body) {
+      const {
+        an,
+        parentAccount,
+        key,
+        token,
+        email,
+        firstName,
+        lastName,
+        documentType,
+        document,
+        status,
+        homePhone,
+        phone,
+        phoneTwo,
+        customerClass,
+        customerClassTwo,
+        customerClassDist,
+        customerClassDistTwo,
+        customerClassDistThree,
+        approved,
+        address,
+        additional_information
+      } = JSON.parse(record.body);
+
+      let clientVtextBody = {
+        an: an,
+        approved: approved ?? true,
+        city: address?.city,
+        complement: address?.complement,
+        country: address?.country,
+        customerClass: customerClass,
+        customerClassTwo: customerClassTwo,
+        customerID: additional_information?.clientCode || '',
+        priceTables: additional_information?.priceTable,
+        diaEntrega: additional_information?.deliveryDay,
+        diaVisita: additional_information?.visitDay,
+        distribuitorName: additional_information?.distributorName ?? null,
+        distribuitorCode: additional_information?.distributorCode ?? null,
+        document: document,
+        documentType: documentType,
+        email: email,
+        firstName: firstName,
+        frecuencia: additional_information?.frequency,
+        lastName: lastName,
+        latitud: address?.geoCoordinates?.latitude,
+        longitud: address?.geoCoordinates?.longitude,
+        neighborhood: address?.neighborhood,
+        number: address?.number ?? null,
+        pdvname: additional_information?.pdvname,
+        pdv: additional_information?.pdv,
+        phone: phone || homePhone,
+        postalCode: address?.postalCode,
+        reference: address?.reference,
+        salesmanName: additional_information?.salesmanName ?? null,
+        state: address?.state,
+        status: status || "new",
+        street: address?.street,
+        supervisorName: additional_information?.supervisorName ?? null
+      };
+      
+      if(additional_information?.sellerId){
+        clientVtextBody.sellerId= additional_information?.sellerId;
+      }
+      if(additional_information?.routeMirror){
+        clientVtextBody.routeMirror= additional_information?.routeMirror; 
+      }
+      if(additional_information?.catalogueName){
+        clientVtextBody.catalogueName= additional_information?.catalogueName;
+      }
+      if(additional_information?.catalogueId){
+        clientVtextBody.catalogueId= additional_information?.catalogueId;
+      }
+      if(additional_information?.routeName){
+        clientVtextBody.routeName= additional_information?.routeName;
+      }
+      if(additional_information?.routeId){
+        clientVtextBody.routeId= additional_information?.routeId;
+      }
+      if(customerClassDist){
+        clientVtextBody.customerClassDist= customerClassDist;
+      }
+      if(customerClassDistTwo){
+        clientVtextBody.customerClassDistTwo= customerClassDistTwo;
+      }
+      if(customerClassDistThree){
+        clientVtextBody.customerClassDistThree= customerClassDistThree;
+      }
+      if(phoneTwo){
+        clientVtextBody.phoneTwo= phoneTwo;
+      }
+
+      //campos politicas financieras
+      if(additional_information?.withCredit || additional_information?.withCredit === false){
+        clientVtextBody.withCredit= additional_information?.withCredit;
+      }
+      if(additional_information?.paymentTerm){
+        clientVtextBody.paymentTerm= additional_information?.paymentTerm;
+      }
+      if(additional_information?.paymentMethodCode){
+        clientVtextBody.paymentMethodCode= additional_information?.paymentMethodCode;
+      }
+
+      const account = await AccountData.getAccountDataByAccountName(an);
+      Logger.setAccount(account);
+      Logger.debug("Message Event: ", event);
+      Logger.debug("Account Data: ", account);
+      // Se realiza proceso para ignorar campos que no  prodran ser actualizados por la distribuidora
+      const ParametersRequiredForCustomerApproved= account?.ParametersRequiredForCustomerApproved ?? ['an'];
+      if(ParametersRequiredForCustomerApproved){
+        let clientAproved=true;
+        for (var i = 0; i < ParametersRequiredForCustomerApproved.length; i++) {
+          let keyClientApro= ParametersRequiredForCustomerApproved[i] ?? null;
+          if(keyClientApro && keyClientApro != ''){
+            if(!clientVtextBody[keyClientApro] || clientVtextBody[keyClientApro] == ''){
+              clientAproved= false;
+            }
+          }
+        }
+
+        if(clientAproved===false){
+          clientVtextBody.approved=false;
+        }
+      }
+      // Asignacion seller default y validacion geoenviadas
+      if(account && account?.ConditionsGeoCoordinates && account?.ConditionsGeoCoordinates?.default && account?.ConditionsGeoCoordinates?.default?.latitude && account?.ConditionsGeoCoordinates?.default?.longitude && account?.SetGeoCoordinatesGlobal === true){
+        const validSeller= await validSellerAccountVTEX({country: clientVtextBody.country, latitud: clientVtextBody.latitud, longitud: clientVtextBody.longitud, an:account?.AccountName, token: account?.Credentials?.token, key: account?.Credentials.key});  
+        if(validSeller === false){
+          let options= account?.ConditionsGeoCoordinates ?? null;
+          if(options?.keyLatitudeSend && options?.keyLongitudeSend && options?.keyLatitudeSend != '' && options?.keyLongitudeSend != ''){
+            clientVtextBody[options.keyLatitudeSend]= clientVtextBody?.latitud;
+            clientVtextBody[options.keyLongitudeSend]= clientVtextBody?.longitud;
+          }
+
+          clientVtextBody.latitud= account?.ConditionsGeoCoordinates?.default?.latitude;
+          clientVtextBody.longitud= account?.ConditionsGeoCoordinates?.default?.longitude;
+
+        }
+      }
+
+      //Limpiar campos que ignorados a ditribuidora
+      if(account && account?.IgnoreParameters && account?.ParameterListIgnore && typeof account?.ParameterListIgnore == 'object' && account?.IgnoreParameters== true ){
+        for (let i = 0; i < account?.ParameterListIgnore.length; i++) {
+          if(account?.ParameterListIgnore[i] && account?.ParameterListIgnore[i] != ''){
+            delete clientVtextBody[account.ParameterListIgnore[i]];
+          }
+        }
+      }
+
+      //recorrer todo AdditionalFieldsClientMD para asignar valores a clientVtextBody
+      if(account && account?.AdditionalFieldsClientMD && typeof account?.AdditionalFieldsClientMD == 'object'){
+        for (let key in account?.AdditionalFieldsClientMD) {
+          if(account?.AdditionalFieldsClientMD[key] && account?.AdditionalFieldsClientMD[key] != ''){
+            try {
+              eval(`clientVtextBody.${key}= ${account?.AdditionalFieldsClientMD[key]}`)
+            } catch (error) {
+              Logger.error(error);
+            }
+          }
+        }
+      }
+
+      // Asignacion de valores por defecto de cliente siendo account?.valuesDefaultClient un objeto que contiene key y value, siendo key el nombre del campo y value el valor a asignar
+      // este key puede ya existir en el objeto clientVtextBody, si es asi se debe verificar si el valor es diferente de null para no sobreescribirlo
+      if(account && account?.ValuesDefaultClient && typeof account?.ValuesDefaultClient == 'object'){
+        for (let key in account?.ValuesDefaultClient) {
+          if(!clientVtextBody[key] || clientVtextBody[key] == ''){
+            clientVtextBody[key]= account?.ValuesDefaultClient[key];
+          }
+        }
+      }
+
+      // limpieza caracteres campos clientes
+      clientVtextBody= cleanerCharactersFields({data:clientVtextBody, regExpFieldsClients: account?.RegExpFieldsClients});
+      
+      // Asignacion de geocoordenadas de manera dinamica por monaliza siguiendo parametros configurados dentro de la cuenta.
+      if(account && account?.SetGeoCoordinatesApp){
+        let setGeoCoordinatesApp= account.SetGeoCoordinatesApp ?? false;
+        if(setGeoCoordinatesApp===true){
+          let conditionsGeoCoordinates= account?.ConditionsGeoCoordinates;
+          if(conditionsGeoCoordinates){
+            clientVtextBody= await validGeoClientPerProperties({client:clientVtextBody, options: conditionsGeoCoordinates});
+          }
+        }
+      }
+      
+      // asignacion de id de entidad de datos de manura dinamica y configurable
+      let idClient= account?.IndexClientRegister ? SetIdClient({indexes: account?.IndexClientRegister, dataClient: clientVtextBody}) : SetIdClient({dataClient: clientVtextBody});
+      if(idClient){
+        clientVtextBody.id= idClient;
+        try {
+          const vtexApi = new VtexApi(parentAccount, key, token);
+          let AcronymClientVtex= account?.AcronymClientVtex ?? DATA_ENTITY_CLIENT_ACRONYM;
+          
+          const response = await vtexApi.fetch(`/dataentities/${AcronymClientVtex}/documents`, {
+            method: "PATCH",
+            data: clientVtextBody,
+          });
+          Logger.debug("Response: ", response);
+
+          // proceso para actualizar cliente dentro de entidad de datos seller vtex
+          if(account?.SavePriceTableCLWL===true){
+            const responseCL = await saveListPriceWhitelabel({
+              accountConfig: account,
+              data: {
+                email: `${account?.Startemail}+${idClient}@${account?.Domainemail}`,
+                priceTables: additional_information?.priceTable
+              }
+            });
+            Logger.debug("Response save priceTable CL whitelabel: ", responseCL);
+          }
+          // fin del proceso
+
+          // proceso para actualizar audience dentro de entidad de datos seller vtex
+          if(account?.SavePriceAudience===true){
+            const responsePriceAudienceCL = await saveListPriceAudience({
+              accountConfig: account,
+              email: `${account?.Startemail}+${idClient}@${account?.Domainemail}`,
+              priceTable: additional_information?.priceTable
+            });
+            Logger.debug("Response save Audience CL: ", responsePriceAudienceCL);
+          }
+          // fin del proceso
+
+          if (response.status >= 200 && response.status < 300) {
+            Logger.debug("Client updated successfully.");
+          } else {
+            const attemps = JSON.parse(record.body)?.attemps || 0;
+            Logger.error(
+              "Error updating client. Status: ",
+              response.status,
+              ". Message: ",
+              response?.data?.message,
+              " - Try: ",
+              attemps
+            );
+
+            if (attemps < MAX_ATTEMPS) {
+              await AWSServices.sendSQSMessage(
+                SQS_CLIENT_QUEUE_URL,
+                JSON.stringify({
+                  key,
+                  token,
+                  attemps: attemps + 1,
+                  ...clientVtextBody,
+                })
+              );
+            } else {
+              throw new Error("Max attemps reached.");
+            }
+          }
+        } catch (error) {
+          Logger.error("Register Client Consumer: ", error);
+          try {
+            let attempsSqs= record?.attempsSqs ?? 1;
+            if(attempsSqs < MAX_ATTEMPS){
+              attempsSqs++;
+              await AWSServices.sendSQSMessage(SQS_CLIENT_QUEUE_URL, {...record, attempsSqs});
+            }else{
+              await AWSServices.sendSQSMessage(
+                SQS_CLIENT_DQL_QUEUE_URL,
+                JSON.stringify({
+                  body: record.body,
+                  error: error?.message,
+                })
+              );
+            }
+          } catch (error) {
+            Logger.error("Sending message to DQL Queue: ", error);
+          }
+        }
+      }else{
+        Logger.error("Error per id client valid IndexClientRegister in settings!")
+      }
+
+    }
+  }
+};
+
+
+/**
+ * Guardar datos de clientes dentro del seller audience
+ * @param accountConfig   datos de configuracion seller dentro de monalisa
+ * @param email           email del cliente
+ * @param priceTable      lista de precios a asociar
+ * @returns {Promise}
+ **/
+const saveListPriceAudience = async ({ accountConfig = null, email = null, priceTable = null }) => {
+  if (!accountConfig || !email || !priceTable) {
+    return null;
+  }
+  return new Promise(async (res, err) => {
+    try {
+      const priceAudience = new AudiencePrice(accountConfig?.AccountName, accountConfig?.Credentials?.key, accountConfig?.Credentials?.token);
+      // 1. POST - Fetch audience (Obtén el audienceId usando el email del comprador)
+      const audienceResponse = await priceAudience.createAudiencePrice(email) ?? null;
+      if (!audienceResponse) {
+        return err("Error fetching audience or no audience found.");
+      }
+      const priceTableResponse = await priceAudience.updateAudiencePriceById(audienceResponse, [priceTable]);
+      if (!priceTableResponse) {
+        return err("Error setting price table mapping.");
+      }
+      // Devuelve el resultado exitoso
+      res({
+        audienceId: audienceResponse,
+        message: "Price table mapping successful.",
+      });
+    } catch (error) {
+      err(error);
+    }
+  });
+};
+
+/**
+ * Guardar datos de clientes dentro del seller white label 
+ * @param accountConfig   datos de configuracion seller dentro de monalisa
+ * @param data            datos almacenar en CL wl VTEX
+ **/
+const saveListPriceWhitelabel= async ({accountConfig=null, data=null})=>{
+  if(!accountConfig || !data){
+    return null;
+  }
+
+  return new Promise(async(res, err)=>{
+    const vtexApi = new VtexApi(accountConfig?.AccountName, accountConfig?.Credentials?.key, accountConfig?.Credentials?.token);
+    
+    const response = await vtexApi.fetch(`/dataentities/CL/documents`, {
+      method: "PATCH",
+      data: data,
+    });
+
+    res(response);
+  });
+};
+
+/**
+ * Funcion para limpieza de caracteres especiales en campos 
+ *@param data -- datos que del cliente
+ *@param regExpFieldsClients -- expresion regular de los valores permitidos por filed
+ **/
+const cleanerCharactersFields= ({data=null, regExpFieldsClients= {"firstName": "^[a-zA-Z0-9 ñÑáéíóúÁÉÍÓÚ]+$"} })=>{
+  if(!data || !regExpFieldsClients){
+    return data;
+  }
+
+  let listReplace={
+    "Ã": "A",
+    "É": "E",
+    "Ü": "U",
+    "Ã'": "N",
+    "°": " ",
+    "´" : " ",
+    "'" : " ",
+    "," : " ",
+    "-": " ",
+    ".": "",
+    "º": "",
+    "ª": "",
+    "/": " ",
+    "°": "",
+    "+": " ",
+    "Ì": "I",
+    ":": "",
+    "?": "",
+    "@": "",
+    "¥": "",
+    "*": "",
+    "ä": "a",
+    "&": " ",
+    "#": " ",
+    "¦": "",
+    "Ü": "U",
+    "È": "E",
+    "À": "A",
+    "Ø": "O",
+    "{": "",
+    "}": "",
+    "ü": "u",
+    "©": "",
+    "`": "",
+    "±": "",
+    "¬": "",
+    "|": "",
+    ";": "",
+    "!": "",
+    "<": " ",
+    "³": "",
+    "": "",
+    "§": "",
+    "~": "",
+    "­": "",
+    "_": "",
+    "¡": "",
+    "„": "",
+    "%": "",
+    "Ð": "",
+    "à": "a",
+    "Ù": "U",
+    "Â": "A",
+    "": "",
+    "(": "",
+    ")": "",
+    "‰": "",
+    "š": "s",
+    "‘": "",
+    "[": "",
+    "]": "",
+    "€": "",
+    "Œ": ""
+  };
+
+  let registerClient= data;
+
+  // Validador de caracteres
+  if(regExpFieldsClients && typeof regExpFieldsClients === 'object'){
+    let listCharacter= [];
+    for (let strRegex in regExpFieldsClients) {
+      if(strRegex && regExpFieldsClients[strRegex] && regExpFieldsClients[strRegex] != '' && registerClient[strRegex] && registerClient[strRegex] != '' ){
+        if( validStringRegExp({string: registerClient[strRegex], regEx: regExpFieldsClients[strRegex]}) === false ){
+          for (let iStr = 0; iStr < registerClient[strRegex].length; iStr++) {
+            let strLetter= registerClient[strRegex].charAt(iStr);
+              if(strLetter != '' && validStringRegExp({string: strLetter, regEx: regExpFieldsClients[strRegex]}) === false){
+                if(!listCharacter.includes(strLetter) && strLetter != ''  && strLetter != ' '){
+                  listCharacter=[...listCharacter, strLetter];
+                }
+              }
+          }
+          registerClient[strRegex]= fixStringValues({string: registerClient[strRegex], listReplace:listReplace, charactersFound: listCharacter });
+        }
+      }
+    }
+
+  }
+
+  return registerClient;
+};
+
+/**
+ * Funcion validador de textos
+ **/
+function validStringRegExp({string=null, regEx= "^[a-zA-Z ñÑáéíóúÁÉÍÓÚ]+$"}){
+  if(typeof string != 'string' || !string || !regEx){
+    return true;
+  }
+
+  if (string.match(regEx)!=null) {
+      return true;
+  } else {
+      return false;
+  }
+}
+
+/***
+ * Funcion de limpiieza string
+ **/
+function fixStringValues({
+  string=null, 
+  listReplace={
+    "%": ""
+  }, 
+  charactersFound= [] 
+}) {
+  if(!string){
+    return "";
+  }
+
+  let listCharacterReplace={};
+
+  for (let i = 0; i < charactersFound.length; i++) {
+    let charac= charactersFound[i];
+    listCharacterReplace[`${charac}`]= listReplace.hasOwnProperty(charac) ? listReplace[charac] : "";
+    
+  }
+
+  for (let caracter in listCharacterReplace) {
+      if (listCharacterReplace.hasOwnProperty(caracter) && caracter != '.' && caracter != '('  && caracter != ')' && caracter != '['  && caracter != ']' && caracter != '{'  && caracter != '}' && caracter != '?' && caracter != '+' && caracter != '*' && caracter != '\\') {
+        string = string.replace(new RegExp(`${caracter}`, 'g'), listCharacterReplace[`${caracter}`]);
+      }else if (listCharacterReplace.hasOwnProperty(caracter) && caracter == '.'){
+        string = string.replace(/\./g, listCharacterReplace[`${caracter}`]);
+      }else if (listCharacterReplace.hasOwnProperty(caracter) && caracter == '('){
+        string = string.replace(/\(/g, listCharacterReplace[`${caracter}`]);
+      }else if (listCharacterReplace.hasOwnProperty(caracter) && caracter == ')'){
+        string = string.replace(/\)/g, listCharacterReplace[`${caracter}`]);
+      }else if (listCharacterReplace.hasOwnProperty(caracter) && caracter == '['){
+        string = string.replace(/\[/g, listCharacterReplace[`${caracter}`]);
+      }else if (listCharacterReplace.hasOwnProperty(caracter) && caracter == ']'){
+        string = string.replace(/\]/g, listCharacterReplace[`${caracter}`]);
+      }else if (listCharacterReplace.hasOwnProperty(caracter) && caracter == '{'){
+        string = string.replace(/\{/g, listCharacterReplace[`${caracter}`]);
+      }else if (listCharacterReplace.hasOwnProperty(caracter) && caracter == '}'){
+        string = string.replace(/\}/g, listCharacterReplace[`${caracter}`]);
+      }else if (listCharacterReplace.hasOwnProperty(caracter) && caracter == '?'){
+        string = string.replace(/\?/g, listCharacterReplace[`${caracter}`]);
+      }else if (listCharacterReplace.hasOwnProperty(caracter) && caracter == '+'){
+        string = string.replace(/\+/g, listCharacterReplace[`${caracter}`]);
+      }else if (listCharacterReplace.hasOwnProperty(caracter) && caracter == '*'){
+        string = string.replace(/\*/g, listCharacterReplace[`${caracter}`]);
+      }else if (listCharacterReplace.hasOwnProperty(caracter) && caracter == '\\'){
+        string = string.replace(/\\/g, '');
+      }
+  }
+
+  return string;
+}
+
+/**
+ * Funcion para validar geo coordenadas seller 
+ * @param country
+ * @param latitud
+ * @param longitud 
+ * @param an
+ * @param token
+ * @param key
+ **/
+const validSellerAccountVTEX= async ({
+  country= null,
+  latitud= null,
+  longitud= null,
+  an= null,
+  token= null,
+  key= null
+})=>{
+  if(!country || !latitud || !longitud || !an || !token || !key){
+    return false;
+  }
+
+  return new Promise(async (res, err)=>{
+
+    const vtexApiV = new VtexApi(an, key, token);
+    const response = await vtexApiV.fetch(`/checkout/pub/regions?country=${country}&geoCoordinates=${longitud};${latitud}`, {
+      method: "GET"
+    });
+
+    if(response?.status === 200 && response?.data && response?.data?.length > 0){
+      let exitSellerVtex= false;
+      for (let i = 0; i < response?.data?.length; i++) {
+        let lisSellerApi= response?.data[i]?.sellers ?? [];
+        for (let j = 0; j < lisSellerApi?.length; j++) {
+          if(lisSellerApi[j]?.id == an){
+            exitSellerVtex= true;
+          }
+        }
+      }  
+
+      if(exitSellerVtex === true){
+        res(true);
+      }else{
+        res(false);
+      }
+    }else{
+      res(false);
+    }  
+  });
+};
+
+/**
+ * Funcion para realizar la asignacion de id de registro de cliente 
+ **/
+const SetIdClient= ({indexes= ['an', 'document'], dataClient=null})=>{
+  if(indexes && dataClient && typeof indexes === 'object'){
+    let idT= null;
+    let listValues=[];
+    for (let i = 0; i < indexes.length; i++) {
+      let indexCl=indexes[i];
+      if(indexCl && dataClient[indexCl]){
+        listValues= [...listValues, dataClient[indexCl]];
+      }
+    }
+
+    return listValues.length > 0 ? listValues.join('') : null;
+  }else{ 
+    return null;
+  }
+}
+
+/**
+ * Funcion que realiza asignacion de geocoordenadas desde el lado de monaliza con propiedades del cliente
+ * @param  client {object} .son las propiedades que se guardan para un cliente
+ * @param  options {object} .Son los parametros de configuracion para las condiciones para asignacion de geocoordenadas
+ **/
+const validGeoClientPerProperties= async ({client={}, options=null})=>{
+  if(client && options){
+    let latitude= options?.default?.latitude,
+        longitude= options?.default?.longitude;
+
+    if(options?.keyLatitudeSend && options?.keyLongitudeSend && options?.keyLatitudeSend != '' && options?.keyLongitudeSend != ''){
+      client[options.keyLatitudeSend]= client?.latitud;
+      client[options.keyLongitudeSend]= client?.longitud;
+    }
+
+    if(options?.listOptions){
+      for (let i = 0; i < options?.listOptions.length; i++) {
+        let conditions= options?.listOptions[i]?.conditioins;
+        if(conditions){
+          let totalConditions= Object.keys(conditions).length;
+          let countConditions= 0;
+          for (let key  in conditions) {
+            let keyS= key ?? null;
+            let valueS= conditions[keyS] ?? null;
+            if(keyS && valueS){
+              if(client[keyS] && client[keyS] == valueS){
+                countConditions++;
+              }
+            }
+          }
+          if(totalConditions==countConditions){
+            latitude= options?.listOptions[i]?.geoCoordinates?.latitude;
+            longitude= options?.listOptions[i]?.geoCoordinates?.longitude;
+          }
+        }
+      }
+    } 
+
+    client.latitud= latitude;
+    client.longitud= longitude;
+
+    return client;
+  }else if(client){
+    return client;
+  }else{
+    return null;
+  }
+}
+
+module.exports = {
+  consumer,
+};