dcos-core-monalisav2-latam 1.0.0

package/src/functions/notifications/download-leads-handler.js

@@ -0,0 +1,67 @@
+const VtexApi = require("../../vtex/clients/VtexApi");
+const AccountData = require("../../entities/account");
+const ApiResponse = require("../../common/utils/api-response");
+const jwt = require('jsonwebtoken');
+const Logger = require("../../common/utils/logger");
+
+const SECRET_KEY = process.env.JWT_SECRET || 'your-secret-key';
+const handler = async (event) => {
+    try {
+        const { token } = event.queryStringParameters;
+        const { accountName, fileId, entity } = decryptUrlParams(token);
+        
+        if (!accountName || !fileId) {
+            return ApiResponse.response(400, {
+                success: false,
+                message: "Missing required parameters"
+            });
+        }
+        //Obtener configuración de cuenta
+        const configAccount = await AccountData.getAccountDataByAccountName(accountName);
+        if (!configAccount?.NewLeadsNotification) {
+            return ApiResponse.response(404, {
+                success: false,
+                message: "Account configuration not found"
+            });
+        }
+        const vtexApi = new VtexApi(
+            configAccount.AccountName,
+            configAccount.Credentials.key,
+            configAccount.Credentials.token
+        );
+
+        const fileData = await vtexApi.fetch(
+            `/dataentities/${configAccount.NewLeadsNotification.fileUploadEntity}/search?_fields=_all&id=${fileId}`,
+            { 
+                method: 'GET',
+                headers: {
+                    'Cache-Control': 'no-cache',
+                    'Content-Type': 'application/json',
+                    'REST-Range': 'resources=0-1'
+                }
+            }
+        );
+        return {
+            statusCode: 200,
+            headers: {
+                'Content-Type': 'text/csv',
+                'Content-Disposition': `attachment; filename="${fileData.data[0].fileName}"`,
+            },
+            body: fileData.data[0].fileContent
+        };
+    } catch (error) {
+        Logger.error('Download error:', error);
+        return ApiResponse.response(500, {
+            success: false,
+            message: "Error downloading file",
+            error: error.message,
+            id: fileId
+        });
+    }
+};
+
+function decryptUrlParams(token) {
+    return jwt.verify(token, SECRET_KEY);
+}
+
+module.exports = { handler };

package/src/functions/notifications/new-leads-notification-consumer.js

@@ -0,0 +1,17 @@
+const AccountData = require("../../entities/account");
+const { handler: newLeadsHandler } = require("./new-leads-notification-handler");
+
+exports.processNewLeadsNotification = async (accountName, actionProcess, values) => {
+    const accountConfig = await AccountData.getAccountDataByAccountName(accountName);
+    if (!accountConfig) {
+        throw new Error("Account configuration not found");
+    }
+
+    if (actionProcess === 'new-leads') {
+        await newLeadsHandler({
+            source: 'cron',
+            accountName,
+            ...values
+        });
+    }
+};

package/src/functions/notifications/new-leads-notification-handler.js

@@ -0,0 +1,359 @@
+//new-leads-notification-handler.js
+const VtexHelper = require("../vtex/vtex-helpers");
+const VtexApi = require("../../vtex/clients/VtexApi");
+const ApiResponse = require("../../common/utils/api-response");
+const AccountData = require("../../entities/account");
+const ClientData = require("../../entities/clients");
+const { calculateDateRange } = require("../../common/utils/date-range-calculator");
+const jwt = require('jsonwebtoken');
+const Logger = require("../../common/utils/logger");
+
+const SECRET_KEY = process.env.JWT_SECRET || 'your-secret-key';
+const BASE_URL_API = `https://${process.env.BASE_URL_API}${(process.env.ENV_URL_API == 'prod' ? '' : `/${process.env.ENV_URL_API}`)}` || 'https://localhost:3000';
+
+const handler = async (event) => {
+    try {
+        let accountName, configAccount;
+        const accountHttp = event?.pathParameters?.an ?? null;
+
+        if (event.source === 'cron') {
+            accountName = event.accountName;
+        } else if(accountHttp){
+            accountName = accountHttp;
+        }
+
+        if (!accountName) {
+            return ApiResponse.response(400, { 
+                success: false, 
+                message: "AccountName is Required" 
+            });
+        }
+
+        configAccount = await AccountData.getAccountDataByAccountName(accountName);
+        if (!configAccount) {
+            return ApiResponse.response(400, { success: false, message: "Account not found" });
+        }
+
+        const newLeadsConfig = configAccount.NewLeadsNotification;
+        const configValidation = VtexHelper.validateLeadsConfig(newLeadsConfig);
+        
+        if (!configValidation.isValid) {
+            return ApiResponse.response(400, { 
+                success: false, 
+                message: "Invalid leads configuration", 
+                errors: configValidation.errors 
+            });
+        }
+
+        const vtexApi = new VtexApi(
+            configAccount.AccountName,
+            configAccount.Credentials.key,
+            configAccount.Credentials.token
+        );
+
+        const dateRange = calculateDateRange(
+            newLeadsConfig.rangeQuery, 
+            newLeadsConfig.rangeValue
+        );
+
+        const currentDate = new Date().toISOString();
+        const fileName = `new-leads-${newLeadsConfig.fileUploadEntity}-${currentDate}.csv`;
+
+        const leads = await getLeadsFromMasterData(
+            vtexApi, 
+            newLeadsConfig.newLeadsEntity, 
+            dateRange,
+            configAccount
+        );
+
+        if (!leads || leads.length === 0) {
+            return ApiResponse.response(200, { 
+                success: true, 
+                message: "No new leads found in the specified date range" 
+            });
+        }
+
+        // Crear documento con CSV
+        const document = await createLeadsDocument(vtexApi, newLeadsConfig, leads, dateRange, fileName);
+        
+        // Generar URL
+        const downloadUrl = generatePublicDownloadUrl(
+            configAccount.AccountName,
+            document.documentId,
+            newLeadsConfig.fileUploadEntity
+        );
+
+        // Actualizar documento con URL y enviar notificación
+        await sendNotification(vtexApi, configAccount, downloadUrl, dateRange, fileName, document.fileContent, document.documentId);
+
+        return ApiResponse.response(200, {
+            success: true,
+            message: "New leads notification processed successfully",
+            data: {
+                leadsCount: leads.length,
+                downloadUrl,
+                dateRange,
+                documentId: document.documentId, 
+                metadata: {
+                    accountName: configAccount.AccountName,
+                    entity: newLeadsConfig.newLeadsEntity,
+                    expirationTime: newLeadsConfig.ExpirationTimeFile
+                }
+            }
+        });
+
+    } catch (error) {
+        return ApiResponse.response(500, {
+            success: false,
+            message: "Error processing new leads notification",
+            error: error.message
+        });
+    }
+};
+
+async function getLeadsFromMasterData(vtexApi, entity, dateRange, configAccount) {
+    const config = configAccount.NewLeadsNotification;
+    const leads = [];
+    let stopApi = false;
+    let scrollToken = null;
+    let page = 1;
+
+    while (!stopApi) {
+        try {
+            const listLeads = await getLeadsSearchAllVTEX({
+                vtexApi: vtexApi,
+                entity: entity,
+                _fields: config.fields,
+                size: config.ScrollSize,
+                page: page,
+                scroll: true,
+                scrollToken: scrollToken,
+                dateField: config.dateField,
+                startDate: dateRange.startDate,
+                endDate: dateRange.endDate,
+                config: config
+            });
+
+            if (listLeads && listLeads?.data && listLeads?.data?.length > 0) {
+                leads.push(...listLeads.data);
+
+                if (!listLeads.scrollToken) {
+                    scrollToken = null;
+                    stopApi = true;
+                } else {
+                    scrollToken = listLeads.scrollToken;
+                    page++;
+                }
+
+                // Opcional: Detener si se alcanza el máximo de solicitudes de scroll
+                if (page > config.MaxScrollRequests) {
+                    stopApi = true;
+                }
+            } else {
+                stopApi = true;
+            }
+        } catch (error) {
+            Logger.error(`Error al recuperar lote de leads: ${error.message}`);
+            stopApi = true;
+        }
+    }
+
+    return leads;
+}
+
+async function getLeadsSearchAllVTEX({
+    vtexApi,
+    entity = 'CT', 
+    _fields = "_all", 
+    size = 1000, 
+    page = 1, 
+    scroll = false, 
+    scrollToken = null,
+    dateField = null,
+    startDate = null,
+    endDate = null,
+    config = {}
+}) {
+    if (!vtexApi) {
+        return null;
+    }
+
+    const endpoint = scroll ? '/scroll' : '/search';
+    const url = `/dataentities/${entity}${endpoint}?_fields=${_fields}`;
+
+    const requestOptions = {
+        method: 'GET',
+        headers: {
+            'Cache-Control': 'no-cache'
+        }
+    };
+
+    // Agregar filtro de rango de fechas
+    if (dateField && startDate && endDate) {
+        let whereClause = `${dateField} between ${startDate} AND ${endDate}`;
+        
+        // Agregar validación de campo duplicado si existe
+        if (config?.duplicateField) {
+            whereClause += ` AND ${config.duplicateField} is null`;
+        }
+    
+        requestOptions.params = {
+            ...(requestOptions.params || {}),
+            _where: whereClause
+        };
+    }
+
+    if (scroll === false) {
+        requestOptions.headers['REST-Range'] = `resources=${(page > 1 ? ((parseFloat(page)*parseFloat(size))+1) : 0)}-${(page > 1 ? (parseFloat((page+1))*parseFloat(size)) : size)}`;
+    } else if (scroll === true && typeof scrollToken === 'string') {
+        requestOptions.params = {
+            ...(requestOptions.params || {}),
+            _token: scrollToken
+        };
+    } else {
+        requestOptions.params = {
+            ...(requestOptions.params || {}),
+            _size: size
+        };
+    }
+
+    try {
+        const response = await vtexApi.fetch(url, requestOptions);
+        
+        return {
+            data: response.data,
+            page: response.data?.length === 0 ? null : (parseInt(page) + 1),
+            scrollToken: response.headers['x-vtex-md-token'] || null
+        };
+    } catch (error) {
+        Logger.error('Error en getLeadsSearchAllVTEX:', error);
+        throw error;
+    }
+}
+
+function transformLeadFields(lead, leadMap) {
+    if (!lead || typeof lead !== 'object') return {};
+    if (!leadMap || typeof leadMap !== 'object') return {};
+
+    const transformedLead = {};
+
+    for (const [csvHeader, mapConfig] of Object.entries(leadMap)) {
+        let value = '';
+
+        try {
+            if (typeof mapConfig === 'string') {
+                value = lead[mapConfig] ?? '';
+            } else if (typeof mapConfig === 'object' && mapConfig !== null) {
+                if (!mapConfig.field) continue;
+
+                if (Array.isArray(mapConfig.field)) {
+                    const fieldValues = mapConfig.field
+                        .map(field => {
+                            const fieldValue = lead[field];
+                            return fieldValue != null ? String(fieldValue).trim() : '';
+                        })
+                        .filter(Boolean);
+                    value = fieldValues.length > 0 ? fieldValues.join(' ') : '';
+                } else {
+                    value = lead[mapConfig.field] ?? '';
+                }
+
+                if (mapConfig.transform) {
+                    try {
+                        const transformResult = new Function('value', `return ${mapConfig.transform}`)(value);
+                        value = transformResult ?? value;
+                    } catch (transformError) {
+                        Logger.error(`Transform error for ${csvHeader}: ${transformError.message}`);
+                    }
+                }
+            }
+
+            value = value !== null && value !== undefined ? String(value).trim() : '';
+            
+            if (typeof value === 'string' && value.includes(',')) {
+                value = `"${value.replace(/"/g, '""')}"`;
+            }
+
+            transformedLead[csvHeader] = value;
+
+        } catch (error) {
+            Logger.error(`Error processing ${csvHeader}: ${error.message}`);
+            transformedLead[csvHeader] = '';
+        }
+    }
+
+    return transformedLead;
+}
+
+async function createLeadsDocument(vtexApi, config, leads, dateRange, fileName) {
+    const formattedLeads = leads.map(lead => transformLeadFields(lead, config.leadMap));
+    const uniqueDocumentId = `${config.fileUploadEntity}-${Math.random().toString(36).slice(2, 11)}`;;
+    const currentDate = new Date().toISOString();
+
+    const headers = Object.keys(config.leadMap);
+    const csvRows = [headers.join(',')]; // Header row
+
+    formattedLeads.forEach(lead => {
+        const row = headers.map(header => {
+            const value = lead[header] || '';
+            // Escapar comas y comillas en valores
+            return `"${String(value).replace(/"/g, '""')}"`;
+        });
+        csvRows.push(row.join(','));
+    });
+
+    const csvContent = csvRows.join('\n');
+
+    const documentSave = {
+        documentId: uniqueDocumentId,
+        fileName,
+        fileContent: csvContent,
+        downloadUrl: null,
+        generationDate: currentDate
+    };
+
+    return documentSave;
+}
+
+function encryptUrlParams(params) {
+    return jwt.sign(params, SECRET_KEY);
+}
+
+function generatePublicDownloadUrl(accountName, fileId, entity) {
+    const params = { accountName, fileId, entity };
+    const token = encryptUrlParams(params);
+    return `${BASE_URL_API}/new-leads/download?token=${token}`;
+}
+
+async function sendNotification(vtexApi, config, downloadUrl, dateRange, fileName, fileContent, documentId) {
+    const currentDate = new Date().toISOString();
+    const { fileUploadEntity, schema = '' } = config.NewLeadsNotification;
+
+    const document = {
+        id: documentId,
+        downloadUrl,
+        generationDate: currentDate,
+        fileName,
+        fileContent
+    };
+
+    // Construir URL asegurando que termine con /
+    const baseUrl = `/dataentities/${fileUploadEntity}/documents/`;
+    const url = schema ? `${baseUrl}?_schema=${schema}` : baseUrl;
+    const response = await vtexApi.fetch(url,
+        {
+            method: 'PATCH',
+            data: document,
+            headers: {
+                'Cache-Control': 'no-cache',
+                'Content-Type': 'application/json'
+            }
+        }
+    );
+
+    if (response.status >= 400) {
+        throw new Error(`Failed to update notification document. Status: ${response.status}, Message: ${response.statusText || 'Unknown error'}`);
+    }
+}
+
+module.exports = { handler };