investira.sdk 2.3.18 → 2.3.20

package/CHANGELOG.md

@@ -529,3 +529,11 @@ O contrutor para a criação das mensagem foi alterado.
 # 2.3.18
 
 -   [objetcs] Correção da mergeObject
+
+# 2.3.19
+
+-   [arrays] Método isEqual
+
+# 2.3.20
+
+-   [tasks] Substituido this por self

package/lib/hofs/tasks.js

@@ -17,8 +17,9 @@ const STATUS = Object.freeze({
  * @param {object} [pSource={}]
  */
 function task(pOptions, pSource = {}) {
-    this.STATUS = STATUS;
-    this.options = {
+    const xSelf = this;
+    xSelf.STATUS = STATUS;
+    xSelf.options = {
         retries: 0, //Numero de tentativas quando houver erro
         delay: 0, //Tempo em segundos para efetuar nova tentativa
         enabled: true,
@@ -34,24 +35,24 @@ function task(pOptions, pSource = {}) {
         ], //Array com os agendamentos
         ...deepCopy(pOptions)
     };
-    // console.log(`*-* INICIO ${this.options.id}`);
-    this.event = new events.EventEmitter();
-    this.beforeRun =
+    // console.log(`*-* INICIO ${xSelf.options.id}`);
+    xSelf.event = new events.EventEmitter();
+    xSelf.beforeRun =
         pSource.beforeRun ||
         function () {
             return Promise.resolve();
         };
-    this.execute =
+    xSelf.execute =
         pSource.execute ||
         function () {
             return Promise.resolve();
         };
-    this.afterStop =
+    xSelf.afterStop =
         pSource.afterStop ||
         function () {
             return Promise.resolve();
         };
-    this.state = {
+    xSelf.state = {
         status: STATUS.STOPPED, //Status da execução
         nextAt: null, //Momento da próxima execução
         startedAt: null, //Momento de inicio da execução
@@ -59,43 +60,43 @@ function task(pOptions, pSource = {}) {
         retries: 0, //Quantidade de vezes que foi reiniciada
         error: null //Mensagem de erro,
     };
-    this.timeout = null;
+    xSelf.timeout = null;
 
     /**
      * desabilitar esta tarefa
      */
-    this.disable = () => {
-        this.options.enabled = false;
-        clearTimeout(this.timeout);
+    xSelf.disable = () => {
+        xSelf.options.enabled = false;
+        clearTimeout(xSelf.timeout);
         //Dispara evento disabled
-        this.event.emit('disabled');
+        xSelf.event.emit('disabled');
     };
     /**
      * Habilitar esta tarefa e reinicia o agendamento se houver
      */
-    this.enable = () => {
-        this.options.enabled = true;
+    xSelf.enable = () => {
+        xSelf.options.enabled = true;
         //Dispara evento scheduled
-        this.event.emit('enabled');
-        this.schedule();
+        xSelf.event.emit('enabled');
+        xSelf.schedule();
     };
     /**
      * Agenda próxima execução
      *
      */
-    this.schedule = () => {
-        // console.log(`${this.options.id} ${this.options.name} *-* SCHEDULE(#1)`);
-        if (!this.options.enabled) {
+    xSelf.schedule = () => {
+        // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* SCHEDULE(#1)`);
+        if (!xSelf.options.enabled) {
             return;
         }
         //Configura schedule inicial
         if (pvSetNextDate()) {
-            clearTimeout(this.timeout);
-            // console.log(`${this.options.id} ${this.options.name} *-* SCHEDULE(#2) ${this.state.nextAt}`);
+            clearTimeout(xSelf.timeout);
+            // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* SCHEDULE(#2) ${xSelf.state.nextAt}`);
             //Efetua agendamento
-            this.timeout = schedule(this.state.nextAt, this.run);
+            xSelf.timeout = schedule(xSelf.state.nextAt, xSelf.run);
             //Dispara evento scheduled
-            this.event.emit('scheduled', this.state.nextAt);
+            xSelf.event.emit('scheduled', xSelf.state.nextAt);
         }
     };
 
@@ -105,45 +106,48 @@ function task(pOptions, pSource = {}) {
      * @param {object} [pPreviousTaskState=null] Atributo 'state' de uma tarefa anterior para a data/hora ser utilizada como o verdadeiro inicio
      * @returns {Promise}
      */
-    this.run = (pPreviousTaskState = null) => {
-        // console.log(`${this.options.id} ${this.options.name} *-* RUN`);
-        if (!this.options.enabled || this.isRunning()) {
-            if (this.isRunning()) {
-                // console.log(`${this.options.id} ${this.options.name} *-* RUN  JÁ EM EXECUÇÃO`);
-                this.event.emit('running', true);
+    xSelf.run = (pPreviousTaskState = null) => {
+        // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* RUN`);
+        if (!xSelf.options.enabled || xSelf.isRunning()) {
+            if (xSelf.isRunning()) {
+                // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* RUN  JÁ EM EXECUÇÃO`);
+                xSelf.event.emit('running', true);
             } else {
-                // console.log(`${this.options.id} ${this.options.name} *-* RUN DESABILITADA`);
+                // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* RUN DESABILITADA`);
             }
             return Promise.resolve();
         }
         return new Promise((pResolve, pReject) => {
             //Códigos referentes a execução devem ser inseridos dentro da função executada no setTimeout
             //Se for retry, aguarda o tempo definido no delay
-            // console.log(`${this.options.id} ${this.options.name} *-* RUN SETTIMEOUT`);
+            // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* RUN SETTIMEOUT`);
 
             setTimeout(
                 () => {
-                    // console.log(`${this.options.id} ${this.options.name} *-* RUN SETTIMEOUT RUN`);
+                    // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* RUN SETTIMEOUT RUN`);
                     //Inicia execução
                     //Reseta erro
-                    this.state.error = null;
+                    xSelf.state.error = null;
                     //Dispara evento run
-                    this.event.emit('run');
+                    xSelf.event.emit('run');
                     //Verica se é para prosseguir
-                    this.beforeRun()
+                    xSelf
+                        .beforeRun()
                         .then((pIsOk = true) => {
-                            // console.log(`${this.options.id} ${this.options.name} *-* RUN BEFORE`);
+                            // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* RUN BEFORE`);
                             if (pIsOk) {
-                                this.state.status = STATUS.RUNNING;
+                                // @ts-ignore
+                                xSelf.state.status = STATUS.RUNNING;
                                 //Considera o inicio informado
-                                this.state.startedAt = (pPreviousTaskState && pPreviousTaskState.startedAt) || toDate();
+                                xSelf.state.startedAt =
+                                    (pPreviousTaskState && pPreviousTaskState.startedAt) || toDate();
                                 //Dispara evento disabled
-                                this.event.emit('running');
+                                xSelf.event.emit('running');
                                 //--------------------
                                 //      EXECUTA
                                 //--------------------
-                                // console.log(`${this.options.id} ${this.options.name} *-* RUN EXECUTE`);
-                                return this.execute();
+                                // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* RUN EXECUTE`);
+                                return xSelf.execute();
                             } else {
                                 return null;
                             }
@@ -151,8 +155,8 @@ function task(pOptions, pSource = {}) {
                         //Sucesso
                         .then(rResult => {
                             //Reseta retries quando execução finalizar com sucesso
-                            this.state.retries = 0;
-                            // console.log(`${this.options.id} ${this.options.name} *-* RUN SUCESSO`);
+                            xSelf.state.retries = 0;
+                            // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* RUN SUCESSO`);
                             //Finaliza execução
                             return pvStop()
                                 .then(() => {
@@ -164,37 +168,41 @@ function task(pOptions, pSource = {}) {
                         })
                         //Error
                         .catch(rErr => {
-                            // console.log(`${this.options.id} ${this.options.name} *-* RUN ERRO`);
-                            this.state.error = rErr;
+                            // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* RUN ERRO`);
+                            xSelf.state.error = rErr;
                             //Finaliza execução
                             return pvStop().finally(() => {
-                                // console.log(`${this.options.id} ${this.options.name} *-* RUN FINALLY`);
+                                // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* RUN FINALLY`);
                                 //Verifica se fará novas tentativas 'Manual Stop'
-                                if (this.state.retries < this.options.retries) {
-                                    this.state.retries++;
+                                if (xSelf.state.retries < xSelf.options.retries) {
+                                    xSelf.state.retries++;
                                     //Dispara evento retry
-                                    this.event.emit('retry', this.state.retries);
+                                    xSelf.event.emit('retry', xSelf.state.retries);
                                     //Faz novas tentativas
-                                    // console.log(`${this.options.id} ${this.options.name} *-* RUN RETRY`);
-                                    return this.run().catch(rErr => {
+                                    // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* RUN RETRY`);
+                                    return xSelf.run().catch(rErr => {
                                         //Dispara evento error
-                                        this.event.emit('error', {
+                                        xSelf.event.emit('error', {
                                             err: rErr,
-                                            state: this.state,
-                                            options: this.options
+                                            state: xSelf.state,
+                                            options: xSelf.options
                                         });
                                         return pReject(rErr);
                                     });
                                 } else {
                                     //Dispara evento error
-                                    this.event.emit('error', { err: rErr, state: this.state, options: this.options });
+                                    xSelf.event.emit('error', {
+                                        err: rErr,
+                                        state: xSelf.state,
+                                        options: xSelf.options
+                                    });
                                     return pReject(rErr);
                                 }
                             });
                         });
                 },
                 //Delay para efetuar novo restart
-                this.state.retries > 0 ? this.options.delay * 1000 : 0
+                xSelf.state.retries > 0 ? xSelf.options.delay * 1000 : 0
             );
         });
     };
@@ -203,27 +211,31 @@ function task(pOptions, pSource = {}) {
      * Interrompe a execução da tarefa caso tenha sido agendada
      *
      */
-    this.stop = () => {
-        if (this.state.status !== STATUS.RUNNING) {
+    xSelf.stop = () => {
+        // @ts-ignore
+        if (xSelf.state.status !== STATUS.RUNNING) {
             return;
         }
-        this.state.status = STATUS.STOPPING;
+        // @ts-ignore
+        xSelf.state.status = STATUS.STOPPING;
     };
     /**
      * Interrompe a execução da tarefa caso tenha sido agendada
      *
      */
-    this.isStopping = () => {
-        if (this.state.status !== STATUS.STOPPING) {
+    xSelf.isStopping = () => {
+        // @ts-ignore
+        if (xSelf.state.status !== STATUS.STOPPING) {
             return false;
         }
         //Indica que execução foi parada manualmente
-        this.state.error = 'Manual Stop';
+        xSelf.state.error = 'Manual Stop';
         pvStop();
         return true;
     };
-    this.isRunning = () => {
-        return this.state.status === STATUS.RUNNING;
+    xSelf.isRunning = () => {
+        // @ts-ignore
+        return xSelf.state.status === STATUS.RUNNING;
     };
     /**
      * Retorna próxima data considerando a configuração do schedule.
@@ -232,25 +244,25 @@ function task(pOptions, pSource = {}) {
      * 								  Se não informada, será utilizada a data atual
      * @returns {Date}
      */
-    this.getNextDate = (pBaseDate = null) => {
-        // console.log(`${this.options.id} ${this.options.name} *-* getNextDate(#1)`);
-        if (!this.options.schedules || !isArray(this.options.schedules) || this.options.schedules.length === 0) {
+    xSelf.getNextDate = (pBaseDate = null) => {
+        // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* getNextDate(#1)`);
+        if (!xSelf.options.schedules || !isArray(xSelf.options.schedules) || xSelf.options.schedules.length === 0) {
             return null;
         }
-        // console.log(`${this.options.id} ${this.options.name} *-* getNextDate(#2)`);
+        // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* getNextDate(#2)`);
         let xNextDate = null;
         //Pesquisa qual a data mais próximas considerando todos os agendamentos
-        for (const xSchedule of this.options.schedules) {
+        for (const xSchedule of xSelf.options.schedules) {
             if (xSchedule.type && isObject(xSchedule)) {
                 //Calcula próxima data
                 const xDate = scheduleToDate(xSchedule, pBaseDate);
-                // console.log(`${this.options.id} ${this.options.name} *-* getNextDate(#3) ${xDate}`);
+                // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* getNextDate(#3) ${xDate}`);
                 if (!xNextDate || xDate < xNextDate) {
                     xNextDate = xDate;
                 }
             }
         }
-        // console.log(`${this.options.id} ${this.options.name} *-* getNextDate(#4) ${xNextDate}`);
+        // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* getNextDate(#4) ${xNextDate}`);
         return xNextDate;
     };
     /**
@@ -258,37 +270,38 @@ function task(pOptions, pSource = {}) {
      *
      */
     const pvStop = () => {
-        // console.log(`${this.options.id} ${this.options.name} *-* STOP`);
-        if (this.state.status !== STATUS.RUNNING && this.state.status !== STATUS.STOPPING) {
+        // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* STOP`);
+        // @ts-ignore
+        if (xSelf.state.status !== STATUS.RUNNING && xSelf.state.status !== STATUS.STOPPING) {
             return Promise.resolve();
         }
-        // console.log(`${this.options.id} ${this.options.name} *-* STOPPED`);
-        this.state.status = STATUS.STOPPED;
-        this.state.endedAt = toDate();
-        this.state.duration = this.state.endedAt.getTime() - this.state.startedAt.getTime();
+        // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* STOPPED`);
+        xSelf.state.status = STATUS.STOPPED;
+        xSelf.state.endedAt = toDate();
+        xSelf.state.duration = xSelf.state.endedAt.getTime() - xSelf.state.startedAt.getTime();
         //Dispara evento stopped
-        this.event.emit('stopped', this.state.error);
+        xSelf.event.emit('stopped', xSelf.state.error);
         //Inicia novo schedule, se houver
-        this.schedule();
+        xSelf.schedule();
         //Chama afterStop
-        return this.afterStop();
+        return xSelf.afterStop();
     };
 
     const pvSetNextDate = () => {
-        // console.log(`${this.options.id} ${this.options.name} *-* setNextDate(#1)`);
-        const xNextDate = this.getNextDate();
-        // console.log(`${this.options.id} ${this.options.name} *-* setNextDate(#2) ${xNextDate} ${this.state.nextAt}`);
-        if (!xNextDate || (this.state.nextAt && xNextDate.getTime() === this.state.nextAt.getTime())) {
+        // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* setNextDate(#1)`);
+        const xNextDate = xSelf.getNextDate();
+        // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* setNextDate(#2) ${xNextDate} ${xSelf.state.nextAt}`);
+        if (!xNextDate || (xSelf.state.nextAt && xNextDate.getTime() === xSelf.state.nextAt.getTime())) {
             return false;
         }
-        // console.log(`${this.options.id} ${this.options.name} *-* setNextDate(#3)`);
-        this.state.nextAt = xNextDate;
+        // console.log(`${xSelf.options.id} ${xSelf.options.name} *-* setNextDate(#3)`);
+        xSelf.state.nextAt = xNextDate;
         return true;
     };
 
     //Inicia schedule de houver
     setTimeout(() => {
-        this.schedule();
+        xSelf.schedule();
     }, 0);
 }
 

package/lib/utils/arrays.js

@@ -167,6 +167,32 @@ const arrays = {
         return pArray.filter((pItem, pIndex) => {
             return pArray.indexOf(pItem) === pIndex;
         });
+    },
+    /**
+     * Retorna se array é iqual
+     *
+     * @param {*} pArray1
+     * @param {*} pArray2
+     * @return {*}
+     */
+    isEqual: (pArray1, pArray2) => {
+        // Check if the arrays have the same length
+        if (pArray1.length !== pArray2.length) {
+            return false;
+        }
+
+        // Sort the arrays before comparison
+        const xSortedArr1 = pArray1.slice().sort();
+        const xSortedArr2 = pArray2.slice().sort();
+
+        // Check each element individually
+        for (let i = 0; i < xSortedArr1.length; i++) {
+            if (xSortedArr1[i] !== xSortedArr2[i]) {
+                return false;
+            }
+        }
+        // If all elements are equal, the arrays are equal
+        return true;
     }
 };
 

package/package.json

@@ -1,16 +1,16 @@
 {
     "name": "investira.sdk",
-    "version": "2.3.18",
+    "version": "2.3.20",
     "author": "Investira",
     "description": "Investira SDK",
     "main": "index.js",
     "type": "commonjs",
     "registry": true,
-    "raw": "investira.sdk@2.3.18",
+    "raw": "investira.sdk@2.3.20",
     "escapedName": "investira.sdk",
-    "rawSpec": "2.3.18",
+    "rawSpec": "2.3.20",
     "saveSpec": null,
-    "fetchSpec": "2.3.18",
+    "fetchSpec": "2.3.20",
     "homepage": "https://investira.com.br/",
     "engines": {
         "node": ">=11.11.0 <=18.12",
@@ -38,7 +38,7 @@
         "axios": "1.5.1",
         "deep-diff": "1.0.2",
         "flatted": "3.2.9",
-        "investira.data": "^1.3.6",
+        "investira.data": "^1.3.8",
         "moment": "^2.30.1"
     },
     "devDependencies": {