dcos-core-monalisav2-latam 1.0.0

package/src/integrations/accountErrors/AccountErrorManager.js

@@ -0,0 +1,437 @@
+const DynamoAWS = require("aws-sdk/clients/dynamodb");
+const Logger = require("../../common/utils/logger");
+
+const ACCOUNT_ERRORS_TABLE = process.env.ACCOUNT_ERRORS_TABLE;
+
+class AccountErrorManager {
+
+    /**
+     * Crea una respuesta de error con formato estándar
+     * @param {string} errorCode - Código de error (ej: 'ACCOUNT_001')
+     * @param {Object} replacements - Valores para reemplazar en el mensaje (opcional)
+     * @returns {Promise<Object>} Respuesta de error formateada
+     */
+    static async createResponse(errorCode, replacements = {}) {
+        try {
+            const errorInfo = await this.getError(errorCode);
+
+            if (!errorInfo) {
+                // ✅ MEJORADO: Fallback más robusto con logging
+                Logger.warn(`Error code ${errorCode} not found in database, using fallback`);
+                
+                // Categorías conocidas de errores para fallback inteligente
+                const errorCategories = {
+                    'ACCOUNT_': { status: 400, category: 'Account Management' },
+                    'VTEX_': { status: 500, category: 'VTEX Integration' },
+                    'AUTH_': { status: 401, category: 'Authentication' },
+                    'PERM_': { status: 403, category: 'Permissions' },
+                    'VALID_': { status: 400, category: 'Validation' }
+                };
+
+                // Determinar status code basado en el prefijo del código
+                let httpStatus = 500;
+                let category = 'Unknown';
+                
+                for (const [prefix, config] of Object.entries(errorCategories)) {
+                    if (errorCode.startsWith(prefix)) {
+                        httpStatus = config.status;
+                        category = config.category;
+                        break;
+                    }
+                }
+
+                return {
+                    statusCode: httpStatus,
+                    body: JSON.stringify({
+                        error: errorCode,
+                        message: `Error ${errorCode}: Operation failed. Please contact support if this issue persists.`,
+                        category: category,
+                        fallback: true // Flag para indicar que es fallback
+                    }, null, 2),
+                    headers: {
+                        "Content-Type": "application/json"
+                    }
+                };
+            }
+
+            // Reemplazar variables en el mensaje si se proporcionan
+            let message = errorInfo.Message;
+            Object.keys(replacements).forEach(key => {
+                const placeholder = `{${key}}`;
+                message = message.replace(new RegExp(placeholder.replace(/[{}]/g, '\\$&'), 'g'), replacements[key]);
+            });
+
+            return {
+                statusCode: errorInfo.HttpStatus,
+                body: JSON.stringify({
+                    error: errorCode,
+                    message: message,
+                    category: errorInfo.Category,
+                    severity: errorInfo.Severity
+                }, null, 2),
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            };
+
+        } catch (error) {
+            Logger.error("Error creating response:", error);
+            
+            // ✅ MEJORADO: Fallback de emergencia más informativo
+            return {
+                statusCode: 500,
+                body: JSON.stringify({
+                    error: errorCode || 'SYSTEM_ERROR',
+                    message: "A system error occurred while processing your request. Please contact support.",
+                    category: "System Error",
+                    emergency_fallback: true,
+                    timestamp: new Date().toISOString()
+                }, null, 2),
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            };
+        }
+    }
+
+    /**
+     * Obtiene un error específico por código
+     * @param {string} errorCode - Código del error
+     * @returns {Promise<Object|null>} Información del error
+     */
+    static async getError(errorCode) {
+        try {
+            if (!ACCOUNT_ERRORS_TABLE) {
+                Logger.error("ACCOUNT_ERRORS_TABLE environment variable not set");
+                return null;
+            }
+
+            const dynamodb = new DynamoAWS.DocumentClient();
+            const params = {
+                TableName: ACCOUNT_ERRORS_TABLE,
+                Key: { ErrorCode: errorCode }
+            };
+
+            const result = await dynamodb.get(params).promise();
+            return result.Item || null;
+        } catch (error) {
+            Logger.error(`Error getting error ${errorCode}:`, error);
+            return null;
+        }
+    }
+
+    /**
+     * Lista todos los errores con filtros opcionales
+     * @param {Object} filters - Filtros para la consulta
+     * @returns {Promise<Object>} Lista de errores
+     */
+    static async listErrors(filters = {}) {
+        try {
+            if (!ACCOUNT_ERRORS_TABLE) {
+                throw new Error("ACCOUNT_ERRORS_TABLE environment variable not set");
+            }
+
+            const dynamodb = new DynamoAWS.DocumentClient();
+            let params = {
+                TableName: ACCOUNT_ERRORS_TABLE,
+                Limit: filters.limit || 100
+            };
+
+            // Filtrar por categoría si se especifica
+            if (filters.category) {
+                params.IndexName = "CategoryIndex";
+                params.KeyConditionExpression = "Category = :category";
+                params.ExpressionAttributeValues = {
+                    ":category": filters.category
+                };
+
+                const result = await dynamodb.query(params).promise();
+                return {
+                    items: result.Items,
+                    lastEvaluatedKey: result.LastEvaluatedKey,
+                    count: result.Count
+                };
+            }
+
+            // Filtrar por severidad si se especifica
+            if (filters.severity) {
+                params.IndexName = "SeverityIndex";
+                params.KeyConditionExpression = "Severity = :severity";
+                params.ExpressionAttributeValues = {
+                    ":severity": filters.severity
+                };
+
+                const result = await dynamodb.query(params).promise();
+                return {
+                    items: result.Items,
+                    lastEvaluatedKey: result.LastEvaluatedKey,
+                    count: result.Count
+                };
+            }
+
+            // Scan completo si no hay filtros específicos
+            if (filters.lastEvaluatedKey) {
+                params.ExclusiveStartKey = JSON.parse(filters.lastEvaluatedKey);
+            }
+
+            const result = await dynamodb.scan(params).promise();
+            return {
+                items: result.Items,
+                lastEvaluatedKey: result.LastEvaluatedKey,
+                count: result.Count
+            };
+
+        } catch (error) {
+            Logger.error("Error listing errors:", error);
+            throw error;
+        }
+    }
+
+    /**
+     * Crea un nuevo error
+     * @param {Object} errorData - Datos del error
+     * @returns {Promise<Object>} Error creado
+     */
+    static async createError(errorData) {
+        try {
+            if (!ACCOUNT_ERRORS_TABLE) {
+                throw new Error("ACCOUNT_ERRORS_TABLE environment variable not set");
+            }
+
+            const dynamodb = new DynamoAWS.DocumentClient();
+
+            // Validar campos requeridos
+            const requiredFields = ['ErrorCode', 'HttpStatus', 'Message', 'Category', 'Severity'];
+            for (const field of requiredFields) {
+                if (!errorData[field]) {
+                    throw new Error(`${field} is required`);
+                }
+            }
+
+            // Verificar que el error no exista
+            const existingError = await this.getError(errorData.ErrorCode);
+            if (existingError) {
+                throw new Error(`Error code ${errorData.ErrorCode} already exists`);
+            }
+
+            const params = {
+                TableName: ACCOUNT_ERRORS_TABLE,
+                Item: {
+                    ErrorCode: errorData.ErrorCode,
+                    HttpStatus: errorData.HttpStatus,
+                    Message: errorData.Message,
+                    Description: errorData.Description || '',
+                    Category: errorData.Category,
+                    Severity: errorData.Severity,
+                    PossibleCauses: errorData.PossibleCauses || [],
+                    Solutions: errorData.Solutions || [],
+                    RelatedFields: errorData.RelatedFields || [],
+                    RelatedTables: errorData.RelatedTables || [],
+                    RelatedEndpoints: errorData.RelatedEndpoints || [],
+                    CreatedAt: new Date().toISOString(),
+                    UpdatedAt: new Date().toISOString()
+                }
+            };
+
+            await dynamodb.put(params).promise();
+            return params.Item;
+
+        } catch (error) {
+            Logger.error("Error creating error:", error);
+            throw error;
+        }
+    }
+
+    /**
+     * Actualiza un error existente
+     * @param {string} errorCode - Código del error
+     * @param {Object} errorData - Nuevos datos del error
+     * @returns {Promise<Object>} Error actualizado
+     */
+    static async updateError(errorCode, errorData) {
+        try {
+            if (!ACCOUNT_ERRORS_TABLE) {
+                throw new Error("ACCOUNT_ERRORS_TABLE environment variable not set");
+            }
+
+            const dynamodb = new DynamoAWS.DocumentClient();
+
+            // Verificar que el error existe
+            const existingError = await this.getError(errorCode);
+            if (!existingError) {
+                throw new Error(`Error code ${errorCode} not found`);
+            }
+
+            // Construir UpdateExpression dinámicamente
+            const updateFields = ['HttpStatus', 'Message', 'Description', 'Category', 'Severity',
+                'PossibleCauses', 'Solutions', 'RelatedFields', 'RelatedTables', 'RelatedEndpoints'];
+
+            let updateExpression = 'SET UpdatedAt = :updatedAt';
+            const expressionAttributeNames = {};
+            const expressionAttributeValues = {
+                ':updatedAt': new Date().toISOString()
+            };
+            const updates = [];
+
+            updateFields.forEach(field => {
+                if (errorData[field] !== undefined) {
+                    const attributeName = `#${field}`;
+                    const attributeValue = `:${field}`;
+                    updates.push(`${attributeName} = ${attributeValue}`);
+                    expressionAttributeNames[attributeName] = field;
+                    expressionAttributeValues[attributeValue] = errorData[field];
+                }
+            });
+
+            if (updates.length > 0) {
+                updateExpression += ', ' + updates.join(', ');
+            }
+
+            const params = {
+                TableName: ACCOUNT_ERRORS_TABLE,
+                Key: { ErrorCode: errorCode },
+                UpdateExpression: updateExpression,
+                ExpressionAttributeNames: Object.keys(expressionAttributeNames).length > 0 ? expressionAttributeNames : undefined,
+                ExpressionAttributeValues: expressionAttributeValues,
+                ReturnValues: 'ALL_NEW'
+            };
+
+            const result = await dynamodb.update(params).promise();
+            return result.Attributes;
+
+        } catch (error) {
+            Logger.error(`Error updating error ${errorCode}:`, error);
+            throw error;
+        }
+    }
+
+    /**
+     * Elimina un error
+     * @param {string} errorCode - Código del error
+     * @returns {Promise<boolean>} Éxito de la eliminación
+     */
+    static async deleteError(errorCode) {
+        try {
+            if (!ACCOUNT_ERRORS_TABLE) {
+                throw new Error("ACCOUNT_ERRORS_TABLE environment variable not set");
+            }
+
+            const dynamodb = new DynamoAWS.DocumentClient();
+
+            // Verificar que el error existe
+            const existingError = await this.getError(errorCode);
+            if (!existingError) {
+                throw new Error(`Error code ${errorCode} not found`);
+            }
+
+            const params = {
+                TableName: ACCOUNT_ERRORS_TABLE,
+                Key: { ErrorCode: errorCode }
+            };
+
+            await dynamodb.delete(params).promise();
+            return true;
+
+        } catch (error) {
+            Logger.error(`Error deleting error ${errorCode}:`, error);
+            throw error;
+        }
+    }
+
+    /**
+     * ✅ NUEVO: Inicializar errores básicos del sistema
+     * @returns {Promise<Array>} Resultados de la inicialización
+     */
+    static async initializeBasicErrors() {
+        const basicErrors = [
+            {
+                ErrorCode: 'ACCOUNT_001',
+                HttpStatus: 400,
+                Message: 'Request body is required',
+                Category: 'Validation',
+                Severity: 'Medium',
+                Description: 'The request body is missing or empty'
+            },
+            {
+                ErrorCode: 'ACCOUNT_026',
+                HttpStatus: 500,
+                Message: 'Internal server error occurred',
+                Category: 'System',
+                Severity: 'High',
+                Description: 'An unexpected system error occurred'
+            },
+            {
+                ErrorCode: 'SYSTEM_ERROR',
+                HttpStatus: 500,
+                Message: 'System error occurred',
+                Category: 'System',
+                Severity: 'Critical',
+                Description: 'Emergency fallback error'
+            }
+        ];
+
+        const results = [];
+        for (const errorData of basicErrors) {
+            try {
+                // Solo crear si no existe
+                const existing = await this.getError(errorData.ErrorCode);
+                if (!existing) {
+                    await this.createError(errorData);
+                    results.push({ errorCode: errorData.ErrorCode, status: 'created' });
+                } else {
+                    results.push({ errorCode: errorData.ErrorCode, status: 'exists' });
+                }
+            } catch (error) {
+                results.push({ 
+                    errorCode: errorData.ErrorCode, 
+                    status: 'failed', 
+                    error: error.message 
+                });
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Migra errores desde JSON a DynamoDB (para uso inicial)
+     * @param {Object} jsonErrors - Errores del JSON original
+     * @returns {Promise<Array>} Resultados de la migración
+     */
+    static async migrateFromJson(jsonErrors) {
+        try {
+            const results = [];
+            const errors = jsonErrors.accountErrorCodes.errors;
+
+            for (const [errorCode, errorInfo] of Object.entries(errors)) {
+                try {
+                    const errorData = {
+                        ErrorCode: errorCode,
+                        HttpStatus: errorInfo.httpStatus,
+                        Message: errorInfo.message,
+                        Description: errorInfo.description || '',
+                        Category: errorInfo.category,
+                        Severity: errorInfo.severity,
+                        PossibleCauses: errorInfo.possibleCauses || [],
+                        Solutions: errorInfo.solutions || [],
+                        RelatedFields: errorInfo.relatedFields || [],
+                        RelatedTables: errorInfo.relatedTables || [],
+                        RelatedEndpoints: errorInfo.relatedEndpoints || []
+                    };
+
+                    await this.createError(errorData);
+                    results.push({ errorCode, status: 'success' });
+                } catch (error) {
+                    results.push({ errorCode, status: 'failed', error: error.message });
+                }
+            }
+
+            return results;
+        } catch (error) {
+            Logger.error("Error migrating from JSON:", error);
+            throw error;
+        }
+    }
+}
+
+module.exports = AccountErrorManager;

package/src/integrations/audience/Audience.js

@@ -0,0 +1,70 @@
+const VtexApi = require("../../vtex/clients/VtexApi");
+const Logger = require("../../common/utils/logger");
+
+class AudiencePrice {
+    constructor(AccountName, Key, Token) {
+        this.AccountName = AccountName;
+        this.Key = Key;
+        this.Token = Token;
+    }
+    
+    async getAudiencePriceById(audienceId) {
+        try {
+            const vtexApi = new VtexApi(this.AccountName, this.Key, this.Token);
+            const response = await vtexApi.fetch(`/price-table-mapper/pvt/mapping/${audienceId}`, {
+                method: "GET",
+            });
+
+            return response.data;
+        } catch (error) {
+            Logger.error("Error getting audience price: ", error);
+            return error;
+        }
+    }
+
+    async deleteAudiencePriceById(audienceId) {
+        try {
+            const vtexApi = new VtexApi(this.AccountName, this.Key, this.Token);
+            const response = await vtexApi.fetch(`/price-table-mapper/pvt/mapping/${audienceId}`, {
+                method: "DELETE",
+            });
+
+            return response.data;
+        } catch (error) {
+            Logger.error("Error deleting audience price: ", error);
+            return error;
+        }
+    }
+
+    async updateAudiencePriceById(audienceId, data) {
+        try {
+            const vtexApi = new VtexApi(this.AccountName, this.Key, this.Token);
+            await vtexApi.fetch(`/price-table-mapper/pvt/mapping/${audienceId}`, {
+                method: "PUT",
+                data,
+            });
+
+            return true;
+        } catch (error) {
+            Logger.error(error);
+            return false;
+        }
+    }
+
+    async createAudiencePrice(email) {
+        try {
+            const vtexApi = new VtexApi(this.AccountName, this.Key, this.Token);
+            const audienceResponse = await vtexApi.fetch(`/audience-manager/pvt/audience`, {
+                method: "POST",
+                data: { email: email },
+            });
+
+            return audienceResponse.data[0] ?? null;
+        } catch (error) {
+            Logger.error("Error creating audience: ", error);
+            return error;
+        }
+    }
+}
+
+module.exports = AudiencePrice;