app-cron

As crons são usadas para rotinas que terão sua execução agendada, para criar uma cron siga o modelo já existente no projeto chamado app-cron, para cada cron deve-se criar um novo arquivo com o nome da cron a ser criada, este arquivo é apenas o start para uma entidade e metodo da pasta models/service. As crons devem ser inputadas no pm2 como um servico.

• Padrão de Retorno (OK)
  • Não há retornos;
  • Caso seja necessário pode enviar mensagens ao console;
  • Obrigatório a finalização do método com resolve();
• Padrão de Retorno (ERRO)
  • string;
  • O erro é exibido no log do console;
  • Obrigatório a finalização do método com reject();

app-console

Os aplicativos console são aplicativos que rodam de maneira desktop podendo ser usadas pelo cron-job do linux, agendador de tarefas do windows ou mesmo para excução manual pelo próprio usuário. Os aplicativos console não deve ser colocados no pm2 pois não possuem agendamentos em sua definição.

• Padrão de Retorno (OK)
  • Não há retornos;
  • Caso seja necessário pode enviar mensagens ao console;
  • Obrigatório a finalização do método com resolve();
• Padrão de Retorno (ERRO)
  • string;
  • O erro é exibido no log do console;
  • Obrigatório a finalização do método com reject();

app-api

As apis são serviços de rest-full usados comumente para sites, mobiles ou até mesmo para aplicativos desktop consumir e desenpenhar alguma tarefa, As apis devem ser inputadas no pm2 como serviço e deve-se ficar atendo a porta definida no arquivo start para que chocar com outra porta ja em uso do sistema operacional.

• Padrão de Retorno (OK)
  • Normal Padrão Genérico;

    {
      noTemplate: true, //(requerido)
      data: {}
    }

  • Normal com code Personalizado;

    {
      code: 1 //<Código Personalizado (>=0)>, (requerido)
      //<Normal sem Config/Normal com Config>
    }
    
    {
      code: 1 //<Código Personalizado (>=0)>, (requerido)
      data: {
        //<Normal sem Config/Normal com Config>
      }
    }

  • Normal sem config:

    {
      //<Dados do Retorno>
    }
    
    {
      data: {
        //<Dados do Retorno>
      }
    }

  • Normal com config:

    {
      data: {
        //<Dados do Retorno>
      },
      config: {
        //<Configurações>
      }
    }

  • Relatorio ejs:

    {
      report: true,
      viewName: 'nome' //<Nome da View>,
      data: {
        //<Dados>
      }
    }

  • Relatorio jasper Api externa ver parametro parameter.report.url:

    {
      report: true,
      jasper: true,
      viewName: 'nome' //<Nome da View>,
      data: {
        //<Dados>
      }
    }

  • Relatorio Api Node com jasper Api externa ver parametro parameter.report.url:

    {
      report: true,
      jaspernode: true,
      viewName: 'nome' //<Nome da View>,
      data: {
        //<Dados>
      }
    }

  • Excel Ver rotina helper.excel:

    {
      excel: true,
      buffer: '' //<Buffer do arquivo Gerado>,
      fileName: '' //<Nome do Arquivo para o navegador>
    }

  • Pdf:

    {
      pdf: true,
      fileName: '' //<Caminho do arquivo pdf>,
      delete: true //Apagar o arquivo após renderizar na resposta
    }

  • Html:

    {
      html: true,
      fileName: '' //<Caminho do arquivo html>
    }

  • Download:

    {
      download: true,
      fileName: '' //<Caminho do arquivo>
    }

• Padrão de Retorno (ERRO)
  • Normal;
    • string;
    • O erro é retornado para quem chamou o endpoint no campo message;
    • Obrigatório a finalização do método com reject();
  • Normal Avançado;
    • O erro é retornado para quem chamou o endpoint no campo message;
    • Obrigatório a finalização do método com reject();

      {
        code: -400 //<Código personalizado de erro (<0)> (requerido) ,
        message: 'Erro' //<Mensagem de Erro> (requerido) ,
        data: {}
        config: {}
      }

Banco de Dados

A configuração deve ser feita no arquivo start.js do projeto alterando variável config.database para bancos de dados comuns e para MongoDB usar a variável config.mongo_database

• Configuração basica; Esta configuração deve ser usada para todos os bancos de dados com exceção do MongoDB, esta configuração é o corpo principal para definição da conexão.

   {
       main: true, // true - Banco principal, false - Banco secundário
       type: 'mysql-access',
       config: {
         //<Configuração específica do banco, ver abaixo:>
       },
       execute: "set lc_time_names = 'pt_BR';",
       pool: null
       noAutoCreate: true /* false/null - Cria no inicio da api e é injetado em todas os endpoint,
                             true - Cria somente para os endopoints informados no parametro
                             config.connection_injection = [
                               {name: '', entity: '', method: ''}
                             ];
                             obs.: Válido somente para aplicações do tipo api usando o
                             inicalizador app-api.js.*/
   }

• Definição dos banco de dados;
  • Firebird

    {
       name: 'Nome do Banco',
       upperCaseString: true, // true - Caso tenha algum campo string que não pode ser convertido colocar nas exceções parameter.ignoreUpperCase.
       tableKeyIncrement: true, // true = Necessário haver uma tabela chamada controlenumeracao com os campos processo, chave,
       useControlFields: false, /* true - Necessário haver nas tabelas os campos:
                                        - usuarioinclusao,
                                        - usuarioalteracao,
                                        - usuarioinativacao,
                                        - usuarioativacao,
                                        - datainclusao,
                                        - dataalteracao,
                                        - dataexclusao,
                                        - datainativacao,
                                        - dataativacao,
                                        - status   (0 - Ativo; 1 - Inativo)*/
       host: 'servidor',
       user: 'usuario',
       password: 'senha',
       port: 3050,
       database: 'database',
       poolMax: 15,
       lowercase_keys: true
    }

  • MySQL

    {
       name: 'Nome do Banco',
       upperCaseString: true, // true - Caso tenha algum campo string que não pode ser convertido colocar nas exceções parameter.ignoreUpperCase.
       tableKeyIncrement: true, // true = Necessário haver uma tabela chamada controlenumeracao com os campos processo, chave
       useControlFields: false, /* true - Necessário haver nas tabelas os campos:
                                        - usuarioinclusao,
                                        - usuarioalteracao,
                                        - usuarioinativacao,
                                        - usuarioativacao,
                                        - datainclusao,
                                        - dataalteracao,
                                        - dataexclusao,
                                        - datainativacao,
                                        - dataativacao,
                                        - status   (0 - Ativo; 1 - Inativo)*/
       host: 'servidor',
       user: 'usuario',
       password: 'senha',
       database: 'database',
       multipleStatements: true,
       connectionLimit: 50,
       charset : 'utf8mb4',
       connectionLimit: 1000,
       connectTimeout: 60 * 60 * 1000,
       acquireTimeout: 60 * 60 * 1000,
       timeout: 60 * 60 * 1000,
    }

  • Oracle

    {
       name: 'Nome do Banco',
       upperCaseString: true, // true - Caso tenha algum campo string que não pode ser convertido colocar nas exceções parameter.ignoreUpperCase.
       tableKeyIncrement: true, // true = Necessário haver uma tabela chamada controlenumeracao com os campos processo, chave
       useControlFields: false, /* true - Necessário haver nas tabelas os campos:
                                        - usuarioinclusao,
                                        - usuarioalteracao,
                                        - usuarioinativacao,
                                        - usuarioativacao,
                                        - datainclusao,
                                        - dataalteracao,
                                        - dataexclusao,
                                        - datainativacao,
                                        - dataativacao,
                                        - status   (0 - Ativo; 1 - Inativo)*/
       user: 'usuario',
       password: 'senha',
       connectString: 'servidor:porta/database',
       poolMax: 15
    }

  • SQL Server

    {
       name: 'Nome do Banco',
       upperCaseString: true, // true - Caso tenha algum campo string que não pode ser convertido colocar nas exceções parameter.ignoreUpperCase.
       tableKeyIncrement: true, // true = Necessário haver uma tabela chamada controlenumeracao com os campos processo, chave
       useControlFields: false, /* true - Necessário haver nas tabelas os campos:
                                        - usuarioinclusao,
                                        - usuarioalteracao,
                                        - usuarioinativacao,
                                        - usuarioativacao,
                                        - datainclusao,
                                        - dataalteracao,
                                        - dataexclusao,
                                        - datainativacao,
                                        - dataativacao,
                                        - status   (0 - Ativo; 1 - Inativo)*/
       user: 'usuario',
       password: 'senha',
       server: 'servidor',
       database: 'database',
       max: 15,
       options: {
           encrypt: true,
           enableArithAbort: true
       }
    }

  • PostgreSQL

    {
       name: 'Nome do Banco',
       upperCaseString: true, // true - Caso tenha algum campo string que não pode ser convertido colocar nas exceções parameter.ignoreUpperCase.
       tableKeyIncrement: true, // true = Necessário haver uma tabela chamada controlenumeracao com os campos processo, chave
       useControlFields: false, /* true - Necessário haver nas tabelas os campos:
                                        - usuarioinclusao,
                                        - usuarioalteracao,
                                        - usuarioinativacao,
                                        - usuarioativacao,
                                        - datainclusao,
                                        - dataalteracao,
                                        - dataexclusao,
                                        - datainativacao,
                                        - dataativacao,
                                        - status   (0 - Ativo; 1 - Inativo)*/
       user: 'usuario',
       host: 'servidor',
       database: 'database',
       password: 'senha',
       port: 5432,
       max: 20,
       idleTimeoutMillis: 30000,
       connectionTimeoutMillis: 2000,
    }

• MongoDB; As configurações para um banco de dados MongoDB deve ser feita no arquivo start.js variável config.mongo_database

  {
    name: 'Nome do Banco',
    host: 'servidor',
    port: 27017,
    user: 'usuario',
    password: 'senha',
    database: 'database'
  }

Eventos

Os eventos devem ser definidos no arquivo event/events.js, os mesmos são executados em determinados momentos da codificação para que torne possivel tratar um dado ou definir um código em algum momento específico da execução, os eventos são separados por Eventos que possuem e não possuem retornos. Os eventos que possuem retorno se o mesmo não for tratado corretamente o fluxo da aplicação fica travado.

• Eventos com Retornos;
  • Eventos;
    • afterLogin;
    • afterEndpoint;
    • beforeTokenaccessValidation;
    • beforeDbInsert;
    • beforeDbChange
  • Exemplo

       events.addEvent('afterEndpoint', function (params) {
           return new Promise((resolve, reject) => {
               // Efetuar Tratametno aqui
               resolve({
                   processValues: processValues,
                   config: config
               })
           })
       })

• Eventos sem Retornos;
  • Eventos;
    • beforeMongoCreateIndex;
    • afterMongoCreateIndex;
    • beforeMongoFind;
    • afterMongoFind;
    • beforeMongoDelete;
    • afterMongoDelete;
    • beforeMongoChange;
    • afterMongoChange;
    • beforeMongoInsert;
    • afterMongoInsert;
    • reportPreview;
    • startConsole;
    • finallyConsole;
    • consoleError;
    • beforeLogin;
    • beforeConnection;
    • afterConnection;
    • beforeMongoConnection;
    • afterMongoConnection;
    • urlError;
    • startApi;
    • responseOk;
    • responseError;
    • beforeHeaderValidation;
    • afterHeaderValidation;
    • beforeBodyValidation;
    • afterBodyValidation;
    • beforeDbSelect;
    • afterDbSelect;
    • beforeDbLoadSelectFile;
    • afterDbLoadSelectFile;
    • beforeDbSelectFile;
    • afterDbSelectFile;
    • afterDbInsert;
    • afterDbChange;
    • beforeDbExecute;
    • afterDbExecute;
    • beforeDbExecuteFile;
    • afterDbExecuteFile;
    • beforeDbDelete;
    • afterDbDelete;
    • beforeDbActive;
    • afterDbActive;
    • beforeDbInactive;
    • afterDbInactive;
    • beforeDbRollback;
    • afterDbRollback;
    • beforeDbCommit;
    • afterDbCommit;
    • beforeDbStartTransaction;
    • afterDbStartTransaction;
    • beforeDbDisconnect;
    • afterDbDisconnect;
    • beforeDbFindKey;
    • afterDbFindKey;
    • beforeTokenaccessGeneration;
    • afterTokenaccessGeneration;
    • afterTokenaccessValidation;
    • imagePreview;
    • beforeEndpoint;
    • cronStart;
    • cronBeforeExecute;
    • cronAfterExecute;
    • cronError;
    • startConsole;
    • endConsole
  • Exemplo

       events.addEvent('beforeLogin', function (params) {
           return new Promise((resolve, reject) => {
               // Efetuar Tratametno aqui
               resolve()
           })
       })

Microserviço

O Micro serviço é uma api normal porem com somente algumas definições dividindo o processo principal para melhor manutenção e aproveitamento de recursos, os micro serviços devem estar destacados na api principal na variável config.api.environment..microservices, a entidade e método não deve existir na api principal.

 - **Definição do Microserviço a Api Principal;**
   - O campo **config.api.environment.<environment>.microservices** é um array que recebe um objeto pra cada Microserviço contendo as seguintes configurações;
     - entity; **Nome da entidade no microserviço**
     - method; **Nome do método no microserviço**
     - url; **url do microserviço seguindo o layout abaixo**
       - **http://<Host>:<Porta>/api{method-html}**
   - Caso seja necessário enviar para o microserviço campos do tipo header personalizado os mesmos tevem estar escrito na requisição com underline no inicio de cada um, estes campos uma vez enviado para o microserviço os mesmos chegam lá sem o underline.