dcos-core-monalisav2-latam 1.0.0

package/src/integrations/mobilvendor/MobilvendorApi.js

@@ -0,0 +1,405 @@
+const axios = require("axios");
+const ApiResponse = require("../../common/utils/api-response");
+const VtexApi = require("../../vtex/clients/VtexApi");
+const Logger = require("../../common/utils/logger");
+
+/**
+ * Class representing the MobilvendorApi.
+ *
+ * @class
+ * @classdesc This class provides methods for interacting with the Mobilvendor API.
+ */
+class MobilvendorApi {
+    constructor(AccountName, Key, Token, AcronymClientVtex, FinancialPolicyEcu) {
+        this.AccountName = AccountName;
+        this.Key = Key;
+        this.Token = Token;
+        this.AcronymClientVtex = AcronymClientVtex;
+        this.FinancialPolicyEcu = FinancialPolicyEcu;
+    }
+
+    /**
+     * set FinancialPolicyEcu
+     * */
+    setConfig(FinancialPolicyEcu) {
+        this.FinancialPolicyEcu= FinancialPolicyEcu;
+    }
+
+    /**
+     * Logs in to the Mobilvendor API.
+     * 
+     * @returns {Object} An object containing the context ID and session ID.
+     *                  - contextId: The ID of the context.
+     *                  - sessionId: The ID of the session.
+     * @throws {Error} If there is an error during the login process.
+     */
+    async login() {
+        try {
+            const responseLogin = await axios.post(this.FinancialPolicyEcu.configService.url,
+                this.FinancialPolicyEcu.configService.body
+            );
+
+            if (!responseLogin || !responseLogin?.data?.session_id){
+                Logger.error("Login mobilvendor have problems");
+                return ApiResponse.response(404, { approved: false, message: "Login mobilvendor have problems" });
+            }
+
+            const sessionId = responseLogin.data.session_id;
+            const responseContexts = await axios.post(this.FinancialPolicyEcu.configService.url, {
+                session_id: sessionId,
+                action: "getContexts",
+            });
+            const response = responseContexts?.data?.records;
+            let contextId = response?.find(record => record?.id === this.FinancialPolicyEcu.configService.context)?.id;
+
+            if (!contextId) {
+                contextId = this.FinancialPolicyEcu.configService.context;
+            }
+
+            return { contextId, sessionId };
+        } catch (error) {
+            Logger.error(error);
+            return ApiResponse.response(404, { approved: false, message: "Login mobilvendor have problems" });
+        }
+    }
+
+    /**
+     * Retrieves the client data by email.
+     * 
+     * This method retrieves the client data by performing the following steps:
+     * 1. Creates an instance of the VtexApi class using the provided account name, key, and token.
+     * 2. Extracts the client ID from the email.
+     * 3. Sends a GET request to the Vtex API to retrieve the client data for the specified ID.
+     * 4. Checks the response status. If the status is between 200 and 299 (inclusive), returns the client data.
+     * 5. Returns null if the response status is outside the range of 200 to 299.
+     * 
+     * @param {string} email - The email of the client.
+     * @returns {Promise<Object|null>} A promise that resolves to the client data if successful, or null in case of an error.
+     * @throws {Error} If there is an error during the retrieval process.
+     */
+    async getClientById(email) {
+        try {
+            const vtexApi = new VtexApi(this.AccountName, this.Key, this.Token);
+            const clientId = email?.split("+")[1]?.split("@")[0];
+            const responseMasterDataCT = await vtexApi.fetch(
+                `/dataentities/${this.AcronymClientVtex}/search?_fields=_all&id=${clientId}`, { method: "GET" }
+            );
+            
+            if (responseMasterDataCT.status >= 200 && responseMasterDataCT.status < 300) {
+                return responseMasterDataCT.data[0];
+            } else {
+                Logger.error(responseMasterDataCT);
+                return null;
+            }
+        } catch (error) {
+            Logger.error(error);
+            return null;
+        }
+    }
+
+    /**
+     * Retrieves the order form data by ID.
+     * 
+     * This method retrieves the order form data by performing the following steps:
+     * 1. Creates an instance of the VtexApi class using the provided account name, key, and token.
+     * 2. Sends a GET request to the Vtex API to retrieve the order form data for the specified ID.
+     * 3. Checks the response status. If the status is not 200, returns an error response.
+     * 4. Returns the order form data.
+     * 
+     * @param {string} orderFormId - The ID of the order form to retrieve.
+     * @returns {Promise<Object|null>} A promise that resolves to the order form data if successful, or null in case of an error.
+     * @throws {Error} If there is an error during the retrieval process.
+     */
+    async getOrderFormById(orderFormId) {
+        try {
+            const vtexApi = new VtexApi(this.AccountName, this.Key, this.Token);
+            const responseOrderForm = await vtexApi.fetch(`/checkout/pub/orderForm/${orderFormId}?refreshOutdatedData=true`, { method: "GET" });
+            
+            if (responseOrderForm.status !== 200){
+                Logger.error(responseOrderForm);
+                ApiResponse.response(404, { approved: false, message: "orderForm is not found" });
+            }            
+                        
+            const { data } = responseOrderForm;
+
+            return data;
+        } catch (error) {
+            Logger.error(error);
+            return null;
+        }
+    }
+
+    async deleteCustomData(orderFormId, customData) {
+        try {
+            if (!customData) {
+                return true;
+            }
+            const vtexApi = new VtexApi(this.AccountName, this.Key, this.Token);
+            const customApps = customData?.customApps ?? [];
+            const financialPolicy = customApps?.find(app => app.id === this.FinancialPolicyEcu.configVtex.id);
+            const fields = financialPolicy?.fields;
+
+            if(this.FinancialPolicyEcu?.attachmentCredit && this.FinancialPolicyEcu?.attachmentCredit?.name && this.FinancialPolicyEcu?.attachmentCredit?.value){
+                await vtexApi.fetchPub(`/checkout/pub/orderForm/${orderFormId}/attachments/${this.FinancialPolicyEcu?.attachmentCredit?.name}`, { method: "POST" }, {value: null});
+            }
+
+            for (const field in fields) {
+                await vtexApi.fetchPub(`/checkout/pub/orderForm/${orderFormId}/customData/${this.FinancialPolicyEcu.configVtex.id}/${field}`, { method: "DELETE" });
+            }
+
+            return true;
+        } catch (error) {
+            Logger.error(error);
+            return ApiResponse.response(401, { approved: false, message: "Error deleting customData orderForm" });
+        }
+    }
+
+    /**
+     * Updates the custom data of an order form.
+     * 
+     * This method updates the custom data of an order form by performing the following steps:
+     * 1. Creates an instance of the VtexApi class using the provided account name, key, and token.
+     * 2. Sends a PUT request to the Vtex API to update the custom data of the specified order form.
+     * 3. Checks the response status. If the status is not 200, returns an error response.
+     * 4. Returns the updated custom data.
+     * 
+     * @param {string} orderFormId - The ID of the order form to update.
+     * @param {string} idConfigVtex - The ID of the custom data configuration in Vtex.
+     * @param {Object} customData - The custom data to update.
+     * @returns {Promise<Object|null>} A promise that resolves to the updated custom data if successful, or null in case of an error.
+     * @throws {Error} If there is an error during the update process.
+     */
+    async updateOrderFormCustomData(orderFormId, idConfigVtex, customData) {
+        try {
+            const vtexApi = new VtexApi(this.AccountName, this.Key, this.Token);
+            const response = await vtexApi.fetchPub(
+                `/checkout/pub/orderForm/${orderFormId}/customData/${idConfigVtex}`,
+                { method: "PUT" },
+                customData
+            );
+
+            if(this.FinancialPolicyEcu?.attachmentCredit && this.FinancialPolicyEcu?.attachmentCredit?.name && this.FinancialPolicyEcu?.attachmentCredit?.value){
+                await vtexApi.fetchPub(`/checkout/pub/orderForm/${orderFormId}/attachments/${this.FinancialPolicyEcu?.attachmentCredit?.name}`, { method: "POST" }, this.FinancialPolicyEcu?.attachmentCredit?.value);
+            }
+
+            if (response.status !== 200) {
+                Logger.error(response);
+                return ApiResponse.response(401, { approved: false, message: "Error updating customData orderForm" });
+            }
+
+            return response.data;
+        } catch (error) {
+            Logger.error(error);
+            return ApiResponse.response(401, { approved: false, message: "Error updating customData orderForm" });
+        }
+    }
+
+    async cleanOrderFormCustomData(orderFormId, idConfigVtex) {
+        try {
+            const vtexApi = new VtexApi(this.AccountName, this.Key, this.Token);
+            const customData = {
+                "approved": "false",
+                "withCredit": "false",
+                "paymentTerm": "-",
+                "maximumCreditAmount": "-",
+                "paymentMethodCode": "-",
+                "creditDays": "-",
+                "paymentMethodName": "-"
+            };
+            const response = await vtexApi.fetchPub(
+                `/checkout/pub/orderForm/${orderFormId}/customData/${idConfigVtex}`,
+                { method: "PUT" },
+                customData
+            );
+
+            if (response.status !== 200){
+                Logger.error(response);
+                return ApiResponse.response(401, { approved: false, message: "Error deleting customData orderForm" });
+            }
+
+            return response.data;
+        } catch (error) {
+            Logger.error(error);
+            return ApiResponse.response(401, { approved: false, message: "Error cleaning customData orderForm" });
+        }
+    }
+
+    /**
+     * Retrieves the customer balance from the Mobilvendor API.
+     * 
+     * This method retrieves the customer balance by performing the following steps:
+     * 1. Checks if the Financial Policy is active. If not, returns an error response.
+     * 2. Checks if the orderFormId is provided. If not, returns an error response.
+     * 3. Retrieves the order form data using the provided orderFormId.
+     * 4. Retrieves the client data using the email from the order form data.
+     * 5. Retrieves the customer balance from the Mobilvendor API using the customer code.
+     * 6. Checks if the customer is found in the Mobilvendor API. If not, throws an error response.
+     * 7. Calculates the approved status based on various conditions.
+     * 8. Constructs the response object with the customer balance information.
+     * 9. Checks if the credit is not approved. If not, returns an error response.
+     * 10. Returns the response object with the customer balance information.
+     * 
+     * @param {string} orderFormId - The ID of the order form associated with the customer.
+     * @param {number} creditDays - The number of credit days to consider for the customer.
+     * @returns {Promise<Object|null>} A promise that resolves to the response object with the customer balance information if successful, or null in case of an error.
+     * @throws {Error} If there is an error during the retrieval process.
+     */
+    async getCustomerBalance(orderForm, creditDays = null, responseMasterDataCT=null) {
+        // Verificar si la política financiera está activa
+        if (!this.FinancialPolicyEcu.isActive) {
+            Logger.error("Financial Policy is not active");
+            return ApiResponse.response(401, { approved: false, message: "Financial Policy is not active" });
+        }
+
+        // Verificar si se proporcionó el orderFormId
+        if (!orderForm) {
+            Logger.error("orderForm is Required");
+            return ApiResponse.response(400, { approved: false, message: "orderForm is Required" });
+        } 
+
+        // Obtener la información del cliente
+        const email = orderForm.clientProfileData?.email;
+        if (!responseMasterDataCT) {
+            Logger.error("Client not found");
+            return ApiResponse.response(404, { approved: false, message: "Client not found" });
+        }
+
+        // Calcular el valor del pedido
+        const value = (orderForm.value || 0) / 100;
+        const customerCode = responseMasterDataCT.pdv;
+        const customerWithCredit = responseMasterDataCT.withCredit ?? false;
+        // Obtener el balance del cliente
+        const responseMobilvendor = await this.getBalanceByCode(customerCode, value, creditDays, customerWithCredit);
+        return responseMobilvendor;
+    }
+
+    /**
+    * Retrieves the customer balance from the Mobilvendor API based on the customer code, value, and credit days.
+    * 
+    * @param {string} customerCode - The customer code.
+    * @param {number} value - The value.
+    * @param {number} creditDays - The credit days.
+    * @returns {Object} - The response from the Mobilvendor API containing the customer balance information.
+    * @throws {Error} - If there is an error retrieving the customer balance.
+    */
+    async getBalanceByCode(customerCode, value, creditDays = null, customerWithCredit=false) {
+        const { contextId, sessionId } = await this.login();
+        const dataGetCustomerBalance = {
+            session_id: sessionId,
+            action: "getCustomerBalance",
+            context_id: contextId,
+            customer_codes: [customerCode],
+        };
+        const { data } = await axios.post(this.FinancialPolicyEcu.configService.url, dataGetCustomerBalance);
+
+        if (!data?.records || data?.records.length == 0) {
+            Logger.error("customer not found in mobilvendor", dataGetCustomerBalance);
+            return ApiResponse.response(404, { approved: false, message: "customer not found in mobilvendor" });
+        }
+
+        const controlData = data.records[0];
+        const balanceRecord = data.records.find(
+            (record) =>
+                (record.concepts === "2" || parseFloat(record.credit_limit) > 0) &&
+                record.status === "A" &&
+                record.expired_invoices === "0" &&
+                (creditDays ? parseInt(record.payment_term_days) === parseInt(creditDays) : true)
+        );
+
+        if (!balanceRecord) {
+            Logger.error("customer not found credit", controlData);
+            return ApiResponse.response(404, { approved: false, message: "customer not found credit" });
+        }
+
+        const {
+            balance,
+            status,
+            credit_limit,
+            payment_term_code,
+            payment_term_days,
+            payment_term_description,
+            concepts,
+            expired_invoices,
+        } = balanceRecord;
+
+        const approved =
+            status === "A" &&
+            (concepts === "0" || concepts === "2") &&
+            value <= parseFloat(credit_limit) &&
+            expired_invoices === "0" &&
+            parseFloat(balance) === 0;
+
+        const responseMobilvendor = {
+            approved,
+            withCredit: approved,
+            paymentTerm: payment_term_days || "",
+            maximumCreditAmount: parseFloat(credit_limit) || 0,
+            creditDays: parseInt(payment_term_days) || 0,
+            paymentMethodCode: payment_term_code || "",
+            paymentMethodName: payment_term_description || "",
+            customerWithCredit: approved ?? false
+        };
+
+        Logger.debug({ responseMobilvendor });
+        return responseMobilvendor;
+    }
+
+    /**
+     * Retrieves information about a specific route from the Mobilvendor API.
+     * 
+     * This method first logs in to obtain the necessary session and context IDs. It then sends a POST request to the Mobilvendor API with the route code to retrieve information about the specified route.
+     * 
+     * @param {string} routeCode - The code of the route for which to retrieve information.
+     * @returns {Promise<Object|null>} A promise that resolves to the route information from the Mobilvendor API if successful, or null in case of an error.
+     */
+    async getRoute(routeCode) {
+        try {
+            const { contextId, sessionId } = await this.login();
+            const dataGetRoute = {
+                session_id: sessionId,
+                action: "getRoute",
+                context_id: contextId,
+                route_code: routeCode,
+            };
+            const responseGetRoute = await axios.post(
+                this.FinancialPolicyEcu.configService.url,
+                dataGetRoute
+            );
+
+            return responseGetRoute.data;
+        } catch (error) {
+            Logger.error(error);
+            return null;
+        }
+    }
+
+    /**
+     * Retrieves information about a specific route from the Mobilvendor API.
+     * 
+     * This method first logs in to obtain the necessary session and context IDs. It then sends a POST request to the Mobilvendor API with the route code to retrieve information about the specified route.
+     * 
+     * @param {string} routeCode - The code of the route for which to retrieve information.
+     * @returns {Promise<Object|null>} A promise that resolves to the route information from the Mobilvendor API if successful, or null in case of an error.
+     */
+    async getRoutes() {
+        try {
+            const { contextId, sessionId } = await this.login();
+            const dataGetRoutes = {
+                session_id: sessionId,
+                action: "getRoutes",
+                context_id: contextId,
+            };
+            const responseGetRoutes = await axios.post(
+                this.FinancialPolicyEcu.configService.url,
+                dataGetRoutes
+            );
+
+            return responseGetRoutes.data.records;
+        } catch (error) {
+            Logger.error(error);
+            return null;
+        }
+    }
+}
+
+module.exports = MobilvendorApi;

package/src/integrations/productmultipresentation/ProductMultiPresentation.js

@@ -0,0 +1,200 @@
+const axios = require("axios");
+const VtexApi = require("../../vtex/clients/VtexApi");
+const Logger = require("../../common/utils/logger");
+
+class ProductMultiPresentation {
+    constructor(AccountName, Key, Token, AcronymDistributorVtex, ProductMultiPresentation) {
+        this.AccountName = AccountName;
+        this.Key = Key;
+        this.Token = Token;
+        this.AcronymDistributorVtex = AcronymDistributorVtex;
+        this.ProductMultiPresentation = ProductMultiPresentation;
+    }
+
+    /**
+     * Function per uatentication service external
+     **/
+    async getTokenAuth() {
+        return new Promise(async (response) => {
+            if (this.ProductMultiPresentation?.ServiceAuth && this.ProductMultiPresentation?.ServiceAuth?.Url && this.ProductMultiPresentation?.ServiceAuth?.Url != "") {
+                const url = this.ProductMultiPresentation?.ServiceAuth?.Url;
+                const options = {
+                    method: this.ProductMultiPresentation?.ServiceAuth?.Method ?? 'GET',
+                    headers: this.ProductMultiPresentation?.ServiceAuth?.Headers ?? {},
+                    data: (this.ProductMultiPresentation?.ServiceAuth?.Body ? this.ProductMultiPresentation?.ServiceAuth?.Body : {}),
+                    url
+                };
+
+                try {
+                    const resp = await axios(options);
+                    if (resp?.data) {
+                        response(resp?.data);
+                    } else {
+                        response(null);
+                    }
+                } catch (e) {
+                    Logger.error("error auth ProductMultiPresentation", e);
+                    response(null);
+                }
+            } else {
+                Logger.error("error auth ProductMultiPresentation", "ServiceAuth not found");
+                response(null);
+            }
+
+        });
+    }
+
+    /**
+     * Normalize service extenal headers and body
+     **/
+    async normalizeBodyAndHeaders(AppExternalPresentation, token=null) {
+        let { Body: body, Headers: headers } = AppExternalPresentation;
+
+        if (typeof body === 'object') {
+            for (let property in body) {
+                if (typeof body[property] === 'string') {
+                    try {
+                        body[property] = eval(body[property]);
+                    } catch (errEval) {
+                        Logger.debug("error normalizeBodyAndHeaders", errEval, token);
+                    }
+                }
+            }
+        }
+        if (typeof headers === 'object') {
+            for (let property in headers) {
+                if (typeof headers[property] === 'string') {
+                    try {
+                        headers[property] = eval(headers[property]);
+                    } catch (errEval) {
+                        Logger.debug("error normalizeBodyAndHeaders", errEval, token);
+                    }
+                }
+            }
+        }
+
+        return { body, headers };
+    }
+
+    async getProductList() {
+        let productList = [];
+        try {
+            const { AppExternalPresentation } = this.ProductMultiPresentation;
+            const { Url, Method, DtoProducts, AssignListProduct } = AppExternalPresentation;
+            const token= await this.getTokenAuth();
+            const { body, headers } = await this.normalizeBodyAndHeaders(AppExternalPresentation, token);
+            const response = await axios({
+                url: Url,
+                method: Method ?? 'post',
+                headers: headers,
+                data: JSON.stringify(body)
+            });
+
+            // Se extrae la lista de productos de Geosales obtenida de la petición
+            let products = [];
+            if (AssignListProduct && AssignListProduct !== "") {
+                eval(`products=${AssignListProduct};`);
+            } else {
+                products = response?.data;
+            }
+
+            // Se recorre la lista de productos (si existen elementos)
+            if (products?.length > 0) {
+                // Como la petición puede retornar 2 o más ítems con un mismo SKU, se deben agrupar los mismos priorizando aquellos que cumplan con la condicion "activo=1"
+                let skus = {}, index = 0;
+                for (let product of products) {
+                    const { sku, activo } = product;
+                    if (!skus.hasOwnProperty(sku)) {
+                        // Si el SKU no está en el listado se agrega la información en la lista y se define los datos del índice de array y estado
+                        productList.push(product);
+                        skus[sku] = { index, activo };
+                        index++;
+                    } else {
+                        // Se verifica si el producto de la lista tiene activo=0; pero se encontró un registro con el mismo SKU pero con activo=1, para actualizar los datos del producto
+                        const { index } = skus[sku];
+                        if (skus[sku].activo == '0' && activo == '1') {
+                            productList[index] = product;
+                        }
+                    }
+                }
+            }
+
+            // Si la lista unificada de productos tiene elementos, y se contempla aplicar un transformado de los datos, se actualiza el contenido de la lista
+            if (productList.length && Object.keys(DtoProducts).length > 0) {
+                productList = productList.map(product => {
+                    const formattedProduct = {};
+                    for (const [key, value] of Object.entries(DtoProducts)) {
+                        if (product.hasOwnProperty(value)) {
+                            formattedProduct[key] = product[value];
+                        }
+                    }
+                    return formattedProduct;
+                });
+            }
+        } catch (error) {
+            Logger.error(error);
+        }
+        return productList;
+    }
+
+    async getDistributorList() {
+        try {
+            const vtexApi = new VtexApi(this.AccountName, this.Key, this.Token);
+            const distributors = await vtexApi.fetch(`/dataentities/${this.AcronymDistributorVtex}/search?_fields=_all`, {
+                method: "GET",
+            });
+
+            return distributors?.data?.length > 0 ? distributors.data : [];
+        } catch (error) {
+            Logger.error(error);
+            return [];
+        }
+    }
+
+    async getAllProductsVTEX() {
+        return new Promise(async (res, err) => {
+            let listProductSkus = [];
+            try {
+                const listTradePolicy = this.ProductMultiPresentation?.TradePolicyId?.length > 0 ? this.ProductMultiPresentation?.TradePolicyId : [1];
+                const vtexApi = new VtexApi(this.AccountName, this.Key, this.Token);
+
+                for (let i = 0; i < listTradePolicy.length; i++) {
+                    let stop = false, _from = 0, _to = 49;
+                    while (stop === false) {
+                        try {
+                            const products = await vtexApi.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++) {
+                                    for (let t = 0; t < products.data[j].items.length; t++) {
+                                        let prod = products.data[j].items[t];
+                                        prod.productId = products.data[j].productId;
+                                        prod.TradePolicyId = listTradePolicy[i];
+                                        listProductSkus.push(prod);
+                                    }
+                                }
+                            } else {
+                                stop = true;
+                            }
+                        } catch (error) {
+                            Logger.error("error getAllProductsVTEX while", error);
+                            stop = true;
+                        }
+
+                        _from += 50;
+                        _to += 50;
+                    }
+                }
+
+            } catch (error) {
+                Logger.error("error getAllProductsVTEX", error);
+            }
+
+            res(listProductSkus);
+        });
+    }
+}
+
+module.exports = ProductMultiPresentation;

package/src/mdlz/auth/SecretManagerApi.js

@@ -0,0 +1,77 @@
+const axios = require("axios");
+const Logger = require("../../common/utils/logger");
+
+class SecretManagerApi {
+  constructor(authorization, baseUrl) {
+    if (!authorization || !baseUrl) {
+      throw new Error("Invalid Secret Manager API Credentials");
+    }
+    this.authorization = authorization;
+    this.baseUrl = baseUrl;
+  }
+
+  get baseURL() {
+    return this.baseUrl;
+  }
+
+  /**
+   * Excute a request to Secret Manager API
+   * @param {string} path
+   * @param {import("axios").AxiosRequestConfig} options
+   * @returns {Promise<import("axios").AxiosResponse>}
+   */
+  fetch(path, options, includeFullResponse = true) {
+    const params = {
+      url: `${this.baseURL}/${path}`.replace(/([^:]\/)\/+/g, "$1"),
+      method: options.method || "GET",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: this.authorization,
+        ...options.headers,
+      },
+      data : options.data,
+      ValidateStatus: function (status) {
+        return status >= 200 && status < 300;
+      },
+    };
+    
+    return axios.request(params).then((response) => {
+      if (includeFullResponse) {
+        return response;
+      }
+      return response.data;
+    })
+    .catch((error) => {
+      // error is handled in catch block
+      Logger.error("Error Secret Manager API response: ", params);
+      if (error.response) {
+        // status code out of the range of 2xx
+        Logger.error("Data Secret Manager API response: ", error.response.data);
+        Logger.error("Status Secret Manager API 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 Secret Manager API no response: ", error.request);
+        const errorResponse = {
+          status: 500,
+          data: error.request,
+        };
+        return errorResponse;
+      } else {
+        // Error on setting up the request
+        Logger.error("Error Secret Manager API response: ", error.message);
+        const errorResponse = {
+          status: 500,
+          data: error.message,
+        };
+        return errorResponse;
+      }
+    });
+  }
+}
+
+module.exports = SecretManagerApi;