dcos-core-monalisav2-latam 1.0.0

package/src/integrations/financialPolicy/FinancialPolicyApi.js

@@ -0,0 +1,377 @@
+const axios = require('axios');
+const VtexHelper = require('../../functions/vtex/vtex-helpers');
+const Logger = require("../../common/utils/logger");
+
+/**
+ * Financial Policy API Class for handling client financial operations
+ * @class
+ */
+class FinancialPolicyApi {
+    /**
+     * Constructor for Financial Policy API
+     * @param {string} AccountName - VTEX account name
+     * @param {string} Key - Authentication key
+     * @param {string} Token - Authentication token
+     * @param {string} AcronymClientVtex - Client acronym in VTEX
+     * @param {Object} FinancialPolicyConfig - Configuration for financial policy
+     */
+    constructor(AccountName, Key, Token, AcronymClientVtex, FinancialPolicyConfig) {
+        this.AccountName = AccountName;
+        this.Key = Key;
+        this.Token = Token;
+        this.AcronymClientVtex = AcronymClientVtex;
+        this.config = FinancialPolicyConfig;
+    }
+
+    setConfig(config) {
+        this.config = config;
+    }
+
+    /**
+     * Authenticate with external service
+     * @returns {Promise<string|null>} Authentication token or null
+     * @throws {Error} If authentication fails
+     */
+    async authenticate() {
+        try {
+            const authConfig = this.config?.configService?.serviceAuth;
+            if (!authConfig?.url) return null;
+
+            const { url, method = 'post', headers = {}, body } = authConfig;
+            const response = await axios({
+                url,
+                method: method.toLowerCase(),
+                headers,
+                data: body
+            });
+
+            const tokenPath = authConfig.tokenPath || 'Token';
+            const token = this.getValueByPath(response.data, tokenPath);
+            
+            if (!token) throw new Error(`Authentication failed - token not found at path: ${tokenPath}`);
+            return token;
+        } catch (error) {
+            Logger.error("Authentication error:", error);
+            throw error;
+        }
+    }
+
+    getValueByPath(obj, path) {
+        return path.split('.').reduce((current, key) => current?.[key], obj);
+    }
+
+    applyTransform(value, transformType) {
+        if (!transformType) return value;
+    
+        try {
+            const customTransform = this.config?.transforms?.[transformType];
+            if (customTransform) {
+                return new Function('value', `return ${customTransform}`)(value);
+            }
+    
+            // Usa VtexHelper para transformaciones base
+            return VtexHelper.applyTransform(value, transformType);
+        } catch (error) {
+            Logger.error(`Transform error (${transformType}):`, error);
+            return value;
+        }
+    }
+
+    async getBalanceByClient(params) {
+        try {
+            const token = await this.authenticate();
+            const { url, method = 'post', headers = {}, headerMapping = {}, parameterMapping = {} } = this.config.configService;
+
+            if (!url) throw new Error("Invalid service configuration - URL required");
+            
+            const processedHeaders = {
+                'Content-Type': 'application/json',
+                ...headers,
+                ...this.processHeaderMapping(headerMapping, params, token)
+            };
+            const data = this.processParameterMapping(parameterMapping, params, token);
+            const response = await axios({
+                method: method.toLowerCase(),
+                url,
+                headers: processedHeaders,
+                data
+            });
+
+            return response.data;
+        } catch (error) {
+            Logger.error("Balance error:", error);
+            throw error;
+        }
+    }
+
+    processHeaderMapping(headerMapping, params, token) {
+        return Object.entries(headerMapping).reduce((acc, [key, path]) => {
+            if (key === 'Authorization' && token) {
+                acc[key] = `Bearer ${token}`;
+            } else {
+                const value = this.getValueByPath(params, path);
+                if (value !== undefined) acc[key] = value;
+            }
+            return acc;
+        }, {});
+    }
+
+    processParameterMapping(parameterMapping, params, token) {
+        const mappedData = { Token: token };
+        for (const [key, mappingPath] of Object.entries(parameterMapping)) {
+            if (key === 'Token') continue;
+            // Obtener el path del extractor correspondiente
+            const extractorPath = this.config.parameterExtractors[mappingPath];
+            if (!extractorPath) {
+                continue;
+            }
+            const value = this.getValueByPath(params, extractorPath);
+    
+            if (value !== undefined) {
+                mappedData[key] = value;
+            }
+        }
+        return mappedData;
+    }
+
+    /**
+     * Get client balance information
+     * @param {Object} params - Parameters for balance retrieval
+     * @param {Object} params.orderForm - Order form details
+     * @param {number|null} params.creditDaysParam - Credit days parameter
+     * @param {Object} params.responseMasterDataCT - Master data response
+     * @returns {Promise<Object>} Balance response object
+     * @example
+     * // Expected input
+     * {
+     *   orderForm: { value: 10000 },
+     *   creditDaysParam: 30,
+     *   responseMasterDataCT: {}
+     * }
+     * 
+     * // Expected output
+     * {
+     *   approved: boolean,
+     *   customerWithCredit: boolean,
+     *   paymentTerm: number,
+     *   creditDays: number
+     * }
+     */
+    async getCustomerBalance(orderForm, creditDaysParam, responseMasterDataCT) {
+        try {
+            const params = { orderForm, creditDaysParam, responseMasterDataCT };
+            const requiredParams = this.validateRequiredParams(params);
+            if (!requiredParams.valid) {
+                Logger.error('Missing required params:', requiredParams.missing);
+                return this.getDefaultResponse(false);
+            }
+
+            const balanceData = await this.getBalanceByClient(params);
+            if (this.hasError(balanceData)) return this.getDefaultResponse(false);
+
+            const extractedData = this.extractResponseData(balanceData);
+            const isValid = this.validateExtractedFields(extractedData);
+            if (!isValid) return this.getDefaultResponse(false);
+
+            const isApproved = this.validateResponse(extractedData, params);
+            const formattedResponse = this.formatResponse(extractedData, isApproved, creditDaysParam);
+            return formattedResponse;
+        } catch (error) {
+            Logger.error('Customer balance error:', error);
+            return this.getDefaultResponse(false);
+        }
+    }
+
+    validateRequiredParams(params) {
+        const required = this.config.requiredParameters || [];
+        const missing = required.filter(param => 
+            !this.getValueByPath(params, this.config.parameterExtractors[param])
+        );
+        return { valid: missing.length === 0, missing };
+    }
+
+    hasError(response) {
+        return this.config.errorPath ? 
+            Boolean(this.getValueByPath(response, this.config.errorPath)) : 
+            false;
+    }
+
+    extractResponseData(response) {
+        const { responsePaths, fieldTransforms = {} } = this.config;
+        if (!response || !responsePaths) return this.getDefaultResponse(false);
+
+        try {
+            return Object.entries(responsePaths).reduce((acc, [field, path]) => {
+                const rawValue = this.getValueByPath(response, path);
+                const transform = fieldTransforms[field];
+                acc[field] = rawValue !== undefined ?
+                    (transform ? this.applyTransform(rawValue, transform) : rawValue) :
+                    this.getDefaultValueForField(field);
+                return acc;
+            }, {});
+        } catch (error) {
+            Logger.error('Data extraction error:', error);
+            return this.getDefaultResponse(false);
+        }
+    }
+
+    validateExtractedFields(data) {
+        if (!data || typeof data !== 'object') return false;
+        const { fieldValidations = {} } = this.config;
+
+        return Object.entries(fieldValidations).every(([field, validation]) => {
+            if (!(field in data)) return true;
+            try {
+                const validationFunction = new Function('value', `return ${validation}`);
+                return validationFunction(data[field]);
+            } catch (error) {
+                Logger.error(`Validation error for ${field}:`, error);
+                return false;
+            }
+        });
+    }
+
+    validateResponse(data, context) {
+        const { validationTransforms = {} } = this.config;
+        const format = context.creditDaysParam === null ? 'get' : 'assign';
+        const validationData = this.config.responseFormats[format].validationData;
+    
+        if (!validationData) return false;
+    
+        try {
+            const validationContext = this.prepareValidationContext(data, context, validationTransforms);
+            const validationFunction = new Function(
+                ...Object.keys(validationContext),
+                `return ${validationData}`
+            );
+            return validationFunction(...Object.values(validationContext)) ?? false;
+        } catch (error) {
+            Logger.error('Validation error:', error);
+            return false;
+        }
+    }
+
+    prepareValidationContext(data, context, transforms) {
+        const transformedData = {};
+        const baseTransforms = {
+            toString: value => String(value || ''),
+            toNumber: value => Number(value || 0),
+            toBoolean: value => Boolean(value),
+            toOrderValue: value => Number(value || 0) / 100
+        };
+    
+        // Transforma datos de respuesta API
+        Object.entries(data).forEach(([key, value]) => {
+            const transform = transforms[key];
+            transformedData[key] = transform ? 
+                baseTransforms[transform](value) : 
+                value;
+        });
+    
+        // Extrae y transforma orderValue
+        const orderValue = baseTransforms.toOrderValue(context.orderForm?.value);
+    
+        return {
+            ...transformedData,
+            orderValue,
+            creditDaysParam: context.creditDaysParam !== null ?
+                baseTransforms.toNumber(context.creditDaysParam) :
+                null
+        };
+    }
+
+    transformFields(data, transforms) {
+        return Object.entries(data).reduce((acc, [key, value]) => {
+            acc[key] = transforms[key] ? this.applyTransform(value, transforms[key]) : value;
+            return acc;
+        }, {});
+    }
+
+    getDefaultValueForField(field) {
+        const defaultValue = this.config?.jsonDefault?.fields?.[field];
+        if (defaultValue === undefined) return null;
+    
+        // Manejo especial para booleanos y números
+        if (field === 'approved' || field === 'withCredit') return Boolean(defaultValue === 'true');
+        if (field === 'paymentTerm' || field === 'creditDays' || field === 'maximumCreditAmount') {
+            return Number(defaultValue) || 0;
+        }
+        
+        return defaultValue;
+    }
+
+    getDefaultResponse(approved = false) {
+        const defaultFields = this.config?.jsonDefault?.fields || {};
+        
+        return Object.entries(defaultFields).reduce((response, [field, defaultValue]) => {
+            response[field] = field === 'approved' || field === 'withCredit' ?
+                Boolean(approved) :
+                this.getDefaultValueForField(field);
+            return response;
+        }, {});
+    }
+
+    formatResponse(data, isApproved, creditDaysParam) {
+        const format = creditDaysParam === null ?
+            this.config.responseFormats.get :
+            this.config.responseFormats.assign;
+    
+        return Object.entries(format.mapping).reduce((acc, [key, config]) => {
+            if (creditDaysParam === null && key === 'withCredit') {
+                // Solo retorna customerWithCredit como true si pasa todas las validaciones
+                acc['customerWithCredit'] = isApproved && this.applyTransform(data[config.field], config.type);
+            } else {
+                const value = config.field === 'approved' ? isApproved : data[config.field];
+                acc[key] = this.applyTransform(value, config.type);
+            }
+            return acc;
+        }, {});
+    }
+
+    // VTEX Helper Methods
+    /**
+     * Retrieve order form by ID from VTEX
+     * @param {string} orderFormId - Unique identifier for order form
+     * @returns {Promise<Object>} Order form details
+     */
+    async getOrderFormById(orderFormId) {
+        return VtexHelper.getOrderFormById(orderFormId, this.AccountName, this.Key, this.Token);
+    }
+
+    /**
+     * Retrieve client information by email
+     * @param {string} email - Client email address
+     * @returns {Promise<Object>} Client details
+     */
+    async getClientById(email) {
+        return VtexHelper.getClientById(email, this.AccountName, this.Key, this.Token, this.AcronymClientVtex);
+    }
+
+    /**
+     * Delete custom data from order form
+     * @param {string} orderFormId - Order form identifier
+     * @param {Object} customData - Custom data to delete
+     * @returns {Promise<Object>} Deletion result
+     */
+    async deleteCustomData(orderFormId, customData) {
+        return VtexHelper.deleteCustomData(
+            orderFormId, this.AccountName, this.Key, this.Token,
+            this.config?.configVtex, this.config?.attachmentCredit, customData
+        );
+    }
+
+    /**
+     * Update order form custom data
+     * @param {string} orderFormId - Order form identifier
+     * @param {string} idConfigVtex - VTEX configuration ID
+     * @param {Object} customData - Custom data to update
+     * @returns {Promise<Object>} Update result
+     */
+    async updateOrderFormCustomData(orderFormId, idConfigVtex, customData) {
+        return VtexHelper.updateOrderFormCustomData(
+            orderFormId, this.AccountName, this.Key, this.Token, idConfigVtex, customData, this.config.attachmentCredit
+        );
+    }
+}
+
+module.exports = FinancialPolicyApi;