dcos-core-monalisav2-latam 1.0.0

package/src/functions/account/account-handler.js

@@ -0,0 +1,299 @@
+"use strict";
+
+const ClientsData = require("../../entities/clients");
+const AccountData = require("../../entities/account");
+const ApiResponse = require("../../common/utils/api-response");
+const SftpInbound = require("../../entities/sftp-inbound");
+const Validation = require("../../common/utils/validation-data");
+const Constants = require("../../common/utils/constants");
+const { handleGetRecordSchema } = require('../../common/utils/schemas-utils')
+const { handleSchemaVtexMD2 } = require('../../common/utils/vtex/save-schemas.js')
+const { handleHookVtexMD2 } = require('../../common/utils/vtex/save-hooks.js')
+const { SCHEMAS_VTEX_TABLE, HOOKS_VTEX_TABLE } = process?.env ?? {};
+const Logger = require("../../common/utils/logger");
+const AccountCoordinatesValidation = require("../../common/validation/AccountCoordinatesValidation.js");
+const SellerEmailSharingService = require("../../common/utils/seller-email-sharing-service.js");
+const AccountErrors = require("../../common/utils/account-error-helper.js"); // Importar helper de errores
+
+/**
+ * @param {import("aws-lambda")} event
+ */
+const create = async (event) => {
+  try {
+    let message = "Client and Account created successfully";
+    Logger.log("Event: ", event);
+    if (!event.body) {
+      return await AccountErrors.createError('ACCOUNT_001'); // CAMBIO
+    }
+    const body = JSON.parse(event.body);
+    const { ClientId, AccountName } = body;
+    if (!AccountName || AccountName === "") {
+      return await AccountErrors.createError('ACCOUNT_002'); // CAMBIO
+    }
+    if (ClientId && ClientId !== "" && typeof ClientId == 'string') {
+      let client = await ClientsData.addClient(ClientId, AccountName);
+      if (!client) {
+        return await AccountErrors.createError('ACCOUNT_003'); // CAMBIO
+      }
+    } else if (ClientId && ClientId !== "" && typeof ClientId == 'object') {
+      for (var i = 0; i < ClientId.length; i++) {
+        let client = await ClientsData.addClient(ClientId[i], AccountName);
+        if (!client) {
+          return await AccountErrors.createError('ACCOUNT_003'); // CAMBIO
+        }
+      }
+    } else {
+      message = "Only the account was created";
+    }
+    const account = await AccountData.addAccountDataConfig(body);
+    if (!account) {
+      return await AccountErrors.createError('ACCOUNT_004'); // CAMBIO
+    }
+    
+    // Validación de AllowEmailSharing
+    const hasSavePriceAudience = body.SavePriceAudience === true;
+    const hasSavePriceTableCLWL = body.SavePriceTableCLWL === true;
+    
+    if (hasSavePriceAudience || hasSavePriceTableCLWL) {
+      Logger.debug("Account requires AllowEmailSharing validation");
+      const sellerEmailSharingService = new SellerEmailSharingService();
+      const validationResult = await sellerEmailSharingService.validateBeforeAccountCreation(body);
+      if (!validationResult.success) {
+        if (validationResult.message.includes('ParentAccountName is required')) {
+          return await AccountErrors.createError('ACCOUNT_011'); // CAMBIO
+        } else if (validationResult.message.includes('Parent account configuration not found')) {
+          return await AccountErrors.createError('ACCOUNT_012', { ParentAccountName: body.ParentAccountName }); // CAMBIO
+        } else if (validationResult.message.includes('VTEX credentials not found')) {
+          return await AccountErrors.createError('ACCOUNT_013', { ParentAccountName: body.ParentAccountName }); // CAMBIO
+        } else if (validationResult.message.includes('Seller not found')) {
+          return await AccountErrors.createError('ACCOUNT_014', { SellerId: body.SellerId || body.AccountName }); // CAMBIO
+        } else {
+          return await AccountErrors.createWithLogging('ACCOUNT_026', new Error(validationResult.message)); // CAMBIO
+        }
+      }
+      Logger.debug("AllowEmailSharing validation passed");
+    } else {
+      Logger.debug("Account does not require AllowEmailSharing validation");
+    }
+    Logger.setAccount(account);
+    // Validación de coordenadas geográficas
+    if (account.SetGeoCoordinatesGlobal === true || account.SetGeoCoordinatesApp === true) {
+      try {
+        Logger.debug("Starting coordinates validation for account:", account.AccountName);
+        const coordinatesValidation = await AccountCoordinatesValidation.validate(account);
+        if (!coordinatesValidation.isValid) {
+          const firstError = coordinatesValidation.errors[0] || '';
+          if (firstError.includes('CodeCountry')) {
+            return await AccountErrors.createError('ACCOUNT_005'); // CAMBIO
+          } else if (firstError.includes('Default coordinates are not configured')) {
+            return await AccountErrors.createError('ACCOUNT_006'); // CAMBIO
+          } else if (firstError.includes('Invalid') && firstError.includes('format')) {
+            return await AccountErrors.createError('ACCOUNT_007'); // CAMBIO
+          } else if (firstError.includes('VTEX regions API')) {
+            return await AccountErrors.createError('ACCOUNT_008', { status: 'unknown', context: firstError }); // CAMBIO
+          } else if (firstError.includes('No regions found')) {
+            return await AccountErrors.createError('ACCOUNT_009', { context: 'coordinates', latitude: 'N/A', longitude: 'N/A' }); // CAMBIO
+          } else if (firstError.includes('not found as seller')) {
+            return await AccountErrors.createError('ACCOUNT_010', { AccountName: account.AccountName, context: 'coordinates', latitude: 'N/A', longitude: 'N/A' }); // CAMBIO
+          } else {
+            return await AccountErrors.createError('ACCOUNT_007'); // CAMBIO
+          }
+        }
+        if (coordinatesValidation.warnings && coordinatesValidation.warnings.length > 0) {
+          Logger.warn("Coordinates validation warnings:", coordinatesValidation.warnings);
+        }
+        Logger.debug("✓ Coordinates validation passed successfully");
+      } catch (coordinatesError) {
+        Logger.error("Error during coordinates validation:", coordinatesError);
+        return await AccountErrors.createWithLogging('ACCOUNT_008', coordinatesError, { status: 'unknown', context: coordinatesError.message }); // CAMBIO
+      }
+    }
+    const listSchemas = account?.ListsSchemasVtexMDv2 ?? [];
+    if (Array.isArray(listSchemas) && listSchemas.length > 0) {
+      Logger.debug('LIST SCHEMAS TO SAVE', listSchemas);
+      const schemaResult = await saveSchemasVTEX(listSchemas, account);
+      if (schemaResult.error) {
+        return schemaResult.error;
+      }
+    }
+    const idOrderHook = account?.HookOrderVtexMDv2 ?? '';
+    if (idOrderHook !== '') {
+      Logger.debug('ID ORDER HOOK', idOrderHook);
+      const hookResult = await saveOrderHookVTEX(idOrderHook, account);
+      if (hookResult.error) {
+        return hookResult.error;
+      }
+    }
+    if (hasSavePriceAudience || hasSavePriceTableCLWL) {
+      try {
+        Logger.debug("Configuring AllowEmailSharing after account creation");
+        const emailSharingService = new SellerEmailSharingService();
+        const emailSharingResult = await emailSharingService.configureEmailSharing(AccountName);
+        if (emailSharingResult.success) {
+          Logger.info("AllowEmailSharing configured successfully");
+          message += " and AllowEmailSharing configured";
+        } else {
+          Logger.warn("AllowEmailSharing configuration warning:", emailSharingResult.message);
+          message += " (AllowEmailSharing configuration pending - check seller configuration)";
+        }
+      } catch (emailSharingError) {
+        Logger.error("Error during AllowEmailSharing configuration:", emailSharingError);
+        message += " (AllowEmailSharing configuration failed - can be configured manually later)";
+      }
+    }
+    return ApiResponse.response(200, { message: message, data: account });
+  } catch (error) {
+    Logger.error(error);
+    return await AccountErrors.createWithLogging('ACCOUNT_026', error); // CAMBIO
+  }
+};
+
+const saveSchemasVTEX = async (listSchemas, account) => {
+  for (const schemaName of listSchemas) {
+    try {
+      const responseData = await handleGetRecordSchema({ id: schemaName, tableName: SCHEMAS_VTEX_TABLE, identifier:'schemas' });
+      Logger.debug('response data', responseData);
+      
+      if (responseData?.statusCode === 200) {
+        const bodyParse = JSON.parse(responseData?.body);
+        const schemaResult = bodyParse?.result;
+
+        if (!schemaResult?.Properties || !schemaResult?.VTriggers) {
+          Logger.error(`Schema ${schemaName} is missing required fields.`);
+          return { error: await AccountErrors.createError('ACCOUNT_022') }; // CAMBIO
+        }
+
+        const response = await handleSchemaVtexMD2({
+          id: schemaName,
+          entityName: schemaResult?.EntityName,
+          data: {
+            'title': schemaResult?.Title,
+            'properties': schemaResult?.Properties,
+            'v-cache': schemaResult?.VCache,
+            'v-default-fields': schemaResult?.VDefaultFields,
+            'required': schemaResult?.Required,
+            'v-indexed': schemaResult?.VIndexed,
+            'v-security': schemaResult?.VSecurity,
+            'v-triggers': schemaResult?.VTriggers,
+            'v-immediate-indexing': schemaResult?.VImmediateIndexing
+          },
+          origin: {
+            AccountName: account?.AccountName,
+            AppKey: account?.Credentials?.key,
+            AppToken: account?.Credentials?.token,
+          },
+          httpMethod: 'PUT',
+        });
+
+        if (!response) {
+          Logger.error('Error saving schema', schemaName);
+          continue;
+        }
+      } else {
+        Logger.error(`Failed to retrieve schema ${schemaName}:`, responseData);
+        return { error: await AccountErrors.createError('ACCOUNT_023') }; // CAMBIO
+      }
+    } catch (error) {
+      Logger.error(error);
+      return { error: await AccountErrors.createWithLogging('ACCOUNT_023', error) }; // CAMBIO
+    }
+  }
+  
+  return { success: true };
+};
+
+const saveOrderHookVTEX = async (idOrderHook, account) => {
+  Logger.debug('ENTRANDO a saveOrderHookVTEX', { idOrderHook, account });
+  
+  try {
+    const responseData = await handleGetRecordSchema({ id: idOrderHook, tableName: HOOKS_VTEX_TABLE, identifier:'hooks' });
+
+    if (responseData?.statusCode === 200) {
+      const bodyParse = JSON.parse(responseData?.body);
+      const hookResult = bodyParse?.result;
+      Logger.debug('response data', hookResult);  
+
+      if (!hookResult?.Filter || !hookResult?.Hook) {
+        Logger.error(`Hook ${idOrderHook} is missing required fields.`);
+        return { error: await AccountErrors.createError('ACCOUNT_024') }; // CAMBIO
+      }
+
+      const response = await handleHookVtexMD2({
+        id: idOrderHook,
+        data: {
+          'filter': hookResult?.Filter,
+          'hook': hookResult?.Hook,
+          'queue': hookResult?.Queue ?? '',
+          'aproximateAgeOfOldestMessageInSeconds': hookResult?.AproximateAgeOfOldestMessageInSeconds ?? 0,
+          'quantity': hookResult?.Quantity ?? 0,
+        },
+        origin: {
+          AccountName: account?.AccountName,
+          AppKey: account?.Credentials?.key,
+          AppToken: account?.Credentials?.token,
+        },
+        httpMethod: 'POST',
+      });
+
+      if (!response) {
+        Logger.error(`Failed to save hook for ${idOrderHook}`);
+        return { error: await AccountErrors.createError('ACCOUNT_025') }; // CAMBIO
+      }
+    } else {
+      Logger.error(`Failed to retrieve hook ${idOrderHook}:`, responseData);
+      return { error: await AccountErrors.createError('ACCOUNT_025') }; // CAMBIO
+    }
+  } catch (error) {
+    Logger.error(`Error processing hook ${idOrderHook}:`, error);
+    return { error: await AccountErrors.createWithLogging('ACCOUNT_025', error) }; // CAMBIO
+  }
+  
+  return { success: true };
+};
+
+const sftpConfig = async (event) => {
+  try {
+    if (!event.body) {
+      return await AccountErrors.createError('ACCOUNT_001'); // CAMBIO
+    }
+    const body = Validation.transformFirstKeysToUpperCaseValue(JSON.parse(event.body));
+    const { AccountName } = body;
+    if (!AccountName || AccountName === "") {
+      return await AccountErrors.createError('ACCOUNT_002'); // CAMBIO
+    }
+    if (!body.ProcessExecute) {
+      return await AccountErrors.createError('ACCOUNT_016'); // CAMBIO
+    }
+    if (!Constants.SFTP_ALL_PROCESSES_CONSUMED.includes(body.ProcessExecute)) {
+      return await AccountErrors.createError('ACCOUNT_017', { VALID_PROCESSES: Constants.SFTP_ALL_PROCESSES_CONSUMED.join(', ') }); // CAMBIO
+    }
+    const accountConfig = await AccountData.getAccountDataByAccountName(AccountName);
+    if (!accountConfig) {
+      Logger.error("Account not found: ", AccountName);
+      return await AccountErrors.createError('ACCOUNT_018', { accountName: AccountName }); // CAMBIO
+    }
+    Logger.setAccount(accountConfig);
+    if (body.ProcessExecute === Constants.SFTP_PROCESS_INVENTORY) {
+      if (!body.Warehouse) {
+        return await AccountErrors.createError('ACCOUNT_019'); // CAMBIO
+      }
+      if (!accountConfig.ChannelWarehouse || !Object.values(accountConfig.ChannelWarehouse).includes(body.Warehouse)) {
+        return await AccountErrors.createError('ACCOUNT_020'); // CAMBIO
+      }
+    }
+    const sftpConfig = await SftpInbound.addSftpInboundConfig(body);
+    Logger.debug("SFTP Config: ", sftpConfig);
+    if (!sftpConfig) {
+      return await AccountErrors.createError('ACCOUNT_021'); // CAMBIO
+    }
+    return ApiResponse.response(200, { message: "SFTP Config created successfully", data: sftpConfig });
+  } catch (error) {
+    Logger.error(error);
+    return await AccountErrors.createWithLogging('ACCOUNT_026', error); // CAMBIO
+  }
+};
+
+module.exports = {
+  create,
+  sftpConfig,
+};

package/src/functions/account/clients.js

@@ -0,0 +1,10 @@
+const client = require('../../entities/clients');
+const ApiResponse = require("../../common/utils/api-response");
+
+const handler = async (event) => {
+    const clientId = event?.requestContext?.authorizer?.claims?.client_id;
+    const listAccounts = await client.getListAccountByClient(clientId);
+    return ApiResponse.responseNoCors(200, listAccounts);
+};
+
+module.exports = { handler };

package/src/functions/account/index.js

@@ -0,0 +1,208 @@
+const ApiResponse = require("../../common/utils/api-response");
+const accountHandler = require("./account-handler");
+const cronFlow = require("../crons/cron");
+const cronJob = require("../cronjobs/cron-jobs-manager");
+const accountGet = require("./account-get");
+const getHandlers = require("../../common/utils/cron-ftp-get");
+const sftp_schemas_file = require("../sftpIntegrations/schemas/record-schema");
+const credential_schema = require("../sftpIntegrations/schemas/credential-schema");
+const handle_schemas = require("../schemas/vtex/handle-schemas");
+const clientauthadmin = require("../../auth/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 "/account/create":
+        switch (method) {
+          case "POST":
+            return await accountHandler.create(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/account":
+        switch (method) {
+          case "GET":
+            return await accountGet.getAccounts(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/account/{an}":
+        switch (method) {
+          case "GET":
+            return await accountGet.getAccount(req, res);
+          case "DELETE":
+            return await accountGet.deleteAccount(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      // admin cron_flow_sett
+      case "/crons":
+        switch (method) {
+          case "GET":
+            return await getHandlers.getAllCrons(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/crons/{cronId}":
+        switch (method) {
+          case "GET":
+            return await getHandlers.getCronById(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/crons/createorupdate/{cronId}":
+        switch (method) {
+          case "POST":
+            return await cronFlow.create(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/cronjobs/createorupdate/{cronId}":
+        switch (method) {
+          case "POST":
+            return await cronJob.create(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      // account sftp config
+      case "/account/sftp":
+        switch (method) {
+          case "GET":
+            // NUEVO: Obtener TODAS las credenciales SFTP
+            return await getHandlers.getAllSftpCredentials(req, res);
+          case "POST":
+            return await accountHandler.sftpConfig(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/account/sftp/{ftpId}":
+        switch (method) {
+          case "GET":
+            return await getHandlers.getSftpCredentialById(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/account/sftp":
+        switch (method) {
+          case "POST":
+            return await accountHandler.sftpConfig(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      
+      // # sftp-schemas-file Schemas file
+      case "/sftpfile/schemas":
+        switch (method) {
+          case "GET":
+            return await sftp_schemas_file.handler(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/sftpfile/schema/{SchemaId}":
+        switch (method) {
+          case "GET":
+            return await sftp_schemas_file.handler(req, res);
+          case "PUT":
+            return await sftp_schemas_file.handler(req, res);
+          case "DELETE":
+            return await sftp_schemas_file.handler(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/sftp/config":
+        switch (method) {
+          case "POST":
+            return await sftp_schemas_file.handler(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      // # sftp-credentiales SFTP credentials
+      case "/sftpcredentials/schemas":
+        switch (method) {
+          case "GET":
+            return await credential_schema.handler(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/sftpcredentials/schema/{FtpId}":
+        switch (method) {
+          case "GET":
+            return await credential_schema.handler(req, res);
+          case "PUT":
+            return await credential_schema.handler(req, res);
+          case "DELETE":
+            return await credential_schema.handler(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      // # handle-schemas-vtex Schemas VTEX
+      case "/resource/schemas/vtex":
+        switch (method) {
+          case "GET":
+            return await handle_schemas.handler(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/resource/schemas/vtex/{SchemaName}":
+        switch (method) {
+          case "GET":
+            return await handle_schemas.handler(req, res);
+          case "PUT":
+            return await handle_schemas.handler(req, res);
+          case "DELETE":
+            return await handle_schemas.handler(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/resource/hooks/vtex":
+        switch (method) {
+          case "GET":
+            return await handle_schemas.handler(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/resource/hooks/vtex/{HookName}":
+        switch (method) {
+          case "GET":
+            return await handle_schemas.handler(req, res);
+          case "PUT":
+            return await handle_schemas.handler(req, res);
+          case "DELETE":
+            return await handle_schemas.handler(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      // # Admin Servicios autenticacion
+      case "/oauth2/pvt/client":
+        switch (method) {
+          case "PATCH":
+            return await clientauthadmin.handler(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/oauth2/pvt/client/{clientId}":
+        switch (method) {
+          case "GET":
+            return await clientauthadmin.handler(req, res);
+          case "DELETE":
+            return await clientauthadmin.handler(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      case "/oauth2/pvt/clients":
+        switch (method) {
+          case "GET":
+            return await clientauthadmin.handler(req, res);
+          default:
+            return ApiResponse.response(400, { error: "Method not allowed." });
+        }
+      default:
+        return ApiResponse.response(400, { error: "Resource not found." });
+    }
+  } else {
+    return ApiResponse.response(400, { error: "Invalid request parameters." });
+  }
+};