exodus-framework 2.0.955 → 2.0.958

package/lib/contracts/messaging.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EMessagingQueue = void 0;
+let EMessagingQueue = exports.EMessagingQueue = /*#__PURE__*/function (EMessagingQueue) {
+  EMessagingQueue["test"] = "exodus.queue.test";
+  EMessagingQueue["accountCreated"] = "exodus.account.created";
+  EMessagingQueue["accountDelete"] = "exodus.account.delete";
+  EMessagingQueue["accountUpdated"] = "exodus.account.updated";
+  EMessagingQueue["accountSync"] = "exodus.account.sync";
+  EMessagingQueue["environmentSync"] = "exodus.environment.sync";
+  EMessagingQueue["environmentCreated"] = "exodus.environment.created";
+  EMessagingQueue["environmentDeleted"] = "exodus.environment.deleted";
+  EMessagingQueue["environmentUpdatedToken"] = "exodus.environment.updated.token";
+  EMessagingQueue["environmentUpdatedDatabase"] = "exodus.environment.updated.database";
+  EMessagingQueue["databaseSync"] = "exodus.database.sync";
+  EMessagingQueue["databaseCreated"] = "exodus.database.created";
+  EMessagingQueue["databaseUpdate"] = "exodus.database.updated";
+  EMessagingQueue["databaseDeleted"] = "exodus.database.deleted";
+  EMessagingQueue["applicationSync"] = "exodus.application.sync";
+  EMessagingQueue["applicationCreated"] = "exodus.application.created";
+  EMessagingQueue["applicationUpdate"] = "exodus.application.updated";
+  EMessagingQueue["applicationDeleted"] = "exodus.application.deleted";
+  EMessagingQueue["smsSend"] = "exodus.sms.send";
+  EMessagingQueue["smsSendBulk"] = "exodus.sms.send.bulk";
+  EMessagingQueue["smsConfirmationSend"] = "exodus.sms.confirmation.send";
+  EMessagingQueue["smsConfirmationSendBulk"] = "exodus.sms.confirmation.send.bulk";
+  EMessagingQueue["smsUpdate"] = "exodus.sms.update";
+  EMessagingQueue["smsCreateWallet"] = "exodus.sms.create.wallet";
+  EMessagingQueue["smsCloseWallet"] = "exodus.sms.close.wallet";
+  EMessagingQueue["smsConfirmationCreateWallet"] = "exodus.sms.confirmation.create.wallet";
+  EMessagingQueue["whatsappOnMessage"] = "exodus.whatsapp.on-message";
+  EMessagingQueue["whatsappOnUpdateMessage"] = "exodus.whatsapp.on-update-message";
+  EMessagingQueue["whatsappOnMessageMediaDownload"] = "exodus.whatsapp.on-message-media-download";
+  EMessagingQueue["whatsappOnContactUpdate"] = "exodus.whatsapp.on-contact-update";
+  EMessagingQueue["whatsappOnContactUpsert"] = "exodus.whatsapp.on-contact-upsert";
+  EMessagingQueue["whatsappSendMessage"] = "exodus.whatsapp.send-message";
+  EMessagingQueue["whatsappHasAccount"] = "exodus.whatsapp.has-account";
+  EMessagingQueue["whatsappHasAccountResponse"] = "exodus.whatsapp.has-account-response";
+  EMessagingQueue["whatsappReadAllMessages"] = "exodus.whatsapp.read-all-messages";
+  EMessagingQueue["whatsappPresenceUpdate"] = "exodus.whatsapp.presence-update";
+  EMessagingQueue["whatsappPresenceSubscribe"] = "exodus.whatsapp.presence-subscribe";
+  EMessagingQueue["whatsappOnContactPresenceUpdate"] = "exodus.whatsapp.contact-presence-update";
+  EMessagingQueue["conversationOnCreateConnection"] = "exodus.conversation.on-create-connection";
+  EMessagingQueue["conversationOnDeleteConnection"] = "exodus.conversation.on-delete-connection";
+  EMessagingQueue["conversationOnUpdateConnection"] = "exodus.conversation.on-update-connection";
+  return EMessagingQueue;
+}({}); // Mapeamento de tópicos para tipos

package/lib/contracts/security.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/contracts/service.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.eEventCommunication = void 0;
+let eEventCommunication = exports.eEventCommunication = /*#__PURE__*/function (eEventCommunication) {
+  eEventCommunication["RECEIVED_MASTER_MESSAGE"] = "received.master.message";
+  eEventCommunication["RECEIVED_CLUSTER_MESSAGE"] = "received.cluster.message";
+  return eEventCommunication;
+}({});

package/lib/contracts/session.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/contracts/settings.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/contracts/singleton.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/contracts/socket.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ESocketEvent = void 0;
+let ESocketEvent = exports.ESocketEvent = /*#__PURE__*/function (ESocketEvent) {
+  ESocketEvent["test"] = "exodus.socket.event.test";
+  ESocketEvent["test2"] = "exodus.socket.event.test2";
+  return ESocketEvent;
+}({}); // Mapeamento de tópicos para tipos

package/lib/contracts/tasks.js

@@ -0,0 +1 @@
+"use strict";

package/lib/controllers/api/file.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _controller = _interopRequireDefault(require("../../app/controller"));
+require("express-async-errors");
+var _http = require("../../contracts/http");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// !Tratamento de erros asyncronos
+
+class FileController extends _controller.default {
+  upload = async (req, res) => {
+    this.send({
+      message: 'Salvo com sucesso',
+      type: 'success',
+      status: true,
+      data: req.file.filename,
+      code: _http.EHttpResponseCode.created
+    }, res);
+  };
+}
+var _default = exports.default = FileController;

package/lib/controllers/api/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "FileController", {
+  enumerable: true,
+  get: function () {
+    return _file.default;
+  }
+});
+var _file = _interopRequireDefault(require("./file"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/controllers/api/log.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _app = require("../../app");
+var _Log = require("../../models/Log");
+var _services = require("../../services");
+var _utils = require("../../utils");
+class LogController extends _app.HttpController {
+  list = async (req, res) => {
+    const {
+      page = 1,
+      filters = {},
+      limit = 10,
+      order = 'ASC',
+      orderBy = 'happenedAt'
+    } = req.body;
+    const offset = (Number(page) - 1) * Number(limit);
+    try {
+      const Entity = await _services.SequelizeService.singleton().getModel(_Log.Log, req.tenant.id);
+      /* filters */
+      const where = (0, _utils.processFilters)(filters);
+      const {
+        rows,
+        count
+      } = await Entity.findAndCountAll({
+        where,
+        order: [[orderBy, order]],
+        limit: Number(limit),
+        offset: offset < 0 ? 0 : offset
+      });
+      const pages = Math.ceil(count / Number(limit));
+      const hasMore = offset + Number(limit) < count;
+      this.send({
+        message: 'carregado com sucesso',
+        status: true,
+        type: 'success',
+        data: {
+          data: rows,
+          total: count,
+          pages,
+          hasMore
+        }
+      }, res);
+    } catch (error) {
+      throw new _app.HttpError({
+        message: 'Não foi possível obter a lista de mensagens',
+        error
+      });
+    }
+  };
+}
+var _default = exports.default = LogController;

package/lib/controllers/api/report.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _app = require("../../app");
+var _services = require("../../services");
+var _utils = require("../../utils");
+var _Report = require("../../models/Report");
+class ReportController extends _app.HttpController {
+  list = async (req, res) => {
+    const {
+      page = 1,
+      filters = {},
+      limit = 10,
+      order = 'ASC',
+      orderBy = 'category'
+    } = req.body;
+    const offset = (Number(page) - 1) * Number(limit);
+    try {
+      const Entity = await _services.SequelizeService.singleton().getModel(_Report.Report, req.tenant.id);
+      /* filters */
+      const where = (0, _utils.processFilters)(filters);
+      const {
+        rows,
+        count
+      } = await Entity.findAndCountAll({
+        where,
+        order: [[orderBy, order]],
+        limit: Number(limit),
+        offset: offset < 0 ? 0 : offset
+      });
+      const pages = Math.ceil(count / Number(limit));
+      const hasMore = offset + Number(limit) < count;
+      this.send({
+        message: 'carregado com sucesso',
+        status: true,
+        type: 'success',
+        data: {
+          data: rows,
+          total: count,
+          pages,
+          hasMore
+        }
+      }, res);
+    } catch (error) {
+      throw new _app.HttpError({
+        message: 'Não foi possível obter a lista de relatórios',
+        error
+      });
+    }
+  };
+}
+var _default = exports.default = ReportController;

package/lib/controllers/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _api = require("./api");
+Object.keys(_api).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _api[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _api[key];
+    }
+  });
+});

package/lib/controllers/messaging/application.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _controller = require("../../app/controller");
+var _error = require("../../app/error");
+var _Application = require("../../models/Application");
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//TODO: a ordem de inicialização do sistema impede as tasks estarem disponiveis até o momento
+//TODO: deveria ser assim?
+class ApplicationController extends _controller.MessagingController {
+  created = async (data, ack) => {
+    /* ApplicationSyncQueue.addJob({ create: data });
+    ack(); */
+
+    try {
+      await _Application.Application.create(data);
+    } catch (error) {
+      new _error.ErrorHandler('Houve um erro ao tentar criar a aplicação', error);
+    } finally {
+      ack();
+    }
+  };
+  update = async (data, ack) => {
+    /* ApplicationSyncQueue.addJob({ update: data });
+    ack(); */
+
+    try {
+      const app = await _Application.Application.findByPk(data.uuid);
+      if (!app) throw new Error('Aplicação não encontrada: ' + data.uuid);
+      await app.update(data.updated);
+    } catch (error) {
+      new _error.ErrorHandler('Houve um erro ao tentar atualizar a aplicação, check o log...', error);
+    } finally {
+      ack();
+    }
+  };
+  delete = async (data, ack) => {
+    try {
+      const app = await _Application.Application.findByPk(data.uuid);
+      if (!app) throw new Error('Aplicação não encontrada: ' + data.uuid);
+      await app.destroy();
+    } catch (error) {
+      new _error.ErrorHandler('Houve um erro ao tentar excluír a aplicação', error);
+    } finally {
+      ack();
+    }
+  };
+  sync = async (data, ack) => {
+    try {
+      data.forEach(async app => {
+        try {
+          const host = await _Application.Application.findByPk(app.uuid);
+          if (!host) {
+            (0, _logger.default)().info(app, `Sincronizando nova integração do banco de dados ${app.name}`);
+            this.log(`Sincronizando nova integração do banco de dados ${app.name}`, 'info');
+            // ApplicationSyncQueue.addJob({ create: app });
+
+            await _Application.Application.create(app);
+          }
+        } catch (error) {
+          new _error.ErrorHandler('Houve um erro ao tentar sincronizar uma integração', error);
+        }
+      });
+    } catch (error) {
+      new _error.ErrorHandler('Houve um erro ao tentar sincronizar uma integração', error);
+    } finally {
+      ack();
+    }
+  };
+}
+var _default = exports.default = ApplicationController;

package/lib/controllers/messaging/database.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _controller = require("../../app/controller");
+var _models = require("../../models");
+var _app = require("../../app");
+var _utils = require("../../utils");
+class DatabaseController extends _controller.MessagingController {
+  created = async (data, ack) => {
+    try {
+      await _models.DatabaseHost.create(data);
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar criar um banco de dados', error);
+    } finally {
+      ack();
+    }
+  };
+  update = async (data, ack) => {
+    try {
+      const host = await _models.DatabaseHost.findByPk(data.uuid);
+      if (!host) throw new Error('Banco de dados não encontrado');
+      await host.update(data.updated);
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar atualizar um banco de dados', error);
+    } finally {
+      ack();
+    }
+  };
+  delete = async (data, ack) => {
+    try {
+      const host = await _models.DatabaseHost.findByPk(data.uuid);
+      if (!host) throw new Error('Banco de dados não encontrado');
+      await host.destroy();
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar excluír um banco de dados', error);
+    } finally {
+      ack();
+    }
+  };
+  sync = async (data, ack) => {
+    try {
+      data.forEach(async database => {
+        try {
+          const host = await _models.DatabaseHost.findByPk(database.uuid);
+          if (!host) {
+            (0, _utils.logger)().info(database, `Sincronizando novo host ${database.host}`);
+            this.log(`Sincronizando novo host ${database.host}`, 'info');
+            await _models.DatabaseHost.create(database);
+          }
+        } catch (error) {
+          new _app.ErrorHandler('Houve um erro ao tentar sincronizar um novo host', error);
+        }
+      });
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar sincronizar um novo host', error);
+    } finally {
+      ack();
+    }
+  };
+}
+var _default = exports.default = DatabaseController;

package/lib/controllers/messaging/environment.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _app = require("../../app");
+var _models = require("../../models");
+var _services = require("../../services");
+var _utils = require("../../utils");
+//TODO: a ordem de inicialização do sistema impede as tasks estarem disponiveis até o momento
+//TODO: deveria ser assim?
+class EnvironmentController extends _app.MessagingController {
+  created = async (data, ack) => {
+    /* EnvironmentSyncQueue.addJob({ create: data });
+    ack(); */
+
+    try {
+      const db = data.database;
+      const token = data.envToken;
+      await _services.SequelizeService.singleton().createDB(db, token);
+      await _models.EnvDBHost.create({
+        envUuid: data.uuid,
+        hostUuid: data.database,
+        envToken: data.envToken
+      });
+      this.log(`New database created successfully: ${db}`);
+    } catch (error) {
+      new _app.ErrorHandler('Erro ao criar o novo banco de dados', error);
+    } finally {
+      ack();
+    }
+  };
+  deleted = async (data, ack) => {
+    try {
+      const token = data.token;
+      const db = data.database;
+      await _services.SequelizeService.singleton().deleteDB(db, token);
+      const relation = await _models.EnvDBHost.findOne({
+        where: {
+          envUuid: data.uuid
+        }
+      });
+      if (!relation) throw new Error('relação env-db não encontrada');
+      await relation.destroy();
+      this.log(`Database deleted successfully: ${token}`);
+    } catch (error) {
+      new _app.ErrorHandler('Erro ao deletar a relação env-db', error);
+    } finally {
+      ack();
+    }
+  };
+  updatedDatabase = async (data, ack) => {
+    /* EnvironmentSyncQueue.addJob({ update: data });
+    ack(); */
+
+    try {
+      const relation = await _models.EnvDBHost.findOne({
+        where: {
+          envUuid: data.envUuid
+        }
+      });
+      if (!relation) throw new Error('relação env-db não encontrada');
+      await relation.update({
+        hostUuid: data.database
+      });
+      this.log(`A relação para o ambiente ${data.envUuid} foi atualizada, a migração deverá ser realizada de forma manual`);
+    } catch (error) {
+      new _app.ErrorHandler('Erro ao atualizar a relação EDB', error);
+    } finally {
+      ack();
+    }
+  };
+  sync = async (data, ack) => {
+    /* EnvironmentSyncQueue.addJob({ sync: data });
+    ack(); */
+
+    try {
+      data.forEach(async env => {
+        try {
+          const host = await _models.EnvDBHost.findOne({
+            where: {
+              envUuid: env.uuid
+            }
+          });
+          if (!host) {
+            (0, _utils.logger)().info(env, `Sincronizando relação env-db ${env.uuid}`);
+            this.log(`Sincronizando relação env-db ${env.uuid}`, 'info');
+            await _models.EnvDBHost.create({
+              envUuid: env.uuid,
+              hostUuid: env.database,
+              envToken: env.envToken
+            });
+          }
+          if (!(await _services.SequelizeService.singleton().hasDB(env.database, env.envToken))) {
+            (0, _utils.logger)().info(env, `Sincronizando novo banco de dados ${env.uuid}`);
+            this.log(`Sincronizando novo banco de dados ${env.uuid}`, 'info');
+            await _services.SequelizeService.singleton().createDB(env.database, env.envToken);
+          }
+        } catch (error) {
+          new _app.ErrorHandler('Houve um erro ao tentar sincronizar um novo ambiente/relação ou banco de dados', error);
+        }
+      });
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar sincronizar um novo ambiente/relação ou banco de dados', error);
+    } finally {
+      ack();
+    }
+  };
+}
+var _default = exports.default = EnvironmentController;

package/lib/express.d.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/index.js

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+var _app = require("./app");
+Object.keys(_app).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _app[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _app[key];
+    }
+  });
+});
+var _contracts = require("./contracts");
+Object.keys(_contracts).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _contracts[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _contracts[key];
+    }
+  });
+});
+var _controllers = require("./controllers");
+Object.keys(_controllers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _controllers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _controllers[key];
+    }
+  });
+});
+var _middlewares = require("./middlewares");
+Object.keys(_middlewares).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _middlewares[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _middlewares[key];
+    }
+  });
+});
+var _models = require("./models");
+Object.keys(_models).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _models[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _models[key];
+    }
+  });
+});
+var _services = require("./services");
+Object.keys(_services).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _services[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _services[key];
+    }
+  });
+});
+var _utils = require("./utils");
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
+});
+var _tasks = require("./tasks");
+Object.keys(_tasks).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _tasks[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _tasks[key];
+    }
+  });
+});
+var _default = exports.default = _app.Exodus;