dcos-core-monalisav2-latam 1.0.0

package/src/functions/sftpIntegrations/test/validateFile.test.js

@@ -0,0 +1,122 @@
+const { validateFile } = require('../processes/validateFileSchema')
+const AWS = require('aws-sdk')
+const dynamoDB = new AWS.DynamoDB.DocumentClient()
+
+// Mock de DynamoDB
+jest.mock('aws-sdk', () => {
+  const mDocumentClient = { get: jest.fn() }
+  return {
+    DynamoDB: {
+      DocumentClient: jest.fn(() => mDocumentClient),
+    },
+  }
+})
+
+describe('validateFile', () => {
+  
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  // test case
+  it('deberia validar correctamente un archivo CSV', async () => {
+    const schemaData = {
+      Item: {
+        SchemaId: 'test-schema',
+        StartName: 'test',
+        Ext: 'csv',
+        Separator: ',',
+        Schema: {
+          type: "object",
+          properties: {
+            name: { type: 'string', pattern: '^[a-zA-Z]+$', },
+            age: { type: 'number', pattern: '^[0-9]+$' },
+          },
+          required: ["name", "age"]
+        },
+      }
+    }
+    dynamoDB.get.mockReturnValue({
+      promise: jest.fn().mockResolvedValue(schemaData),
+    })
+
+    // Archivo CSV simulado
+    const file = {
+      filename: 'test_file.csv',
+      content: `name,age\nJohn,25\nJane,30`,
+    }
+
+    const result = await validateFile(file, 'test-schema')
+
+    expect(result.valid).toBe(true)
+    expect(result.errors).toEqual([])
+  })
+
+  // test case
+  it('deberia devolver error si el archivo JSON tiene un campo faltante', async () => {
+    const schemaData = {
+      Item: {
+        SchemaId: 'test-schema',
+        StartName: 'test',
+        Ext: 'json',
+        Schema: {
+          properties: {
+            name: { type: 'string', pattern: '^[a-zA-Z]+$' },
+            age: { type: 'number', pattern: '^[0-9]+$' },
+          }
+        }
+      }
+    }
+    dynamoDB.get.mockReturnValue({
+      promise: jest.fn().mockResolvedValue(schemaData),
+    })
+
+    const file = {
+      filename: 'test_file.json',
+      content: JSON.stringify([{ name: "John" }]),
+    }
+
+    const result = await validateFile(file, 'test-schema')
+
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContain("El campo age es requerido")
+  })
+
+  // test case
+  it('debería devolver error si el archivo XML no cumple con el esquema', async () => {
+
+    const schemaData = {
+      Item: {
+        SchemaId: 'test-schema',
+        StartName: 'test',
+        Ext: 'xml',
+        Schema: {
+          properties: {
+            name: { type: 'string', pattern: '^[a-zA-Z]+$' },
+            age: { type: 'number', pattern: '^[0-9]+$' }
+          }
+        }
+      }
+    }
+
+    dynamoDB.get.mockReturnValue({
+      promise: jest.fn().mockResolvedValue(schemaData),
+    })
+
+    const file = {
+      filename: 'test_file.xml',
+      content: `
+        <root>
+          <item>
+            <name>John</name>
+          </item>
+        </root>
+      `,
+    }
+
+    const result = await validateFile(file, 'test-schema')
+
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContain("El campo age es requerido")
+  })
+})

package/src/functions/sftpIntegrations/utils/connect-dynamo.js

@@ -0,0 +1,29 @@
+const AWS = require('aws-sdk');
+const Logger = require("../../../common/utils/logger");
+
+class DynamoDBConnector {
+  constructor(tableName) {
+    this.dynamoDB = new AWS.DynamoDB.DocumentClient();
+    this.tableName = tableName;
+  }
+
+  async getItem(key) {
+    const params = {
+      TableName: this.tableName,
+      Key: key,
+    };
+
+    try {
+      const data = await this.dynamoDB.get(params).promise();
+      if (!data.Item) {
+        throw new Error(`No se encontró el elemento con la clave: ${JSON.stringify(key)}`);
+      }
+      return data.Item;
+    } catch (error) {
+      Logger.error('Error al obtener el elemento de DynamoDB:', error.message);
+      throw error;
+    }
+  }
+}
+
+module.exports = DynamoDBConnector;

package/src/functions/sftpIntegrations/utils/split-data.js

@@ -0,0 +1,25 @@
+function splitData(data) {
+  const documents = data.map((item) => ({
+    orderId: item.orderId,
+    documentsType: item.documentsType,
+    documentsIssuanceDate: item.documentsIssuanceDate,
+    documentsInvoiceNumber: item.documentsInvoiceNumber,
+    documentsInvoiceValue: item.documentsInvoiceValue,
+    documentsInvoiceUrl: item.documentsInvoiceUrl
+  }));
+
+  const changes = data.map((item) => ({
+    orderId: item.orderId,
+    changesReason: item.changesReason,
+    changesDiscountValue: item.changesDiscountValue,
+    changesItemsRemoved: item.changesItemsRemoved
+      .split('|')
+      .filter(Boolean)
+      .map((change) => {
+        const [sku, price, quantity] = change.split(',');
+        return { sku, price: Number(price), quantity: Number(quantity) };
+      })
+  }));
+
+  return { documents, changes };
+}

package/src/functions/utils/index.js

@@ -0,0 +1,130 @@
+const ApiResponse = require("../../common/utils/api-response");
+const clientsAudience = require("../clients/clients-audience");
+const downloadleadshandler = require("../notifications/download-leads-handler");
+const newleadsnotificationhandler = require("../notifications/new-leads-notification-handler");
+const catalogSyncHandler = require("../inventory/catalog-sync-handler");
+const clients = require("../account/clients");
+const promotionNotificationHandler = require("../notifications/promotion-notification-handler");
+const vtexHookHandler = require("../../common/utils/vtex-hook-handler");
+const AccountErrorsHandler = require("../../common/utils/account-error-handler");
+const AccountPropertiesHandler = require("../../common/utils/account-properties-handler");
+const multiPresentation = require("../multiPresentation/multipres");
+const securityHandler = require("../security/security-handler");
+const Logger = require("../../common/utils/logger");
+
+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 "/audience/get":
+        switch (method) {
+          case "GET":
+            return await clientsAudience?.handler(req, res);
+          default:
+            Logger.error("error method!.");
+            return ApiResponse.response(400, {
+              error: "error method!."
+            });
+        }
+        break;
+      case "/distributors/get/accounts":
+        switch (method) {
+          case "GET":
+            return await clients?.handler(req, res);
+          default:
+            return ApiResponse.response(400, {
+              error: "error method!."
+            });
+        }
+        break;
+      case "/orders/notify_promotion":
+        switch (method) {
+          case "POST":
+            return await promotionNotificationHandler?.handler(req, res);
+          default:
+            Logger.error("error method!.");
+            return ApiResponse.response(400, {
+              error: "error method!."
+            });
+        }
+        break;
+        // route notification new leads
+      case "/new-leads/notification/{an}":
+        switch (method) {
+          case "POST":
+            return await newleadsnotificationhandler?.handler(req, res);
+          default:
+            Logger.error("error method!.");
+            return ApiResponse.response(400, {
+              error: "error method!."
+            });
+        }
+        break;
+      case "/new-leads/download":
+        switch (method) {
+          case "GET":
+            return await downloadleadshandler?.handler(req, res);
+          default:
+            Logger.error("error method!.");
+            return ApiResponse.response(400, {
+              error: "error method!."
+            });
+        }
+        break;
+      case "/catalog/sync/{accountName}":
+        switch (method) {
+          case "POST":
+            return await catalogSyncHandler.handler(req, res);
+          default:
+            Logger.error("error method!.");
+            return ApiResponse.response(400, {
+              error: "error method!."
+            });
+        }
+        break;
+      case "/vtex/hook/{accountName}":
+        switch (method) {
+          case "GET":
+            return await vtexHookHandler?.handler(req, res);
+          default:
+            Logger.error("error method!.");
+            return ApiResponse.response(400, {
+              error: "error method!."
+            });
+        }
+        break;
+      case "/errors/{errorCode}":
+          return await AccountErrorsHandler.handler(req, res);
+        break;
+      case "/accounts/properties":
+      case "/accounts/properties/required":
+        return await AccountPropertiesHandler.handler(req, res);
+        break;
+      // Multi presentations INIT
+      case "/multipresentation/{accountName}":
+          return await multiPresentation?.producer(req, res);
+        break;
+      // Multi presentations END
+      // Roles Security INIT
+      case "/batch/users":
+          return await securityHandler?.producer(req, res);
+        break;
+      case "/batch/accounts":
+          return await securityHandler?.producer(req, res);
+        break;
+      // Roles Security END
+      default:
+        Logger.error("error resource!.");
+        return ApiResponse.response(400, {
+          error: "error resource!."
+        });
+    }
+  } else {
+    Logger.error("error resource!.");
+    return ApiResponse.response(400, {
+      error: "error resource!."
+    });
+  }
+}