exodus-framework 2.0.756 → 2.0.757

package/lib/services/socket.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _controller = require("../app/controller");
+var _service = _interopRequireDefault(require("../app/service"));
+var _socket = require("socket.io");
+var _express = _interopRequireDefault(require("./express"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Serviço de gerênciamento de comunicação WS/WSS Socket
+ *
+ * @class SocketIOService
+ * @extends {Service}
+ * @implements {IService}
+ */
+class SocketIOService extends _service.default {
+  server;
+  mainRouter;
+  constructor() {
+    super();
+  }
+  async init() {
+    if (!this.mainRouter) throw new Error('Need router'); //!sem router
+    const server = _express.default.singleton().getHttpServer();
+    this.createSocket(server);
+    this.server.on('connection', this.onConnection.bind(this));
+    this.log('Socket server created');
+  }
+  onConnection(socket) {
+    this.log(`${socket.id} conectado`);
+    socket.on('disconnect', () => this.log(`${socket.id} desconectado`));
+    this.bindEvents(socket);
+  }
+  bindEvents(socket) {
+    Object.entries(this.mainRouter).forEach(([key, handle]) => {
+      socket.on(key, (...args) => {
+        handle(new _controller.SocketRequest(socket, key), ...args);
+      });
+    });
+  }
+  createSocket(app, cors = {
+    origin: '*'
+  }) {
+    this.server = new _socket.Server(app, {
+      cors
+    });
+  }
+  registerRouter(router) {
+    this.mainRouter = router;
+  }
+}
+var _default = exports.default = SocketIOService;

package/lib/services/task.js

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TaskSchedulingService = exports.TaskQueueService = exports.SchedulingTask = exports.QueueTask = void 0;
+var _bullmq = require("bullmq");
+var _fs = require("fs");
+var _nodeSchedule = require("node-schedule");
+var _service = _interopRequireDefault(require("../app/service"));
+var _singleton = _interopRequireDefault(require("../app/singleton"));
+var _app = require("../app");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//* Base
+class TaskServiceBase extends _service.default {
+  jobsPath;
+  setTaskPath(path) {
+    this.jobsPath = path;
+  }
+}
+
+//* Scheduler
+class TaskSchedulingService extends TaskServiceBase {
+  jobs;
+  async init() {
+    if (!this.jobsPath) {
+      return this.log('Tasks file path not found!', 'danger');
+    }
+    this.jobs = [];
+    this.log('Initializing jobs...', 'info');
+    await this.importAllJobs();
+    await this.processAllJobs();
+    this.log('All jobs initializeds...', 'info');
+  }
+  async registerJob(job) {
+    this.jobs.push(job);
+  }
+  async importAllJobs() {
+    if (!(0, _fs.existsSync)(this.jobsPath)) (0, _fs.mkdirSync)(this.jobsPath, {
+      recursive: true
+    });
+    for (const handlerFile of (0, _fs.readdirSync)(this.jobsPath)) {
+      try {
+        const job = require(`${this.jobsPath}/${handlerFile}`).default;
+        const jobInstance = job.singleton();
+        this.jobs.push(jobInstance);
+      } catch (error) {
+        new _app.ErrorHandler(`Falha ao iniciar um ou mais jobs: ${handlerFile}`, error);
+      }
+    }
+  }
+  async processAllJobs() {
+    for (const job of this.jobs) {
+      if (!job.getActive()) continue;
+      (0, _nodeSchedule.scheduleJob)(job.getJobTime(), job.handler.bind(job));
+      this.log(`Job '${job.getJobName()}' started...`, 'warning');
+    }
+  }
+}
+exports.TaskSchedulingService = TaskSchedulingService;
+class SchedulingTask extends _singleton.default {
+  getJobTime() {
+    return this.cron;
+  }
+  getActive() {
+    return this.active;
+  }
+  getJobName() {
+    return this.name;
+  }
+}
+
+//* Queue
+exports.SchedulingTask = SchedulingTask;
+class TaskQueueService extends TaskServiceBase {
+  jobs;
+  connection;
+  async init() {
+    this.jobs = [];
+    this.connection = {
+      host: _app.Core.settings.getCache().host,
+      port: Number(_app.Core.settings.getCache().port),
+      password: _app.Core.settings.getCache().password
+    };
+    this.log('Initializing jobs...', 'info');
+    await this.importAllJobs();
+    await this.processAllJobs();
+    this.log('All jobs initializeds...', 'info');
+  }
+  async registerJob(job) {
+    this.jobs.push(job);
+  }
+  async importAllJobs() {
+    if (!(0, _fs.existsSync)(this.jobsPath)) (0, _fs.mkdirSync)(this.jobsPath, {
+      recursive: true
+    });
+    for (const handlerFile of (0, _fs.readdirSync)(this.jobsPath)) {
+      const job = require(`${this.jobsPath}/${handlerFile}`).default;
+      const jobInstance = job.singleton();
+      this.jobs.push(jobInstance);
+    }
+  }
+  async processAllJobs() {
+    for (const job of this.jobs) {
+      this.startTask(job);
+    }
+  }
+  async startTask(task) {
+    if (!task.getActive()) return;
+    const queue = new _bullmq.Queue(task.getQueueName(), {
+      connection: this.connection
+    });
+    const worker = new _bullmq.Worker(task.getQueueName(), task.handle.bind(task), {
+      connection: this.connection
+    });
+    task.setQueue(queue);
+    task.setWorker(worker);
+    task.init();
+    this.log(`Job '${task.getQueueName()}' started...`, 'warning');
+  }
+}
+exports.TaskQueueService = TaskQueueService;
+class QueueTask extends _singleton.default {
+  queue;
+  worker;
+  initialize() {
+    this.queue = new _bullmq.Queue(this.getQueueName(), {
+      // Configurações do Redis
+      connection: {
+        host: 'localhost',
+        port: 6379
+      }
+    });
+    this.worker = new _bullmq.Worker(this.getQueueName(), this.handle.bind(this), {
+      connection: {
+        host: 'localhost',
+        port: 6379
+      }
+    });
+  }
+  async addJob(data) {
+    await this.queue.add(this.getQueueName(), data);
+    this.log('Nova tarefa disponível.', 'comment');
+  }
+  getQueue() {
+    return this.queue;
+  }
+  setQueue(queue) {
+    this.queue = queue;
+  }
+  getWorker() {
+    return this.worker;
+  }
+  setWorker(worker) {
+    this.worker = worker;
+  }
+  getActive() {
+    return this.active;
+  }
+  getQueueName() {
+    return this.queueName;
+  }
+}
+exports.QueueTask = QueueTask;

package/lib/utils/api.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _core = _interopRequireDefault(require("../app/core"));
+var _axios = _interopRequireDefault(require("axios"));
+var _dateFns = require("date-fns");
+var _app = require("../app");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Api extends _core.default {
+  axios;
+  constructor() {
+    super();
+    this.init();
+  }
+  async init() {
+    this.axios = _axios.default.create({
+      baseURL: this.host,
+      headers: {
+        ...this.headers,
+        'Content-Type': 'application/json'
+      },
+      validateStatus: this.validateStatus
+    });
+  }
+  async request(endpoint, method, data, params, headers) {
+    try {
+      const res = await this.axios({
+        method,
+        url: this.host + endpoint,
+        data,
+        params,
+        headers: {
+          ...headers,
+          ...this.headers
+        }
+      });
+      return res.data;
+    } catch (error) {
+      new _app.ErrorHandler('não foi possível realizar uma requisição', error);
+    }
+  }
+  getLogicalSecurityId() {
+    const date = (0, _dateFns.format)(new Date(), 'yyyy-MM-dd');
+    return String(Date.parse(date) - 5000);
+  }
+}
+var _default = exports.default = Api;

package/lib/utils/database.js

@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.masterDB = void 0;
+exports.processFilters = processFilters;
+exports.serviceDB = void 0;
+var _sequelize = require("sequelize");
+var _app = require("../app");
+var _logger = _interopRequireDefault(require("./logger"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const serviceDB = exports.serviceDB = new _sequelize.Sequelize({
+  database: _app.Core.settings.getDatabase().service.database,
+  dialect: _app.Core.settings.getDatabase().master.dialect,
+  username: _app.Core.settings.getDatabase().master.username,
+  password: _app.Core.settings.getDatabase().master.password,
+  define: {
+    timestamps: true
+  },
+  timezone: '-03:00',
+  logging(sql, timing) {
+    (0, _logger.default)().trace('DATABASE', sql, timing);
+  }
+});
+const masterDB = exports.masterDB = new _sequelize.Sequelize({
+  database: _app.Core.settings.getDatabase().master.database,
+  dialect: _app.Core.settings.getDatabase().master.dialect,
+  username: _app.Core.settings.getDatabase().master.username,
+  password: _app.Core.settings.getDatabase().master.password,
+  define: {
+    timestamps: true
+  },
+  timezone: '-03:00',
+  logging(sql, timing) {
+    (0, _logger.default)().trace('DATABASE', sql, timing);
+  }
+});
+function processCondition(cond) {
+  if ('or' in cond) {
+    return {
+      [_sequelize.Op.or]: cond.or.map(subCond => processCondition(subCond))
+    };
+  }
+  if ('and' in cond) {
+    return {
+      [_sequelize.Op.and]: cond.and.map(subCond => processCondition(subCond))
+    };
+  }
+  const simpleWhere = {};
+  if (cond.eq !== undefined) {
+    simpleWhere[_sequelize.Op.eq] = cond.type === 'DATE' ? new Date(cond.eq) : cond.eq;
+  }
+  if (cond.gt !== undefined) {
+    simpleWhere[_sequelize.Op.gt] = cond.type === 'DATE' ? new Date(cond.eq) : cond.gt;
+  }
+  if (cond.lt !== undefined) {
+    simpleWhere[_sequelize.Op.lt] = cond.type === 'DATE' ? new Date(cond.lt) : cond.lt;
+  }
+  if (cond.between !== undefined) {
+    simpleWhere[_sequelize.Op.between] = cond.type === 'DATE' ? cond.between.map(d => new Date(d)) : cond.between;
+  }
+  if (cond.notBetween !== undefined) {
+    simpleWhere[_sequelize.Op.notBetween] = cond.type === 'DATE' ? cond.notBetween.map(d => new Date(d)) : cond.notBetween;
+  }
+  if (cond.like !== undefined) {
+    simpleWhere[_sequelize.Op.like] = cond.type === 'DATE' ? new Date(cond.like) : cond.like;
+  }
+  if (cond.notLike !== undefined) {
+    simpleWhere[_sequelize.Op.notLike] = cond.type === 'DATE' ? new Date(cond.notLike) : cond.notLike;
+  }
+  if (cond.in !== undefined) {
+    simpleWhere[_sequelize.Op.in] = cond.type === 'DATE' ? cond.in.map(d => new Date(d)) : cond.in;
+  }
+  if (cond.notIn !== undefined) {
+    simpleWhere[_sequelize.Op.notIn] = cond.type === 'DATE' ? cond.notIn.map(d => new Date(d)) : cond.notIn;
+  }
+  return simpleWhere;
+}
+function processDateCondition(key, cond) {
+  const simpleWhere = [key, undefined];
+  if (cond.eq !== undefined) {
+    simpleWhere[0] = _sequelize.Op.and;
+    simpleWhere[1] = [(0, _sequelize.literal)(`DATE(${key}) = '${cond.eq}'`)];
+  }
+  if (cond.gt !== undefined) {
+    simpleWhere[0] = _sequelize.Op.and;
+    simpleWhere[1] = [(0, _sequelize.literal)(`DATE(${key}) > '${cond.gt}'`)];
+  }
+  if (cond.lt !== undefined) {
+    simpleWhere[0] = _sequelize.Op.and;
+    simpleWhere[1] = [(0, _sequelize.literal)(`DATE(${key}) < '${cond.lt}'`)];
+  }
+  if (cond.between !== undefined) {
+    simpleWhere[1] = {
+      [_sequelize.Op.between]: cond.between.map(d => new Date(d))
+    };
+  }
+  if (cond.notBetween !== undefined) {
+    simpleWhere[1] = {
+      [_sequelize.Op.notBetween]: cond.notBetween.map(d => new Date(d))
+    };
+  }
+  if (cond.in !== undefined) {
+    simpleWhere[1] = {
+      [_sequelize.Op.in]: cond.in.map(d => new Date(d))
+    };
+  }
+  if (cond.notIn !== undefined) {
+    simpleWhere[1] = {
+      [_sequelize.Op.notIn]: cond.notIn.map(d => new Date(d))
+    };
+  }
+  return simpleWhere;
+}
+
+// Função Principal para Processar Filtros
+function processFilters(filters) {
+  if (!filters) return {};
+  const where = {};
+  Object.entries(filters).forEach(([key, condition]) => {
+    if (key === 'or' || key === 'and') {
+      const logicalOp = key === 'or' ? _sequelize.Op.or : _sequelize.Op.and;
+      const t = [];
+      for (const c of condition) {
+        const [[key, value]] = Object.entries(c);
+        t.push({
+          [key]: processCondition(value)
+        });
+      }
+      if (!where[logicalOp]) {
+        where[logicalOp] = [];
+      }
+      where[logicalOp].push(...t);
+    } else {
+      const field = key;
+      const isDate = condition.type && condition.type === 'DATE';
+      // const isTime = condition.type && condition.type === 'TIME';
+      // const isDateTime = condition.type && condition.type === 'DATETIME';
+
+      if (isDate) {
+        const [k, c] = processDateCondition(key, condition);
+        where[k] = c;
+      } else {
+        const processedCondition = processCondition(condition);
+        if (where[field]) {
+          where[field] = {
+            ...where[field],
+            ...processedCondition
+          };
+        } else {
+          where[field] = processedCondition;
+        }
+      }
+    }
+  });
+  return where;
+}

package/lib/utils/date.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.timestampDifference = timestampDifference;
+function timestampDifference(timestamp1, timestamp2, type = 'd') {
+  const difference = timestamp1 - timestamp2;
+  let dvrs;
+  switch (type) {
+    case 'd':
+      dvrs = difference / 1000 / 60 / 60 / 24;
+      break;
+    case 'h':
+      dvrs = difference / 1000 / 60 / 60;
+      break;
+    case 'm':
+      dvrs = difference / 1000 / 60;
+      break;
+    case 's':
+      dvrs = difference / 1000;
+      break;
+    default:
+      dvrs = difference / 1000 / 60 / 60 / 24;
+      break;
+  }
+  return Math.round(dvrs * -1 * 100) / 100;
+}

package/lib/utils/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Api: true,
+  logger: true
+};
+Object.defineProperty(exports, "Api", {
+  enumerable: true,
+  get: function () {
+    return _api.default;
+  }
+});
+Object.defineProperty(exports, "logger", {
+  enumerable: true,
+  get: function () {
+    return _logger.default;
+  }
+});
+var _api = _interopRequireDefault(require("./api"));
+var _database = require("./database");
+Object.keys(_database).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _database[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _database[key];
+    }
+  });
+});
+var _date = require("./date");
+Object.keys(_date).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _date[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _date[key];
+    }
+  });
+});
+var _logger = _interopRequireDefault(require("./logger"));
+var _session = require("./session");
+Object.keys(_session).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _session[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _session[key];
+    }
+  });
+});
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/utils/logger.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dateFns = require("date-fns");
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _pinoMultiStream = _interopRequireDefault(require("pino-multi-stream"));
+var _app = require("../app");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+let loggerInstance = null;
+const createLogger = () => {
+  const basePath = _path.default.resolve(_app.Core.settings.getLogger().path, (0, _dateFns.format)(new Date(), 'dd-MM-yyyy'), (0, _dateFns.format)(new Date(), 'HH_mm'));
+  (0, _fs.mkdirSync)(basePath, {
+    recursive: true
+  });
+  const streams = [{
+    level: 'error',
+    stream: (0, _fs.createWriteStream)(basePath + '/error' + _app.Core.settings.getLogger().fileformat)
+  }, {
+    level: 'info',
+    stream: (0, _fs.createWriteStream)(basePath + '/info' + _app.Core.settings.getLogger().fileformat)
+  }, {
+    level: 'fatal',
+    stream: (0, _fs.createWriteStream)(basePath + '/fatal' + _app.Core.settings.getLogger().fileformat)
+  }, {
+    level: 'warn',
+    stream: (0, _fs.createWriteStream)(basePath + '/warn' + _app.Core.settings.getLogger().fileformat)
+  }, {
+    level: 'silent',
+    stream: (0, _fs.createWriteStream)(basePath + '/silent' + _app.Core.settings.getLogger().fileformat)
+  }, {
+    level: 'trace',
+    stream: (0, _fs.createWriteStream)(basePath + '/trace' + _app.Core.settings.getLogger().fileformat)
+  }];
+  _app.Core.settings.getLogger().console ?? streams.push({
+    stream: process.stdout
+  });
+  return (0, _pinoMultiStream.default)({
+    streams
+  });
+};
+const logger = () => {
+  if (!loggerInstance) {
+    loggerInstance = createLogger();
+  }
+  return loggerInstance;
+};
+var _default = exports.default = logger;

package/lib/utils/session.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SessionAPI = void 0;
+var _app = require("../app");
+var _api = _interopRequireDefault(require("./api"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class SessionAPI extends _api.default {
+  host = process.env.APP_SESSION_URL;
+  headers = {
+    'X-Exodus-App-Sec': this.getLogicalSecurityId(),
+    'X-Exodus-Core-Version': _app.Exodus.getVersion()
+  };
+  validateStatus(status) {
+    return status < 400;
+  }
+  async getCertificate() {
+    return this.request('/api/v1/session/certificate', 'get');
+  }
+}
+exports.SessionAPI = SessionAPI;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exodus-framework",
-  "version": "2.0.756",
+  "version": "2.0.757",
   "description": "Exodus Framework",
   "author": "jhownpaixao",
   "license": "ISC",