dcos-core-monalisav2-latam 1.0.0

package/src/functions/notifications/order-status-notification-handler.js

@@ -0,0 +1,482 @@
+const VtexApi = require('../../vtex/clients/VtexApi');
+const ProviderApi = require('../../vtex/clients/ProvidersApi');
+const { 
+    isObjectNotEmpty, 
+    validateURL, 
+    processStringOrObject, 
+    evaluateCondition 
+} = require('../../common/utils/validateProviders');
+const Logger = require("../../common/utils/logger");
+
+// Constants
+const HTTP_STATUS = {
+    OK: 200,
+    BAD_REQUEST: 400,
+    NOT_FOUND: 404,
+    NO_CONTENT: 204,
+    INTERNAL_SERVER_ERROR: 500,
+    BAD_GATEWAY: 502
+};
+
+const ERROR_MESSAGES = {
+    NO_RECORDS: 'No records found in event',
+    INVALID_JSON: 'Invalid JSON in record body',
+    MISSING_ACCOUNT_CONFIG: 'Missing AccountConfig or credentials',
+    MISSING_ORDER_ID: 'Missing orderInfo.OrderId',
+    VTEX_FETCH_ERROR: 'Error fetching order from VTEX',
+    ORDER_NOT_FOUND: 'Order info not found in VTEX response',
+    NOTIFICATIONS_INACTIVE: 'Notifications not active or no providers configured',
+    NO_NOTIFICATIONS: 'No notifications to send',
+    PROVIDERS_FAILED: 'Failed to process provider notifications',
+    PROCESSING_ERROR: 'Error processing record'
+};
+
+/**
+ * Main handler for order status notifications
+ * Processes SQS records containing order information and sends notifications to configured providers
+ */
+module.exports.handler = async (event) => {
+
+    try {
+        const validationResult = validateEvent(event);
+        if (!validationResult.isValid) {
+            Logger.error(validationResult.error);
+            return createErrorResponse(HTTP_STATUS.BAD_REQUEST, validationResult.error);
+        }
+
+        const results = await processRecords(event.Records);
+        return createSuccessResponse(results);
+        
+    } catch (error) {
+        Logger.error(ERROR_MESSAGES.PROCESSING_ERROR, error);
+        return createErrorResponse(HTTP_STATUS.INTERNAL_SERVER_ERROR, error.message);
+    }
+};
+
+/**
+ * Validates the incoming event structure
+ */
+function validateEvent(event) {
+    if (!event || !Array.isArray(event.Records) || event.Records.length === 0) {
+        return { isValid: false, error: ERROR_MESSAGES.NO_RECORDS };
+    }
+    return { isValid: true };
+}
+
+/**
+ * Processes all records in the event
+ */
+async function processRecords(records) {
+
+    const results = {
+        processed: 0,
+        errors: 0,
+        notifications: 0
+    };
+
+    for (const record of records) {
+        try {
+            const result = await processSingleRecord(record);
+            results.processed++;
+            
+            if (result.notificationsSent > 0) {
+                results.notifications += result.notificationsSent;
+            }
+        } catch (error) {
+            Logger.error('Error processing record', error);
+            results.errors++;
+        }
+    }
+
+    return results;
+}
+
+/**
+ * Processes a single SQS record
+ */
+async function processSingleRecord(record) {
+    Logger.debug(`Processing record: ${record.body}`);
+    
+    const order = parseOrderData(record.body);
+    Logger.setAccount(order?.accountConfig);
+    if (!order) {
+        throw new Error(ERROR_MESSAGES.INVALID_JSON);
+    }
+
+    const accountConfig = validateAccountConfig(order.accountConfig);
+    const orderInfo = await fetchOrderFromVtex(order, accountConfig);
+    const responseClientData = await getEmailClientVTEX(accountConfig, orderInfo?.clientProfileData?.email);
+    const orderState = order?.orderInfo?.State;
+    const client = responseClientData?.data;
+
+    const notificationResult = await processNotifications(orderInfo, accountConfig, client, orderState);
+    
+    return {
+        orderId: orderInfo.OrderId,
+        notificationsSent: notificationResult.successCount
+    };
+}
+
+/**
+ * Safely parses JSON from record body
+ */
+function parseOrderData(body) {
+    try {
+        return JSON.parse(body);
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Validates account configuration
+ */
+function validateAccountConfig(accountConfig) {
+    if (!accountConfig || !accountConfig.AccountName || !accountConfig.Credentials) {
+        throw new Error(ERROR_MESSAGES.MISSING_ACCOUNT_CONFIG);
+    }
+    return accountConfig;
+}
+
+/**
+ * Fetches order information from VTEX API
+ */
+async function fetchOrderFromVtex(order, accountConfig) {
+    const orderId = order?.orderInfo?.OrderId;
+    if (!orderId) {
+        throw new Error(ERROR_MESSAGES.MISSING_ORDER_ID);
+    }
+
+    const vtexApi = new VtexApi(
+        accountConfig.AccountName, 
+        accountConfig.Credentials.key, 
+        accountConfig.Credentials.token
+    );
+
+    try {
+        const response = await vtexApi.fetch(`/oms/pvt/orders/${orderId}`, { method: "GET" });
+        Logger.debug("VTEX Order Response:", response?.data);
+        
+        if (!response?.data) {
+            throw new Error(ERROR_MESSAGES.ORDER_NOT_FOUND, { orderId });
+        }
+        
+        return response.data;
+    } catch (error) {
+        Logger.error(ERROR_MESSAGES.VTEX_FETCH_ERROR, error);
+        throw new Error(`${ERROR_MESSAGES.VTEX_FETCH_ERROR}: ${error.message}`);
+    }
+}
+
+async function getEmailClientVTEX(accountConfig, emailAlias) {
+
+    const vtexApi = new VtexApi(
+        accountConfig.AccountName, 
+        accountConfig.Credentials.key, 
+        accountConfig.Credentials.token
+    );
+
+    if (emailAlias) {
+        try {
+            const responseParentDataEmail = await vtexApi.fetchOrderMail(emailAlias);
+            const email = responseParentDataEmail?.data?.email;
+            const idCT = (email)?.split("+")[1]?.split("@")[0].toString();
+
+            if (idCT) {
+                return await vtexApi.fetch(`/dataentities/${accountConfig?.AcronymClientVtex}/documents/${idCT}?_fields=_all`, { method: "GET" });
+            }else{
+                return null;
+            }
+        } catch (error) {
+            Logger.error(error);
+            return null;
+        }
+    }else{
+        Logger.error("Email alias is not provided");
+        return null;
+    }
+}
+
+/**
+ * Processes notifications for the order
+ */
+async function processNotifications(orderInfo, accountConfig, client, orderState) {
+    const notificationConfig = accountConfig?.NotificationsVTEX;
+    
+    if (!isNotificationConfigValid(notificationConfig)) {
+        Logger.info(ERROR_MESSAGES.NOTIFICATIONS_INACTIVE);
+        return { successCount: 0 };
+    }
+
+    Logger.debug('Preparing notifications', {
+        isActive: notificationConfig.isActive,
+        providerCount: notificationConfig.NotificationProviders.length
+    });
+
+    const requests = await buildNotificationRequests(
+        notificationConfig.NotificationProviders, 
+        orderInfo, 
+        orderState,
+        client,
+        Logger
+    );
+
+    if (requests.length === 0) {
+        Logger.info(ERROR_MESSAGES.NO_NOTIFICATIONS);
+        return { successCount: 0 };
+    }
+
+    const successCount = await sendNotificationRequests(requests, Logger);
+    return { successCount };
+}
+
+/**
+ * Validates notification configuration
+ */
+function isNotificationConfigValid(config) {
+    return config?.isActive && 
+           Array.isArray(config.NotificationProviders) && 
+           config.NotificationProviders.length > 0;
+}
+
+/**
+ * Builds notification requests for all configured providers
+ */
+async function buildNotificationRequests(providers, orderData, orderStatus, client, logger) {
+    if (!Array.isArray(providers) || providers.length === 0) {
+        return [];
+    }
+
+    const requests = [];
+    
+    for (const provider of providers) {
+        try {
+            const request = await buildSingleProviderRequest(provider, orderData, orderStatus, client, logger);
+            if (request) {
+                requests.push(request);
+            }
+        } catch (error) {
+            logger.error(`Error building request for provider ${provider.Name}`, error);
+        }
+    }
+    
+    return requests;
+}
+
+/**
+ * Builds a single provider notification request
+ */
+async function buildSingleProviderRequest(provider, orderData, orderStatus, client, logger) {
+    const { Name, Method, Path: URL, Headers, Status } = provider;
+
+    logger.info(`Building request for provider: ${provider}`);
+    
+    const url = validateURL(URL);
+    if (!url) {
+        return null;
+    }
+
+    const notificationPayload = await getNotificationPayload(Status, orderStatus, orderData, client, logger);
+    if (!isObjectNotEmpty(notificationPayload)) {
+        return null;    
+    }
+
+    const headers = parseHeaders(Headers, Name);
+
+    return {
+        data: {
+            name: Name,
+            url: url,
+            method: Method || 'GET',
+            headers: headers,
+        },
+        status: notificationPayload
+    };
+}
+
+/**
+ * Parses and validates headers configuration
+ */
+function parseHeaders(headers, providerName) {
+    try {
+        if (typeof headers === 'string') {
+            return eval(headers);
+        }
+        return headers || {};
+    } catch (error) {
+        return {};
+    }
+}
+
+/**
+ * Generates notification payload based on order status
+ */
+async function getNotificationPayload(statusMap, orderStatus, orderData, client, logger) {
+
+    logger.debug(`Getting notification payload for status: ${orderStatus}`, { statusMap });
+
+    if (!isObjectNotEmpty(statusMap)) {
+        return {};
+    }
+
+    try {
+        if (!statusMap.hasOwnProperty(orderStatus)) {
+            return {};
+        }
+
+        let payload = statusMap[orderStatus];
+        
+        if (typeof payload !== 'object' || !isObjectNotEmpty(payload)) {
+            logger.info(`Payload for status ${orderStatus} is empty or invalid`);  
+            return {};
+        }
+
+        // Evaluate conditions if present
+        if ('conditions' in payload) {
+            const conditionResult = evaluateCondition(payload.conditions, orderData, client);
+            if (!conditionResult) {
+                return {};
+            }
+        }
+
+        // Process dynamic query and body
+        payload = processDynamicFields(payload, orderData, client, logger);
+        logger.debug('Processed payload:', payload);
+        
+        return payload;
+    } catch (error) {
+        return {};
+    }
+}
+
+/**
+ * Processes dynamic fields in the payload
+ */
+function processDynamicFields(payload, orderData, client, logger) {
+
+    logger.debug('Processing dynamic fields in payload', { payload });
+    
+    const processedPayload = { ...payload };
+
+    if ('query' in processedPayload) {
+        processedPayload.query = processStringOrObject(processedPayload, 'query', orderData, client);
+    }
+    
+    if ('body' in processedPayload) {
+        processedPayload.body = processStringOrObject(processedPayload, 'body', orderData, client);
+    }
+    
+    return processedPayload;
+}
+
+/**
+ * Sends notification requests to all providers
+ */
+async function sendNotificationRequests(requests, logger) {
+    if (!Array.isArray(requests) || requests.length === 0) {
+        logger.error('No requests to process');
+        return 0;
+    }
+
+    let successCount = 0;
+    
+    for (const request of requests) {
+        try {
+            const success = await sendSingleNotification(request, logger);
+            if (success) {
+                successCount++;
+            }
+        } catch (error) {
+            logger.error(`Error sending notification for ${request.data.name}`, error);
+        }
+    }
+    
+    return successCount;
+}
+
+/**
+ * Sends a single notification request
+ */
+async function sendSingleNotification(request, logger) {
+    const { data: requestData, status: requestStatus } = request;
+    
+    if (!isObjectNotEmpty(requestData) || !isObjectNotEmpty(requestStatus)) {
+        logger.error('Request data or status is empty, skipping');
+        return false;
+    }
+
+    const url = buildNotificationUrl(requestData.url, requestStatus);
+    if (!url) {
+        logger.error(`Invalid URL for provider ${requestData.name}`);
+        return false;
+    }
+
+    try {
+        const apiClient = new ProviderApi();
+        await apiClient.fetch(url, {
+            name: requestData.name || 'PROVIDER',
+            method: requestData.method || 'GET',
+            headers: requestData.headers || {},
+            body: JSON.stringify(requestStatus.body) || {}
+        });
+        
+        logger.debug(`Successfully sent notification to ${requestData.name}`);
+        return true;
+    } catch (error) {
+        logger.error(`Failed to send notification to ${requestData.name} at ${requestData.url}`, error);
+        return false;
+    }
+}
+
+/**
+ * Builds the complete notification URL with query parameters
+ */
+function buildNotificationUrl(baseUrl, requestStatus) {
+    if (typeof baseUrl !== 'string') {
+        return null;
+    }
+
+    let url = baseUrl;
+    
+    // Add path if present
+    if (requestStatus?.path) {
+        url += requestStatus.path;
+    }
+    
+    // Add query parameters if present
+    if (requestStatus?.query) {
+        const queryString = new URLSearchParams(requestStatus.query).toString();
+        if (queryString) {
+            url += `?${queryString}`;
+        }
+    }
+    
+    return url;
+}
+
+/**
+ * Creates a standardized error response
+ */
+function createErrorResponse(statusCode, message) {
+    return {
+        statusCode,
+        body: JSON.stringify({ error: message })
+    };
+}
+
+/**
+ * Creates a standardized success response
+ */
+function createSuccessResponse(results) {
+    return {
+        statusCode: HTTP_STATUS.OK,
+        body: JSON.stringify({
+            message: 'Notifications processed successfully',
+            results: {
+                processed: results.processed,
+                errors: results.errors,
+                notificationsSent: results.notifications
+            }
+        })
+    };
+}

package/src/functions/notifications/promotion-notification-handler.js

@@ -0,0 +1,193 @@
+const { validate } = require('validate.js');
+const AccountData = require('../../entities/account');
+const ApiResponse = require('../../common/utils/api-response');
+const VtexApi = require('../../vtex/clients/VtexApi');
+const Logger = require("../../common/utils/logger");
+
+const { STAGE = 'dev' } = process?.env ?? {};
+
+module.exports.handler = async (event, context) => {
+    const { awsRequestId } = context;
+
+    try {
+        let { body } = event;
+        body = JSON.parse(body);
+
+        // Condicional (middleware) para despliegue del hook en VTEX
+        if (body?.hookConfig && body?.hookConfig == 'ping') {
+            return ApiResponse.response(200, { hook: 'OK' });
+        }
+
+        // Se valida el cuerpo de la petición
+        let errors = validateHookBody(body);
+        if (errors) {
+            Logger.error(errors);
+            return ApiResponse.response(400, { errors });
+        }
+
+        // Se extrae los datos enviados por el Hook de VTEX
+        const { OrderId, State, Origin } = body;
+        const { Account, Key } = Origin;
+
+        // Consulta de datos configurados
+        const accountConfig = await AccountData.getAccountDataByAccountName(Account);
+        if (!accountConfig) {
+            return ApiResponse.response(400, 'Account not found');
+        }
+        Logger.setAccount(accountConfig);
+        // Se desestructura las variables de configuración asociadas al account 'Account'
+        const { Credentials, PromotionNotificationStock } = accountConfig;
+        if (!Credentials || !PromotionNotificationStock) {
+            return ApiResponse.response(400, 'Credentials or PromotionNotificationStock parameters not found');
+        }
+
+        // Credenciales VTEX asociadas al account
+        const { key, token } = Credentials;
+        // Parámetros de la integración 'PromotionNotificationStock'
+        const { isActive = false, vtexAppKey, customDataId, entityName, schema = 'default' } = PromotionNotificationStock;
+
+        // Se valida si la integración se encuentra activa
+        if (!isActive) {
+            let message = `The promotion notification process is not active for the account ${Account}`;
+            return ApiResponse.response(400, { errors: message });
+        }
+        // Se valida si el AppKey del Hook concuerda con el valor parametrizado
+        if (Key !== vtexAppKey) {
+            let message = `The VTEX App Key ${Key} not apply in this hook`;
+            return ApiResponse.response(400, { errors: message });
+        }
+
+        // Consulta de los datos de la orden en VTEX
+        const apiClient = new VtexApi(Account, key, token);
+        let vtexOrder = await apiClient.fetch(`/oms/pvt/orders/${OrderId}`, {}, false).then(response => response.data);
+
+        // Se desestructura los datos de la orden
+        let { merchantName, ratesAndBenefitsData, customData } = vtexOrder;
+        let promotionsData = {}, promotions = [];
+
+        // Se obtiene la información de las promociones aplicadas a la orden
+        let orderPromotions = {};
+        if (ratesAndBenefitsData?.rateAndBenefitsIdentifiers) {
+            for (let promotion of ratesAndBenefitsData.rateAndBenefitsIdentifiers) {
+                const { id, name, description } = promotion;
+                if (!orderPromotions[id]) {
+                    orderPromotions[id] = { name, description };
+                }
+            }
+        }
+        Logger.debug('Promotions in order ' + OrderId, orderPromotions);
+
+        // Se valida la información de stock no disponible
+        if (customData?.customApps) {
+            Logger.debug('customData for order ' + OrderId, customData.customApps);
+            for (let itemData of customData.customApps) {
+                const { id, fields } = itemData;
+                if (id == customDataId) {
+                    let { skusWithoutStock = '', promotionsWithoutStock = '' } = fields;
+
+                    // Se separa la lista de promociones y SKU's asociados
+                    promotionsWithoutStock = promotionsWithoutStock.split(',');
+                    skusWithoutStock = skusWithoutStock.split(';');
+
+                    if (promotionsWithoutStock.length !== skusWithoutStock.length) {
+                        Logger.warn(`Promotions count (${promotionsWithoutStock.length}) doesn't match with the sku items count (${skusWithoutStock.length})`);
+                    } else {
+                        // Se recorre la lista de promociones
+                        promotionsWithoutStock.forEach((promotionId, index) => {
+                            Logger.debug(`Validating data for promotion ${promotionId}`);
+                            if (promotionId && orderPromotions[promotionId]) {
+                                const { name, description } = orderPromotions[promotionId];
+
+                                // Se valida si existe lista de SKU asociados a la promoción
+                                if (skusWithoutStock[index]) {
+                                    let skus = skusWithoutStock[index].split(',');
+                                    Logger.debug(`SKU items: `, skus);
+                                    if (skus.length) {
+                                        // Se agrupa los datos de las promociones por Id
+                                        if (!promotionsData.hasOwnProperty(promotionId)) {
+                                            promotionsData[promotionId] = { name, description, stock: {} };
+                                        }
+
+                                        // Se agrupan los SKU's asociados a la promoción
+                                        for (let sku of skus) {
+                                            if (!promotionsData[promotionId].stock.hasOwnProperty(sku)) {
+                                                promotionsData[promotionId].stock[sku] = true;
+                                            }
+                                        }
+                                    }
+                                } else {
+                                    Logger.error(`SKU items is not defined for the promotion ${promotionId}`);
+                                }
+                            } else {
+                                Logger.error(`Promotion id '${promotionId}' not found in the order ${OrderId}`);
+                            }
+                        });
+                    }
+                }
+            }
+        }
+
+        // Se valida si existen promociones sin SKU asociados
+        if (Object.keys(promotionsData).length) {
+            // Insertar el registro en VTEX
+            for (let promotionId in promotionsData) {
+                const { name, description, stock } = promotionsData[promotionId];
+                promotions.push({
+                    id: promotionId,
+                    name, description,
+                    skus: Object.keys(stock)
+                });
+            }
+
+            // Insertar el registro en la entidad de Master Data V2;
+            // para que de allí se dispare el trigger que hace el envío del correo electrónico.
+            await apiClient.fetch(`/dataentities/${entityName}/documents?_schema=${schema}`, {
+                method: 'PATCH',
+                data: { id: OrderId, merchantName, promotions }
+            }, false).then(response => {
+                const { data, status } = response;
+                Logger.debug({ status, data });
+            }).catch(Logger.error);
+        }
+
+        return ApiResponse.response(200, {
+            orderId: OrderId,
+            merchantName,
+            promotions
+        });
+    } catch (ex) {
+        Logger.error(ex);
+        return ApiResponse.response(500, { 'error': ex.message, awsRequestId });
+    }
+};
+
+function validateHookBody(body) {
+    return validate(body, {
+        'Domain': {
+            'presence': { allowEmpty: false },
+            'inclusion': ['Marketplace']
+        },
+        'OrderId': {
+            'presence': { allowEmpty: false },
+            'format': {
+                'pattern': '^\\d{13}-01$',
+                'message': function (value, attribute, validatorOptions, attributes, globalOptions) {
+                    const { pattern } = validatorOptions;
+                    return `'${value}' doesn't match with the pattern '${pattern}'`;
+                }
+            },
+        },
+        'State': {
+            'presence': { allowEmpty: false }
+        },
+        'Origin': {
+            'presence': { allowEmpty: false }
+        },
+        'Origin.Account': {
+            'presence': { allowEmpty: false }
+        },
+        'Origin.Key': {
+            'presence': { allowEmpty: false }
+        }
+    })
+}

package/src/functions/orders/index.js

@@ -0,0 +1,32 @@
+
+const ApiResponse = require("../../common/utils/api-response");
+const get_order = require("./orders-handler");
+const cancel_order = require("./orders-cancel-handler");
+
+module.exports.handler= async (req,res)=>{
+  const resource= req?.resource ?? null;
+  const method= req?.httpMethod ? String(req?.httpMethod).toUpperCase() : null;
+
+  if(resource && method){
+    switch(resource){
+      case "/orders/id/{orderId}":
+          switch(method){
+            case "GET":
+              return await get_order?.getOrders(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+      case "/orders/cancel/{orderId}":
+          switch(method){
+            case "POST":
+              return await cancel_order?.cancel(req,res);
+            default: 
+              return ApiResponse.response(400, {error: "error method!."});
+          }
+      default:
+        return ApiResponse.response(400, {error: "error resource!."}); 
+    }
+  }else{
+    return ApiResponse.response(400, {error: "error resource!."});
+  }  
+}