dcos-core-monalisav2-latam 1.0.0

package/src/mdlz/client/MdlzApi.js

@@ -0,0 +1,70 @@
+const axios = require("axios");
+const MDLZ_BASE_URL = process.env.MDLZ_BASE_URL;
+const Logger = require("../../common/utils/logger");
+
+class MdlzApi {
+  constructor(authorization, grantType, scope) {
+    if (!authorization || !grantType || !scope) {
+      Logger.error("Invalid MDLZ API Credentials");
+      throw new Error("Invalid MDLZ API Credentials");
+    }
+    this.authorization = authorization;
+    this.grantType = grantType;
+    this.scope = scope;
+  }
+
+  get baseURL() {
+    return MDLZ_BASE_URL;
+  }
+
+  /**
+   * Excute a request to MDLZ API
+   * @param {string} url
+   * @param {import("axios").AxiosRequestConfig} options
+   * @returns {Promise<import("axios").AxiosResponse>}
+   */
+  fetch(url, options) {
+    const params = {
+      url: `${this.baseURL}${url}`,
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: this.authorization,
+        grant_type: this.grantType,
+        scope: this.scope,
+        ...options.headers,
+      },
+    };
+    return axios.request(params).catch((error) => {
+      // error is handled in catch block
+      if (error.response) {
+        // status code out of the range of 2xx
+        Logger.error("Data MDLZ response: ", error.response.data);
+        Logger.error("Status MDLZ response : ", error.response.status);
+        const errorResponse = {
+          status: error.response.status,
+          data: error.response.data,
+        };
+        return errorResponse;
+      } else if (error.request) {
+        // The request was made but no response was received
+        Logger.error("Error MDLZ no response: ", error.request);
+        const errorResponse = {
+          status: 500,
+          data: error.request,
+        };
+        return errorResponse;
+      } else {
+        // Error on setting up the request
+        Logger.error("Error MDLZ api response: ", error.message);
+        const errorResponse = {
+          status: 500,
+          data: error.message,
+        };
+        return errorResponse;
+      }
+    });
+  }
+}
+
+module.exports = MdlzApi;

package/src/vtex/clients/ProvidersApi.js

@@ -0,0 +1,51 @@
+const axios = require("axios");
+const Logger = require("../../common/utils/logger");
+
+/**
+ * Class providers api.
+ **/
+
+class ProviderApi {
+
+    /**
+     * Method that processes the fetch request to the supplier once the necessary data has been assembled.
+     * @param url -- url to request
+     * @param options -- object that contains the parameters necessary to perform the query, path, query or body.
+     **/
+
+    fetch(url, options = {}){
+        if (typeof options.body === 'string') {
+            try {
+                options.body = JSON.parse(options.body);
+            } catch (error) {
+                Logger.error('Error parsing body:', error.message);
+                return Promise.reject(new Error('Invalid JSON body format'));
+            }
+        }
+
+        return axios
+            .request({
+                url: url,
+                method: options.method || 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...options.headers,
+                },
+                data: options.body
+            })
+            .then(response => {
+                Logger.debug('Response data:', response.data);
+                return response;
+            })
+            .catch(error => {
+                if (error.response) {
+                    Logger.error('Error response:', error.response.data);
+                } else {
+                    Logger.error('Error', error.message);
+                }
+                throw error;
+            });
+    }
+}
+
+module.exports = ProviderApi

package/src/vtex/clients/VtexApi.js

@@ -0,0 +1,511 @@
+const axios = require("axios");
+const VTEX_BASE_URL = process.env.VTEX_BASE_URL;
+const Logger = require("../../common/utils/logger");
+
+class VtexApi {
+  constructor(accountName, authKey, authToken, environment) {
+    if (!accountName || !authKey || !authToken) {
+      throw new Error("Invalid VTEX API Credentials");
+    }
+    this.accountName = accountName;
+    this.authKey = authKey;
+    this.authToken = authToken;
+    this.environment = environment || "vtexcommercestable";
+  }
+
+  get baseURL() {
+    return VTEX_BASE_URL.replace("{accountName}", this.accountName)
+      .replace("{environment}", this.environment);
+  }
+
+  /**
+   * Execute a request to VTEX API
+   * @param {string} url
+   * @param {import("axios").AxiosRequestConfig} options
+   * @returns {Promise<import("axios").AxiosResponse>}
+   */
+  fetch(url, options = {}, printLog = true) {
+    const { headers = {}, ...optionsRemain } = options;
+    const data = {
+      url: `${this.baseURL}${url}`,
+      ...optionsRemain,
+      headers: {
+        "X-VTEX-API-AppKey": this.authKey,
+        "X-VTEX-API-AppToken": this.authToken,
+        "Content-Type": "application/json",
+        ...headers,
+      },
+    };
+    return axios
+      .request(data)
+      .catch(error => {
+        if (printLog) {
+          // error is handled in catch block
+          if (error.response) {
+            // status code out of the range of 2xx
+            Logger.error("Data :", error.response.data);
+            Logger.error("Status :" + error.response.status);
+          } else if (error.request) {
+            // The request was made but no response was received
+            Logger.error(error.request);
+          } else {
+            // Error on setting up the request
+            Logger.error("Error", error.message);
+          }
+        }
+        if (error?.response?.status >= 400) {
+          throw error;
+        } else {
+          return null;
+        }
+      });
+  }
+
+  fetchPub(url, options, data) {
+    return axios
+      .request({
+        url: `${this.baseURL}${url}`,
+        ...options,
+        data,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers,
+        },
+      })
+      .catch((error) => {
+        // error is handled in catch block
+        if (error.response) {
+          // status code out of the range of 2xx
+          Logger.error("Data :", error.response.data);
+          Logger.error("Status :" + error.response.status);
+        } else if (error.request) {
+          // The request was made but no response was received
+          Logger.error(error.request);
+        } else {
+          // Error on setting up the request
+          Logger.error("Error", error.message);
+        }
+        throw error;
+      });
+  }
+
+  fetchOrderMail(aliasMail) {
+    return axios.request({
+      url: `http://conversationtracker.vtex.com.br/api/pvt/emailMapping?alias=${aliasMail}&an=${this.accountName}`,
+      headers: {
+        "Content-Type": "application/json",
+        "X-VTEX-API-AppKey": this.authKey,
+        "X-VTEX-API-AppToken": this.authToken,
+      },
+    });
+  }
+
+  /**
+   * Execute a request to VTEX API
+   * @param {string} url
+   * @param {import("axios").AxiosRequestConfig} options
+   * @returns {Promise<import("axios").AxiosResponse>}
+   */
+  fetchApiURL(url, options) {
+    return axios.request({
+      url: `https://api.vtex.com/${this.accountName}${url}`,
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers,
+        "X-VTEX-API-AppKey": this.authKey,
+        "X-VTEX-API-AppToken": this.authToken,
+      },
+    });
+  }
+  /**
+   * Metdo para obtener token de autenticacion
+   * @returns 
+   */
+  async getVtexIdclientAutCookie(){
+    const _this= this;
+    return new Promise(async (resp,err)=>{
+      let data = JSON.stringify({
+        "appkey": _this.authKey,
+        "apptoken": _this.authToken
+      });
+
+      let config = {
+        method: 'post',
+        maxBodyLength: Infinity,
+        url: `https://api.vtexcommercestable.com.br/api/vtexid/apptoken/login?an=${_this.accountName}`,
+        headers: { 
+          'X-VTEX-API-AppKey': _this.authKey, 
+          'X-VTEX-API-AppToken': _this.authToken, 
+          'Content-Type': 'application/json'
+        },
+        data : data
+      };
+
+      axios.request(config)
+      .then((response) => {
+        resp((response?.data?.token ?? null));
+      })
+      .catch((error) => {
+        Logger.error(error);
+        resp(null);
+      });
+    });
+  }
+
+  convertDefaultProductSearch(dataP=null, isActive=true){
+    dataP.Skus= dataP?.Skus?.filter(it=> it?.IsActive===isActive) ?? [];
+    let dataTransform= {
+        "productId": dataP?.ProductId ? String(dataP?.ProductId) : dataP?.ProductId,
+        "productName": dataP?.Name,
+        "noVisible": true,
+        "brand": dataP?.BrandName,
+        "brandId": dataP?.BrandId,
+        "brandImageUrl": null,
+        "linkText": dataP?.LinkId,
+        "productReference": dataP?.RefId,
+        "productReferenceCode": dataP?.RefId,
+        "categoryId": dataP?.CategoryId ? String(dataP?.CategoryId) : dataP?.CategoryId,
+        "productTitle": dataP?.Title,
+        "metaTagDescription": dataP?.MetaTagDescription,
+        "releaseDate": dataP?.ReleaseDate,
+        "clusterHighlights": {},
+        "productClusters": {},
+        "searchableClusters": {},
+        "categories": [
+            `/${dataP?.CategoryName}/`
+        ],
+        "categoriesIds": [
+            `/${String(dataP?.CategoryId)}/`
+        ],
+        "link": null,
+        "allSpecifications": dataP?.Specifications?.map(it=>(it?.MainFieldName)),
+        "allSpecificationsGroups": [],
+        "description": dataP?.Description,
+        "items": dataP?.Skus?.map(it=>({
+          "itemId": it?.Id ? String(it?.Id) : it?.Id,
+          "name": it?.Name,
+          "nameComplete": `${dataP?.Name} ${it?.Name}`,
+          "complementName": dataP?.Name,
+          "ean": it?.Eans?.length > 0 ? it?.Eans[0] : "",
+          "referenceId": [
+              {
+                  "Key": "RefId",
+                  "Value": it?.RefId
+              }
+          ],
+          "measurementUnit": it?.MeasurementUnit,
+          "unitMultiplier": it?.UnitMultiplier,
+          "modalType": it?.ModalType,
+          "isKit": it?.IsKit,
+          "kitItems": it?.Components?.map(itK =>({
+            "itemId": itK?.SkuId ? String(itK?.SkuId) : itK?.SkuId,
+            "amount": itK?.Quantity
+          })),
+          "images": it?.Images?.map(itI=>({
+            "imageId": itI?.Id,
+            "imageLabel": itI?.Label,
+            "imageTag": itI?.Tag,
+            "imageUrl": itI?.Url,
+            "imageText": itI?.ArchiveText,
+            "imageLastModified": null
+          })),
+          "sellers": [],
+          "Videos": it?.Videos ?? [],
+          "estimatedDateArrival": it?.EstimatedDateArrival
+      }))
+    };
+
+    for(let i = 0; i < dataP?.Specifications?.length; i++){
+      let spec= dataP?.Specifications[i];
+      let keyS=spec.MainFieldName, valS=spec.ProductFieldValueText;
+      dataTransform[keyS]= [valS];
+    }
+
+    return dataTransform;
+  }
+
+  getProductsUnique(data=[]){
+    return data.filter((objeto, index) => {
+      return data.findIndex(obj => JSON.stringify(obj) === JSON.stringify(objeto)) === index;
+    });
+  };
+
+  async getProductsVisiblesDetails(data=[], authPrev, isActive=true){
+    const _this= this;
+    const dataUnique= _this.getProductsUnique(data);
+
+    if(dataUnique?.length === 0){
+      return [];
+    }
+
+    return new Promise(async(resp, err)=>{
+      const urls = dataUnique?.map(it=>(`https://admin-catalog-facelift.vercel.app/api/proxy/catalog/pvt/admin/form/product/${it?.ProductId}?an=${_this.accountName}`));
+
+      axios.all(urls.map(url => axios.request({
+        method: 'get',
+        maxBodyLength: Infinity,
+        url: url,
+        headers: { 
+          'accept': 'application/json', 
+          'token': authPrev
+        }
+      })))
+        .then((responses) => {
+          const dataRes= responses.map((resp) => {
+            return _this.convertDefaultProductSearch(resp?.data, isActive);
+          });
+           resp(dataRes);
+        })
+        .catch(error => {
+          // Manejar errores
+          Logger.error('Error:', error);
+          resp([]);
+        });
+    });
+  }
+
+  /**
+   * Metodo para obtener registros no visibles en tienda
+   * @param {*} isVisible 
+   * @param {*} isActive 
+   * @param {*} sc 
+   * @returns
+   */
+  async getProductsVisibles(isVisible=true, isActive=true, sc="1", lengthData= 2000){
+    const _this=this;
+    return new Promise(async (resp, err)=>{
+      let data = `Filters[SkuId]=&Filters[IsVisible]=${(isVisible === true ? "True" : "False")}&Filters[ProductName]=&Filters[BrandId]=&Filters[CategoryIds]=&Filters[StoreId]=${sc}&Filters[IsActive]=${(isActive === true ? "True" : "False")}&Filters[SellerId]=&Fields[]=ProductId&Rows=${lengthData}`;
+      const tokenAuth= await _this.getVtexIdclientAutCookie();
+
+      if(!tokenAuth){
+        resp([]);
+      }
+
+      let config = {
+        method: 'post',
+        maxBodyLength: Infinity,
+        url: `https://${_this.accountName}.${_this.environment}.com.br/admin/API/StockKeepingUnitReport/LoadContent/`,
+        headers: { 
+          'accept': 'application/json', 
+          'content-type': 'application/x-www-form-urlencoded; charset=UTF-8', 
+          'Cookie': `VtexIdclientAutCookie=${tokenAuth}`
+        },
+        data : data
+      };
+
+      axios.request(config).then(async (response) => {
+        const dataRes= await _this.getProductsVisiblesDetails((response?.data["Data"] ?? []), tokenAuth, isActive);
+        resp(dataRes);
+      }).catch((error) => {
+        Logger.error(error);
+        resp([]);
+      });
+    });
+  }
+  /**
+   * Metodo para obtener todos los productos de catalogo VTEX
+   * @param {*} isVisible 
+   * @param {*} isActive 
+   * @param {*} sc 
+   * @returns 
+   */
+  async getProductsAll(isActive=null, isVisible=null, sc="1", lengthData=2000){
+    let _this=this;
+    return new Promise(async (res, err) => {
+      let listProductSkus = [];
+      try {
+          const listTradePolicy = sc ? [sc] : ["1"];
+          for (let i = 0; i < listTradePolicy.length; i++) {
+              let stop = false, _from = 0, _to = 49;
+              while (stop === false) {
+                  try {
+                      const products = await _this.fetch(`/catalog_system/pub/products/search/?sc=${listTradePolicy[i]}&_to=${_to}&_from=${_from}&O=OrderByNameASC`, {
+                          method: "GET",
+                      });
+
+                      if (products?.data?.length > 0) {
+                          for (let j = 0; j < products.data.length; j++) {
+                            listProductSkus=[...listProductSkus, products.data[j]];
+                          }
+                      } else {
+                          stop = true;
+                      }
+                  } catch (error) {
+                      Logger.error("error getAllProductsVTEX while", error);
+                      stop = true;
+                  }
+
+                  _from += 50;
+                  _to += 50;
+              }
+          }
+
+          if(typeof isActive === "string"){
+            isActive= isActive.toLowerCase();
+            if(isActive && (isActive===true || isActive==="true")){
+              isActive= true;
+            }else{
+              isActive= false;
+            }
+          }else if(!isActive){
+            isActive=true;
+          }
+
+          if(typeof isVisible === "string"){
+            isVisible= isVisible.toLowerCase();
+            if(isVisible && (isVisible===true || isVisible==="true")){
+              isVisible= true;
+            }else{
+              isVisible= false;
+            }
+          }else if(!isVisible){
+            isVisible=false;
+          }
+
+          const productsVisible= await _this.getProductsVisibles(isVisible, isActive, sc, lengthData);
+          const productsVisibleFilter= productsVisible?.filter(itV=>itV?.items?.length > 0);
+          listProductSkus= [...listProductSkus, ...productsVisibleFilter];
+
+      } catch (error) {
+          Logger.error("error getAllProductsVTEX", error);
+      }
+
+      res(listProductSkus);
+    });
+  }
+  /**
+   * Metodo para obtener productos de catalogo VTEX
+   * @param {*} isVisible 
+   * @param {*} isActive 
+   * @param {*} sc 
+   * @returns 
+   */
+  async getProducts(event, isActive=null, isVisible=null, sc="1", lengthData=2000){
+    let _this=this;
+    let noVisible= event?.queryStringParameters?.noVisible;
+
+    let responseService= [];
+
+    if(typeof noVisible === "string"){
+      noVisible= noVisible.toLowerCase();
+    }
+    if(typeof isActive === "string"){
+      isActive= isActive.toLowerCase();
+      if(isActive && (isActive===true || isActive==="true")){
+        isActive= true;
+      }else{
+        isActive= false;
+      }
+    }else if(!isActive){
+      isActive=true;
+    }
+
+    if(typeof isVisible === "string"){
+      isVisible= isVisible.toLowerCase();
+      if(isVisible && (isVisible===true || isVisible==="true")){
+        isVisible= true;
+      }else{
+        isVisible= false;
+      }
+    }else if(!isVisible){
+      isVisible=false;
+    }
+
+    if((noVisible && (noVisible===true || noVisible==="true")) || isActive===false){
+      const productsVisible= await _this.getProductsVisibles(isVisible, isActive, sc, lengthData);
+      const productsVisibleFilter= productsVisible?.filter(itV=>itV?.items?.length > 0);
+      responseService= [...responseService, ...productsVisibleFilter];
+    }else{
+      const response = await _this.fetch(`/catalog_system/pub/products/search`, {
+        method: "GET",
+        params: event?.queryStringParameters
+      });
+
+      if (response?.data) {
+        responseService = response?.data ?? [];
+      }
+    }
+
+    return responseService;
+  }
+
+  async getDetailSkuPerSkuRef(relationSkuRef){
+    const _this = this;
+
+    try {
+      if (Array.isArray(relationSkuRef) === false || relationSkuRef.length === 0) {
+        relationSkuRef = [relationSkuRef];
+      }
+
+      const skusRefsIds = await _this.fetch(`/catalog_system/pub/sku/stockkeepingunitidsbyrefids`, {
+        method: "POST",
+        data: relationSkuRef
+      });
+
+      if (!skusRefsIds || !skusRefsIds.data) {
+        return [];
+      }
+
+      let filteredSkusRefsIds = [];
+      Object.entries(skusRefsIds.data).forEach(([key, value]) => {
+        if(value !== "null" && value !== null && value !== undefined){
+          filteredSkusRefsIds.push(value);
+        }
+      });
+      
+      if (filteredSkusRefsIds.length === 0) {
+        return [];
+      }
+
+      const detailedProducts = await this.getDetailSkuById(filteredSkusRefsIds);
+      return detailedProducts;
+
+    } catch (error) {
+      Logger.error("error getDetailSkuPerSkuRef", error);
+      return [];
+    }
+  }
+
+  async getDetailSkuById(skuIds){
+    const _this = this;
+
+    if (Array.isArray(skuIds) === false || skuIds.length === 0) {
+      skuIds = [skuIds];
+    }
+
+    return new Promise(async(resp, err)=>{
+      const urls = skuIds?.map(skuId =>(`${_this.baseURL}/catalog_system/pvt/sku/stockkeepingunitbyid/${skuId}`));
+
+      axios.all(urls.map(url => axios.request({
+        method: 'get',
+        maxBodyLength: Infinity,
+        url: url,
+        headers: { 
+          'Accept': 'application/json',
+          'Content-Type': 'application/json',
+          'X-VTEX-API-AppKey': _this.authKey, 
+          'X-VTEX-API-AppToken': _this.authToken
+        }
+      }).catch(error => {
+        Logger.error(`Error for URL ${url}:`, error.message);
+        return null;
+      })))
+        .then((responses) => {
+          const dataRes = responses
+            .filter(resp => resp && resp.data) // Filtrar respuestas válidas
+            .map((resp) => resp.data);
+          resp(dataRes);
+        })
+        .catch(error => {
+          Logger.error('General error in getDetailSkuById:', error);
+          resp([]);
+        });
+    });
+  
+  }
+
+}
+
+module.exports = VtexApi;
+