inicial

.env.prod

@@ -0,0 +1,8 @@
+DB_HOST=minhastar.com.br
+DB_USER=minhastar
+DB_PASS=Bd121012*
+DB_SCHEMA=minhastar
+TOKEN_SAPERX='eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJoYXNoIjoiZDY5N2FlM2Q5MTMzNTA5Y2UzYzIwNGEwZmRiMTVmOTciLCJpYXQiOjE1Nzk1MzcxMDF9.jTrvmfVCZiVZWc-j00Zo7Ab4O-kHHdXbYaxo9qYcs5w'
+URL_SAPERX=http://10.101.255.250:8080
+URL_IXC=https://sistema.star.psi.br/
+TOKEN_IXC='45:1f6ddb4d6abf3c9d2eaf1789a877735cb4288b657106ddd143b563e46948d2e6'

.gitignore

@@ -0,0 +1,6 @@
+package-lock.json
+/node_modules/*
+yarn.lock
+.yarn
+/data/*
+.env

.yarnrc.yml

@@ -0,0 +1 @@
+nodeLinker: node-modules

Atualiza_integrador_saperx.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+
+echo '------> INICIANDO ATUALIZACAO'
+
+rm integradorsaperx -rf
+git clone https://diogenes:Bd121012@git.tutech.com.br/TU/saperx.git integradorsaperx
+cd integradorsaperx
+docker build . -t tu/integradorsaperx --no-cache
+cd
+rm integradorsaperx -rf
+echo '-----> FIM'
+
+

Dockerfile

@@ -0,0 +1,16 @@
+FROM node:18
+
+ENV TZ America/Sao_Paulo
+WORKDIR /var/www/dados/
+COPY package*.json ./
+RUN apt-get update \
+    && apt-get upgrade -y 
+RUN apt-get install -yq nano
+RUN chmod -R 777 /var/www/dados  && chown -R node:node /var/www/dados
+COPY --chown=node:node . .
+RUN npm install --unsafe-perm
+RUN npm install -g knex
+EXPOSE 30000
+USER node
+
+CMD [ "npm", "start" ]

db/migrations/20210818220919_Usuarios.js

@@ -0,0 +1,16 @@
+exports.up = function(knex, Promise) {
+    return knex.schema.createTable('usuario', t => {
+        t.increments('Id')
+        t.string('Nome').notNullable()
+        t.string('Login').notNullable()
+        t.string('Senha').notNullable()
+        t.integer('Ativo').notNullable()
+        t.integer('Nivel').notNullable()
+        t.integer('Setor').notNullable()
+        t.datetime('UltimoLogin')
+    })
+  };
+  
+  exports.down = function(knex, Promise) {
+    return knex.schema.dropTable('usuario')
+  };

db/migrations/20210818225728_setor.js

@@ -0,0 +1,11 @@
+exports.up = function (knex, Promise) {
+    return knex.schema.createTable('setor', t => {
+        t.increments('Id')
+        t.string('Nome').notNullable()
+    })
+};
+
+exports.down = function (knex, Promise) {
+    return knex.schema.dropTable('setor')
+};
+

db/migrations/20210818225740_configuracao.js

@@ -0,0 +1,16 @@
+
+
+exports.up = function (knex, Promise) {
+    return knex.schema.createTable('configuracao', t => {
+        t.increments('Id')
+        t.string('Url')
+        t.integer('Ifbotmaster')
+        t.string('Urlmaster')
+        t.string('Fotoclientes')
+    })
+};
+
+exports.down = function (knex, Promise) {
+    return knex.schema.dropTable('configuracao')
+};
+

db/migrations/20220131143802_tb_backup.js

@@ -0,0 +1,13 @@
+
+exports.up = function(knex, Promise) {
+    return knex.schema.createTable('backup', t => {
+        t.increments('Id')
+        t.string('Nome').notNullable()
+        t.timestamp("Data").notNullable().defaultTo(knex.fn.now());  
+        t.integer('Status').notNullable()
+    })
+  };
+  
+  exports.down = function(knex, Promise) {
+    return knex.schema.dropTable('backup')
+  };

db/migrations/20220718161350_create_indique.js

@@ -0,0 +1,16 @@
+exports.up = function (knex, Promise) {
+    return knex.schema.createTable('indique', t => {
+        t.increments('Id')
+        t.string('NomeTitular').notNullable()
+        t.string('CpfTitular').notNullable()
+        t.string('TelefoneTitular').notNullable()
+        t.string('NomeIndicado').notNullable()
+        t.string('TelefoneIndicado').notNullable()
+        t.timestamp('DataCadastro').notNullable().defaultTo(knex.raw('CURRENT_TIMESTAMP'))
+        t.integer('Status').notNullable()
+    })
+};
+
+exports.down = function (knex, Promise) {
+    return knex.schema.dropTable('indique')
+};

db/migrations/20221119224043_cria_integracao.js

@@ -0,0 +1,16 @@
+exports.up = function(knex, Promise) {
+    return knex.schema.createTable('integracao', t => {
+        t.increments('Id')
+        t.string('Nome')
+        t.integer('Tipo')
+        t.string('Chave')
+        t.string('Url')
+        t.string('Token')
+        t.timestamp('Atualizacao').notNullable().defaultTo(knex.raw('CURRENT_TIMESTAMP'))
+        t.json("Outros")
+    })
+  };
+  
+  exports.down = function(knex, Promise) {
+    return knex.schema.dropTable('integracao')
+  };

db/migrations/20230725203258_pesquisa.js

@@ -0,0 +1,14 @@
+exports.up = function(knex, Promise) {
+  return knex.schema.createTable('pesquisa', t => {
+      t.increments('Id')
+      t.string('Nome').notNullable()
+      t.timestamp('DataCadastro').notNullable().defaultTo(knex.raw('CURRENT_TIMESTAMP'))
+      t.string('Descricao').notNullable()
+      t.string('Cabecalho')
+      t.string('Imagem')
+  })
+};
+
+exports.down = function(knex, Promise) {
+  return knex.schema.dropTable('pesquisa')
+};

db/migrations/20230725203505_avaliacao-basica.js

@@ -0,0 +1,13 @@
+exports.up = function(knex, Promise) {
+  return knex.schema.createTable('avaliacao_basica', t => {
+      t.increments('Id')
+      t.integer('Pesquisa').unsigned().references('Id').inTable('pesquisa').onDelete('CASCADE').index().notNullable()
+      t.string('Cliente').notNullable()
+      t.integer('Nota').notNullable()
+      t.timestamp('DataCadastro').notNullable().defaultTo(knex.raw('CURRENT_TIMESTAMP'))
+  })
+};
+
+exports.down = function(knex, Promise) {
+  return knex.schema.dropTable('avaliacao_basica')
+};

db/migrations/20230725203515_avaliacao-completa.js

@@ -0,0 +1,13 @@
+exports.up = function(knex, Promise) {
+  return knex.schema.createTable('avaliacao_completa', t => {
+      t.increments('Id')
+      t.integer('Pesquisa').unsigned().references('Id').inTable('pesquisa').onDelete('CASCADE').index().notNullable()
+      t.string('Cliente').notNullable()
+      t.timestamp('DataCadastro').notNullable().defaultTo(knex.raw('CURRENT_TIMESTAMP'))
+      t.integer('Dados').notNullable()
+  })
+};
+
+exports.down = function(knex, Promise) {
+  return knex.schema.dropTable('avaliacao_completa')
+};

db/migrations/20230725203522_campos-pesquisa.js

@@ -0,0 +1,13 @@
+exports.up = function(knex, Promise) {
+  return knex.schema.createTable('campos_pesquisa', t => {
+      t.increments('Id')
+      t.integer('Pesquisa').unsigned().references('Id').inTable('pesquisa').onDelete('CASCADE').index().notNullable()
+      t.string('Descricao').notNullable()
+      t.string('Nome').notNullable()
+      t.string('TipoValor').notNullable()
+  })
+};
+
+exports.down = function(knex, Promise) {
+  return knex.schema.dropTable('campos_pesquisa')
+};

db/migrations/20230727182754_update_avaliacao_completa.js

@@ -0,0 +1,11 @@
+exports.up = function(knex, Promise) {
+  return knex.schema.alterTable('avaliacao_completa', t => {
+    t.json('Dados').notNullable().alter();
+  });
+};
+
+exports.down = function(knex, Promise) {
+  return knex.schema.alterTable('avaliacao_completa', t => {
+    t.integer('Dados').notNullable().alter();
+  });
+};

db/migrations/20230731132926_update_pesquisa.js

@@ -0,0 +1,11 @@
+exports.up = function(knex, Promise) {
+  return knex.schema.alterTable('pesquisa', t => {
+    t.integer('IconePesquisa').notNullable()
+  });
+};
+
+exports.down = function(knex, Promise) {
+  return knex.schema.alterTable('pesquisa', t => {
+    t.dropColumn('IconePesquisa')
+  });
+};

db/migrations/20230803183953_ajuste_pesquisa.js

@@ -0,0 +1,11 @@
+exports.up = function(knex, Promise) {
+  return knex.schema.alterTable('pesquisa', t => {
+    t.string('Cor').notNullable()
+  });
+};
+
+exports.down = function(knex, Promise) {
+  return knex.schema.alterTable('pesquisa', t => {
+    t.dropColumn('Cor')
+  });
+};

db/migrations/20230804174546_ajuste2_pesquisa.js

@@ -0,0 +1,13 @@
+exports.up = function(knex, Promise) {
+  return knex.schema.alterTable('pesquisa', t => {
+    t.string('CorTexto').notNullable()
+    t.integer('Status').notNullable()
+  });
+};
+
+exports.down = function(knex, Promise) {
+  return knex.schema.alterTable('pesquisa', t => {
+    t.dropColumn('CorTexto')
+    t.dropColumn('Status')
+  });
+};

db/seeds/001setor.js

@@ -0,0 +1,12 @@
+
+exports.seed = function(knex) {
+  // Deletes ALL existing entries
+  return knex('setor').del()
+    .then(function () {
+      // Inserts seed entries
+      return knex('setor').insert([
+        {Id: 1, Nome: 'ENTRADA'}
+        
+      ]);
+    });
+};

db/seeds/configuracao.js

@@ -0,0 +1,17 @@
+
+exports.seed = function(knex) {
+  // Deletes ALL existing entries
+  return knex('configuracao').del()
+    .then(function () {
+      // Inserts seed entries
+      return knex('configuracao').insert([
+        {
+          Id: 1, 
+          Url: 'https://api.star.tv.br',
+          Ifbotmaster: 1,
+          Urlmaster: 'https://starcorp.star.psi.br/web/',
+          Fotoclientes: 'http://starcorp.star.psi.br/web/img/foto.png'
+        }
+      ]);
+    });
+};

db/seeds/usuario.js

@@ -0,0 +1,19 @@
+
+exports.seed = function(knex) {
+  // Deletes ALL existing entries
+  return knex('usuario').del()
+    .then(function () {
+      // Inserts seed entries
+      return knex('usuario').insert([
+        {
+          "Id": 2,
+          "Nome": "SysDev",
+          "Login": "sysdev",
+          "Senha": "$2b$08$OckwNAnmdnIyjiDtCRpXN./1h2pphmTFdKpQz.U3ZLHt63Rq7NmHC",
+          "Ativo": 1,
+          "Nivel": 1,          
+          "Setor": 1
+        }
+      ]);
+    });
+};

index.js

@@ -0,0 +1,8 @@
+const CoreFactory = require("./src/factories/Core.factory");
+
+
+try {
+    CoreFactory.Iniciar()
+} catch (error) {
+    console.log(error)
+}

knexfile.js

@@ -0,0 +1,58 @@
+require('dotenv').config()
+
+module.exports = {
+
+  development: {
+    client: 'mysql',
+    connection: {
+      host: process.env.DB_HOST,
+      user: process.env.DB_USER,
+      port: process.env.DB_PORT,
+      password: process.env.DB_PASS,
+      database: process.env.DB_SCHEMA,
+      charset: "utf8mb4",
+      collation: "utf8mb4_bin",
+    },
+    migrations: {
+      tableName: 'knex_migrations',
+      directory: './db/migrations'
+    },
+    seeds: {
+      tableName: 'knex_seeds',
+      directory: './db/seeds'
+    }
+  },
+/*
+  staging: {
+    client: 'postgresql',
+    connection: {
+      database: 'my_db',
+      user: 'username',
+      password: 'password'
+    },
+    pool: {
+      min: 2,
+      max: 10
+    },
+    migrations: {
+      tableName: 'knex_migrations'
+    }
+  },
+
+  production: {
+    client: 'postgresql',
+    connection: {
+      database: 'my_db',
+      user: 'username',
+      password: 'password'
+    },
+    pool: {
+      min: 2,
+      max: 10
+    },
+    migrations: {
+      tableName: 'knex_migrations'
+    }
+  }*/
+
+};

package.json

@@ -0,0 +1,44 @@
+{
+  "name": "minhastar_api",
+  "version": "0.2.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "dev": "nodemon --require dotenv/config index.js",
+    "start": "node --require dotenv/config index.js"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "-": "^0.0.1",
+    "axios": "^0.21.0",
+    "bcrypt": "^5.0.0",
+    "body-parser": "^1.19.0",
+    "cli-color": "^2.0.3",
+    "cors": "^2.8.5",
+    "cpf-cnpj-validator": "^1.0.3",
+    "crypto-js": "^4.1.1",
+    "dotenv": "^8.2.0",
+    "express": "^4.17.2",
+    "express-graphql": "^0.12.0",
+    "fs": "^0.0.1-security",
+    "jsonwebtoken": "^8.5.1",
+    "knex": "^2.5.1",
+    "mime-types": "^2.1.27",
+    "moment": "^2.29.1",
+    "multer": "^1.4.5-lts.1",
+    "mysql": "^2.18.1",
+    "node-schedule": "^2.1.0",
+    "nodemailer": "^6.8.0",
+    "objection": "^3.0.0",
+    "objection-unique": "^1.2.1",
+    "query-string": "^7.0.1",
+    "request": "^2.88.2",
+    "save": "^2.4.0",
+    "socket.io": "^3.0.4",
+    "underscore": "^1.13.2"
+  },
+  "devDependencies": {
+    "nodemon": "^2.0.6"
+  }
+}

src/Modules/ixc/clientes.js

@@ -0,0 +1,36 @@
+const axios = require('axios');
+
+
+
+module.exports = {
+    buscacliente: async (cpfcliente) => {
+
+        let token = process.env.TOKEN_IXC;
+    
+        return axios.post(process.env.URL_IXC + "webservice/v1/cliente",
+            {
+                qtype: 'cliente.cnpj_cpf',
+                query: cpfcliente,
+                oper: '=',
+                page: '1',
+                rp: '20',
+                sortname: 'cliente.id',
+                sortorder: 'desc',
+                json: true
+            },
+            {
+                headers:
+                {
+                    'Content-Type': 'application/json',
+                    Authorization: 'Basic ' + new Buffer.from(token).toString('base64'),
+                    ixcsoft: 'listar'
+                }
+            })
+            .then(async function (response) {
+                //console.log(response.data)
+                return response.data
+            }).catch(error => {
+                console.log(error)
+            });
+    }
+}

src/Modules/ixc/contratos.js

@@ -0,0 +1,104 @@
+require('dotenv').config()
+const axios = require('axios');
+const fs = require('fs');
+const Path = require('path')
+module.exports = {
+    baixacontrato: async (idcontrato) => {
+
+        let token = process.env.TOKEN_IXC;
+
+        return axios.post(process.env.URL_IXC + "webservice/v1/botao_rel_20939",
+            {
+                id: idcontrato,
+                json: true
+            },
+            {
+                responseType: 'stream',
+                headers:
+                {
+                    'Content-Type': 'application/json',
+                    Authorization: 'Basic ' + new Buffer.from(token).toString('base64'),
+                    ixcsoft: 'listar'
+                }
+            })
+            .then(async function (response) {
+
+                var caminho = process.env.PATH_CONTRATOS + idcontrato + ".pdf"
+                const path = Path.resolve(caminho)
+                const writer = fs.createWriteStream(path)
+                await response.data.pipe(writer)
+                new Promise((resolve, reject) => {
+                    writer.on('finish', resolve)
+                    writer.on('error', reject)
+                })
+
+                return caminho
+            }).catch(error => {
+                console.log(error)
+            });
+    },
+    baixacontrato2: async (idcontrato) => {
+
+        let token = process.env.TOKEN_IXC;
+
+        return axios.post(process.env.URL_IXC + "webservice/v1/cliente_contrato_imprimir_contrato_17678",
+            {
+                id: idcontrato,
+                json: true
+            },
+            {
+                responseType: 'stream',
+                headers:
+                {
+                    'Content-Type': 'application/json',
+                    Authorization: 'Basic ' + new Buffer.from(token).toString('base64'),
+                    ixcsoft: 'listar'
+                }
+            })
+            .then(async function (response) {
+
+                var caminho = process.env.PATH_CONTRATOS + idcontrato + ".pdf"
+                const path = Path.resolve(caminho)
+                const writer = fs.createWriteStream(path)
+                await response.data.pipe(writer)
+                new Promise((resolve, reject) => {
+                    writer.on('finish', resolve)
+                    writer.on('error', reject)
+                })
+
+                return caminho
+            }).catch(error => {
+                console.log(error)
+            });
+    },
+    BuscaContratos: async (IdCliente) => {
+
+        let token = process.env.TOKEN_IXC;
+
+        return axios.post(process.env.URL_IXC + "webservice/v1/cliente_contrato",
+            {
+                qtype: 'cliente_contrato.id_cliente',
+                query: IdCliente,
+                oper: '=',
+                page: '1',
+                rp: '20',
+                sortname: 'cliente_contrato.id',
+                sortorder: 'desc',
+                json: true
+            },
+            {
+                headers:
+                {
+                    'Content-Type': 'application/json',
+                    Authorization: 'Basic ' + new Buffer.from(token).toString('base64'),
+                    ixcsoft: 'listar'
+                }
+            })
+            .then(async function (response) {
+                // console.log(response.data)
+                return response.data
+            }).catch(error => {
+                console.log(error)
+            });
+    }
+}

src/Modules/saperx/circuitos.js

@@ -0,0 +1,29 @@
+const axios = require('axios');
+
+
+
+module.exports = {
+    BuscaFatura: async (id,mes) => {
+
+        let token = process.env.TOKEN_SAPERX;
+        return axios.post(process.env.URL_SAPERX + "/billing",
+            {
+                "month_bill": mes,
+                "id_sip": id
+            },
+            {
+                headers:
+                {
+                    'Content-Type': 'application/json',
+                    Authorization: 'Bearer ' + token
+
+                }
+            })
+            .then(async function (response) {
+                //console.log(response)
+                return response.data
+            }).catch(error => {
+                console.log(error)
+            });
+    }
+}

src/config/db.config.js

@@ -0,0 +1,51 @@
+require('dotenv').config()
+
+const mysql = require('mysql');
+const connection = mysql.createConnection({
+  host: process.env.DB_HOST,
+  port: process.env.DB_PORT,
+  user: process.env.DB_USER,
+  password: process.env.DB_PASS,
+  database: process.env.DB_SCHEMA,
+  charset: "utf8mb4",
+  collation: "utf8mb4_bin",
+});
+
+var knex = require('knex')({
+  client: 'mysql',
+  connection: {
+    host: "10.101.255.243",
+    port: 3306,
+    user: "chamado31993",
+    password: "7Bk@JDwsVA",
+    database: "spx_o",
+    charset: "utf8mb4",
+    collation: "utf8mb4_bin",
+  }
+});
+
+var knexlocal = require('knex')({
+  client: 'mysql',
+  connection: {
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASS,
+    database: process.env.DB_SCHEMA,
+    charset: "utf8mb4",
+    collation: "utf8mb4_bin",
+  },
+  migrations: {
+    tableName: 'knex_migrations',
+    directory: './db/migrations'
+  },
+  seeds: {
+    tableName: 'knex_seeds',
+    directory: './db/seeds'
+  }
+});
+
+
+module.exports.connection = connection;
+module.exports.knex = knex;
+module.exports.knexlocal = knexlocal;

src/config/pass.js

@@ -0,0 +1,4 @@
+module.exports = {
+    'secret': process.env.SECRET_PASS_TOKEN == undefined ?  'ASDasdwqriodsfmfsddsfjkldsfkljfsdsdnfkjsdflkdhsgkjsdfdsf' : process.env.SECRET_PASS_TOKEN
+};
+

src/config/server.js

@@ -0,0 +1,2 @@
+const port = 4000;
+module.exports.port = port;

src/controllers/Cadastros.Controller.js

@@ -0,0 +1,129 @@
+const { Indique } = require("../models/Indique.model");
+const nodemailer = require("nodemailer");
+module.exports = {
+  trabalhe: async function (req, res) {
+    const { Id, Mensagem } = req.body;
+    var arq = Mensagem.split(";base64,")[1];
+    var min = Mensagem.split(";base64,")[0];
+    var Mime = min.split("data:")[1];
+    console.log(Mime);
+    var exts = mime.extension(Mime);
+
+    var nomeaudio = "/data/arq/" + Math.random().toString(36).substring(7);
+    await fs.writeFile(
+      "." + nomeaudio + "." + exts,
+      arq,
+      "base64",
+      function (err) {
+        console.log(err);
+      }
+    );
+    /*
+                const media = await new MessageMedia(Mime, arq, exts);
+                var saida = await Cliente.query().where("Id", Id).first().then(async (cliente, erro) => {
+                    var Mensg = nomeaudio + "." + exts
+        
+                    var rows = await RespondeMensagemMediaRubi(cliente, Mensg, media, exts, Mime);
+                    await VistoMensagens(cliente.Id);
+        
+        
+                    io.emit('MESSAGE', {
+                        Acao: "Arquivo Enviada",
+                        Wid: cliente.Wid
+                    });
+                    return rows
+                })*/
+    res.json({ ok: "ok" });
+  },
+  indique: async function (req, res) {
+    var { NomeTitular } = req.body;
+    if (NomeTitular != undefined) {
+      await Indique.query()
+        .insert({
+          NomeTitular: req.body.NomeTitular,
+          CpfTitular: req.body.CpfTitular,
+          TelefoneTitular: req.body.TelefoneTitular,
+          NomeIndicado: req.body.NomeIndicado,
+          TelefoneIndicado: req.body.TelefoneIndicado,
+          Status: 1,
+        })
+        .then(async () => {
+          const transporter = nodemailer.createTransport({
+            host: "star.psi.br",
+            port: 465,
+            secure: true, // true for 465, false for other ports
+            auth: {
+              user: "naoresponda@star.psi.br",
+              pass: "1GW23telecom4",
+            },
+            tls: { rejectUnauthorized: false },
+          });
+          const mailOptions = {
+            from: "naoresponda@star.psi.br",
+            to: "luciana@star.psi.br",
+            subject: "Star Tem indicação!!",
+            text: "Tem indicação no site. ;)",
+          };
+          await transporter.sendMail(mailOptions, function (error, info) {
+            if (error) {
+              console.log(error);
+            } else {
+              console.log("Email enviado: " + info.response);
+            }
+          });
+          res.status(200).send({ status: true });
+        })
+        .catch((err) => {
+          res.status(401).send({ err });
+        });
+    } else {
+      res
+        .status(200)
+        .send({ status: false, msg: "algo de errado nao esta certo" });
+    }
+  },
+  indiqueLista: async function (req, res) {
+    await Indique.query()
+      .then(async (indicacao) => {
+        res.status(200).send({ status: true, indicacao: indicacao });
+      })
+      .catch((err) => {
+        res.status(401).send({ err });
+      });
+  },
+  EnviarContatoSite: async function (req, res) {
+    var { Nome, Telefone, Email, Mensagem } = req.body;
+    const transporter = nodemailer.createTransport({
+      host: "star.psi.br",
+      port: 465,
+      secure: true, // true for 465, false for other ports
+      auth: {
+        user: "naoresponda@star.psi.br",
+        pass: "1GW23telecom4",
+      },
+      tls: { rejectUnauthorized: false },
+    });
+    const mailOptions = {
+      from: "naoresponda@star.psi.br",
+      to: "luciana@star.psi.br;contato@star.psi.br;volnei@star.psi.br",
+      subject: "Star tem contato do site!!",
+      html:
+        "Tem contato do site. ;) <br/> Nome: " +
+        Nome +
+        "<br/> Telefone: " +
+        Telefone +
+        "<br/> Email: " +
+        Email +
+        "<br/> Mensagem: <br/>" +
+        Mensagem,
+    };
+    await transporter.sendMail(mailOptions, function (error, info) {
+      if (error) {
+        console.log(error);
+      } else {
+        console.log("Email enviado: " + info.response);
+      }
+    });
+    res.status(200).send({ status: true });
+  },
+};

src/controllers/Login.Controller.js

@@ -0,0 +1,15 @@
+const IxcFactory = require("../core/ixc/Ixc.factory");
+
+module.exports = {
+  ListaLogin: async function (req, res) {
+    var { ClienteIdIxc } = req.user;
+    let resposta = await IxcFactory.BuscaLoginsDoCliente(ClienteIdIxc);
+    return res.status(200).send(resposta);
+  },
+  LoginConsumo: async function (req, res) {
+    // VARIAVEL TIPO DE CONSUMO SERVE PRA ESCOLHER QUAL TIPO DE DADO:: 1 PARA CONSUMO 20MINUTOS, 2 PARA CONSUMO DIARIO E 3 PARA CONSUMO MENSAL
+    var { tipo_consumo, IdLogin } = req.body;
+    let resposta = await IxcFactory.ConsumoLogin(IdLogin, tipo_consumo);
+    return res.status(200).send(resposta);
+  },
+};

src/controllers/Telefonia.Controller.js

@@ -0,0 +1,84 @@
+const { BuscaFatura } = require("../Modules/saperx/circuitos");
+const IxcFactory = require("../core/ixc/Ixc.factory");
+const SaperxFactory = require("../core/saperx/Saperx.factory");
+const { Ramais } = require("../models/Ramais.model");
+
+module.exports = {
+  Token: async function (req, res) {
+    const { month_bill, id_sip } = req.body;
+    await SaperxFactory.RefreshToken();
+    res.json({ ok: "ok" });
+  },
+  BuscaCircuitos: async function (req, res) {
+    var { busca } = req.body;
+
+    // Use .query() para começar uma nova consulta
+    const query = Ramais.query()
+      .withGraphFetched("did")
+      .withGraphFetched("ramais_franquias");
+
+    // Use .orWhere para adicionar as condições "like" nas colunas id, circuito e numero da tabela did
+    query
+      .joinRelated("did")
+      .orWhere("ramais.id", "like", `%${busca}%`)
+      .orWhere("ramais.nome", "like", `%${busca}%`)
+      .orWhere("ramais.ramal", "like", `%${busca}%`)
+      .orWhere("did.numero", "like", `%${busca}%`);
+
+    // Execute a consulta e envie a resposta quando terminar
+    try {
+      const ramais = await query;
+      res.json({ ramais });
+    } catch (error) {
+      console.error(error);
+      res.status(500).json({ error: "Ocorreu um erro ao buscar os ramais." });
+    }
+  },
+  VerCircuitos: async function (req, res) {
+    var { busca } = req.body;
+
+    // Use .query() para começar uma nova consulta
+    const query = Ramais.query()
+      .withGraphFetched("did")
+      .withGraphFetched("ramais_franquias");
+
+    // Use .orWhere para adicionar as condições "like" nas colunas id, circuito e numero da tabela did
+    query
+      .joinRelated("did")
+      .orWhere("ramais.id",  busca)
+      .orWhere("ramais.nome", busca)
+      .orWhere("ramais.ramal", busca)
+      .orWhere("did.numero", busca);
+
+    // Execute a consulta e envie a resposta quando terminar
+    try {
+      const ramais = await query;
+      res.json({ ramais });
+    } catch (error) {
+      console.error(error);
+      res.status(500).json({ error: "Ocorreu um erro ao buscar os ramais." });
+    }
+  },
+  Circuitos: async function (req, res) {
+    try {
+      let { IdCliente } = req.body;
+
+      if (!IdCliente) {
+        return res.status(401).send({ msg: "Informacoes faltando!" });
+      }
+
+      var dados = await IxcFactory.BuscaTelefonia(IdCliente);
+      var { id_sip } = dados.circuitos[2];
+      var dados = await SaperxFactory.Buscacircuitos(id_sip);
+      res.json({ dados });
+    } catch (error) {
+      console.log(error);
+      return res.status();
+    }
+  },
+  Fatura: async function (req, res) {
+    const { month_bill, id_sip } = req.body;
+    var dados = await BuscaFatura(id_sip, month_bill);
+    res.json({ ok: "ok", dados: dados });
+  },
+};

src/controllers/UsuarioController.js

@@ -0,0 +1,181 @@
+const config = require("../config/pass");
+const IxcFactory = require("../core/ixc/Ixc.factory");
+const { LoginCliente } = require("../core/ixc/clientes.ixc");
+const { test, Usuario } = require("../models/Usuario");
+const bcrypt = require("bcrypt");
+const jwt = require("jsonwebtoken");
+const { OrganizaDados } = require("../functions/clientes/AjustesCadastrais");
+
+module.exports = {
+  Login: async function (req, res) {
+    if (req.body.Senha == undefined) {
+      return res.status(200).send({
+        auth: false,
+        token: null,
+        data: { erro: "Não esqueceu de nada?" },
+      });
+    }
+    var user = await Usuario.query()
+      .where("Login", req.body.Login)
+      .first()
+      .then((user, err) => {
+        //console.log(user.Senha)
+        if (err) return res.status(500).send("Error on the server.");
+        if (!user) return res.status(404).send("Usuario não localizado.");
+        if (user.Ativo == 0) return res.status(401).send("Usuario inativo");
+        let passwordIsValid = bcrypt.compareSync(req.body.Senha, user.Senha);
+        if (!passwordIsValid)
+          return res
+            .status(401)
+            .send("Combinação de usuario e senha inválida!");
+        let token = jwt.sign({ id: user.Id, dados: user }, config.secret, {
+          expiresIn: 86400, // expires in 24 hours
+        });
+        res.status(200).send({ auth: true, token: token, user: user });
+      });
+  },
+  Ixc: async function (req, res) {
+    var { Login, Senha } = req.body;
+
+    if (Senha == undefined || Login == undefined) {
+      return res.status(200).send({
+        auth: false,
+        token: null,
+        data: { erro: "Não esqueceu de nada?" },
+      });
+    } else {
+      Login = Login.replace(/\D/g, "");
+      let resposta = await IxcFactory.LoginNoIxc(Login, Senha);
+
+      if (resposta.status) {
+        var dados = await OrganizaDados(resposta.cliente);
+
+        if (dados.Status == 0) {
+          return res.status(401).send({ auth: false, msg: "Usuário inativo!" });
+        }
+
+        let token = jwt.sign(
+          {
+            id: dados.id,
+            dados: {
+              Id: dados.Id,
+              Nome: dados.Nome,
+              Cpf: dados.cnpj_cpf,
+              Email: dados.email,
+              Telefone: dados.telefone_celular,
+            },
+            ClienteIdIxc: dados.id,
+            sistema: "minhastar",
+          },
+          config.secret,
+          {
+            expiresIn: 86400, // expires in 24 hours
+          }
+        );
+        res.status(200).send({ auth: true, token: token, user: resposta });
+      } else {
+        res.status(401).send({ auth: false, msg: resposta.msg });
+      }
+    }
+  },
+  Status: async function (req, res) {
+    res.status(200).send({ ok: true, dados: req.user });
+  },
+
+  Listar: async function (req, res) {
+    try {
+      await Usuario.query()
+        .then(async (usuarios) => {
+          res.status(200).send(usuarios);
+        })
+        .catch((error) => {
+          console.log(error);
+          res.send(error);
+        });
+    } catch (error) {
+      console.log(error);
+    }
+  },
+
+  Cadastrar: async function (req, res) {
+    try {
+      let { DadosUsuario } = req.body;
+
+      if (DadosUsuario) {
+        await Usuario.query()
+          .insert({
+            Nome: DadosUsuario.Nome,
+            Login: DadosUsuario.Login,
+            Senha: bcrypt.hashSync(DadosUsuario.Senha, 8),
+            Ativo: DadosUsuario.Status ? 1 : 0,
+            Nivel: DadosUsuario.Nivel,
+            Setor: 1,
+          })
+          .then(async (usuariocadastrado) => {
+            res.status(200).send({ status: true, Usuario: usuariocadastrado });
+          })
+          .catch((error) => {
+            console.log(error);
+            res.send({ status: false, msg: "Erro ao cadastrar!" });
+          });
+      } else {
+        res.status(401).send({ msg: "Informacoes faltando!" });
+      }
+    } catch (error) {
+      console.log(error);
+      res.status(500).send({ msg: "Erro interno." });
+    }
+  },
+
+  Editar: async function (req, res) {
+    try {
+      let { DadosUsuario } = req.body;
+
+      if (DadosUsuario) {
+        await Usuario.query()
+          .where("Id", DadosUsuario.Id)
+          .first()
+          .then(async (user) => {
+            if (DadosUsuario.Senha == "") {
+              var usered = {
+                Nome: DadosUsuario.Nome,
+                Login: DadosUsuario.Login,
+                Nivel: parseInt(DadosUsuario.Nivel),
+                Ativo: DadosUsuario.Status ? 1 : 0,
+                Setor: 1,
+              };
+            } else {
+              var usered = {
+                Nome: DadosUsuario.Nome,
+                Login: DadosUsuario.Login,
+                Senha: bcrypt.hashSync(DadosUsuario.Senha, 8),
+                Nivel: parseInt(DadosUsuario.Nivel),
+                Ativo: DadosUsuario.Status ? 1 : 0,
+                Setor: 1,
+              };
+            }
+
+            user
+              .$query()
+              .patchAndFetchById(user.Id, usered)
+              .then(async (usuarioatt, err) => {
+                res.status(200).send({ status: true, Usuario: usuarioatt });
+              })
+              .catch((err) => {
+                console.log(err);
+                res.status(401).send({ status: false, erro: err });
+              });
+          })
+          .catch((error) => {
+            console.log(error);
+            res.send({ status: false, msg: "Erro ao atualizar!" });
+          });
+      } else {
+        res.status(401).send({ msg: "Informacoes faltando!" });
+      }
+    } catch (error) {
+      console.log(error);
+      res.status(500).send({ msg: "Erro interno." });
+    }
+  },
+};

src/core/Manipuladores.js

@@ -0,0 +1,34 @@
+const fs = require("fs");
+const path = require("path");
+
+module.exports = {
+  AlteraCaracter: async (arquivo, nome) => {
+    fs.readFile(arquivo, "utf-8", (err, data) => {
+      if (err) throw err;
+
+      // separa o arquivo em linhas
+      const lines = data.split(/\r?\n/);
+
+      // altera o valor do caractere na posição 143 para "1" em cada linha
+      for (let i = 0; i < lines.length; i++) {
+        lines[i] = lines[i].split("");
+        lines[i].splice(143, 1, "1");
+        lines[i] = lines[i].join("");
+      }
+      var dados = lines.join("\n") + "\n";
+      var cnpj = nome.substring(2, 16);
+      var ano = nome.substring(16, 18);
+      var pasta = path.join(
+        __dirname,
+        "../../data/uploads/" + cnpj + "/" + ano + "/"
+      );
+      if (!fs.existsSync(pasta)) {
+        fs.mkdirSync(pasta, { recursive: true }, (err) => {});
+      }
+      fs.writeFile(pasta + nome, dados, (err) => {
+        if (err) throw err;
+        console.log("Arquivo atualizado com sucesso!");
+      });
+    });
+  },
+};

src/core/ixc/Ixc.factory.js

@@ -0,0 +1,190 @@
+const clc = require("cli-color");
+const {
+  buscacliente,
+  buscaclienteidixc,
+  LoginCliente,
+} = require("./clientes.ixc");
+const { validacpfcnpf } = require("../../functions/clientes/AjustesCadastrais");
+const {
+  buscaloginscliente,
+  buscalogin,
+  buscaConsumo,
+} = require("./logins.ixc");
+const {
+  BuscaFinanceiroAberto,
+  buscaPix,
+  buscaFaturaPdf,
+  BuscaFinanceiro,
+} = require("./financeiro.ixc");
+const {
+  BuscaContratos,
+  BuscaVendasNotas,
+  BuscaPDFNotas,
+  DesbloqueioConfianca,
+} = require("./contratos.ixc");
+const { BuscaCircuitosTelefoniaIXC } = require("./telefonia.ixc");
+
+class IxcFactory {
+  static Iniciar(client, data) {}
+  static async BuscaCliente(cpfcliente) {
+    var cnpj_cpf = await validacpfcnpf(cpfcliente);
+    if (cnpj_cpf.status) {
+      let cliente = await buscacliente(cnpj_cpf.CpfCnpj);
+      if (cliente.status && cliente.total != 0) {
+        return { status: true, cliente: cliente.dados.registros[0] };
+      } else {
+        return { status: false, msg: "Nenhum registro encontrado" };
+      }
+    } else {
+      return { status: false, msg: "Cnpj ou Cpf invalido!!" };
+    }
+  }
+
+  static async BuscaClientePorId(idixc) {
+    let cliente = await buscaclienteidixc(idixc);
+    if (cliente.status && cliente.total != 0) {
+      return { status: true, cliente: cliente.dados.registros[0] };
+    } else {
+      return { status: false, msg: "Nenhum registro encontrado" };
+    }
+  }
+
+  static async BuscaLoginsDoCliente(IdDoCliente) {
+    return await buscaloginscliente(IdDoCliente);
+  }
+  static async BuscaLogin(IdLogin) {
+    return await buscalogin(IdLogin);
+  }
+  static async VerificaIpFixo(IdLogin) {
+    var login = await buscalogin(IdLogin);
+    if (login.status && login.dados.total != 0) {
+      if (login.dados.registros[0].fixar_ip == "S") {
+        return { status: true, fixo: true };
+      } else {
+        return { status: true, fixo: false };
+      }
+    } else {
+      return { status: false, msg: "Login não encontrado!!" };
+    }
+  }
+
+  static async LoginNoIxc(Login, Senha) {
+    let cliente = await LoginCliente(Login, Senha);
+    if (cliente.status && cliente.dados.total != 0) {
+      if (cliente.dados.registros[0].senha == Senha) {
+        return { status: true, cliente: cliente.dados.registros[0] };
+      } else {
+        return { status: false, msg: "Senha Incorreta" };
+      }
+    } else {
+      return { status: false, msg: "Usuário não encontrado!" };
+    }
+  }
+
+  static async ConsumoLogin(idLogin, tipo_consumo) {
+    let consumo = await buscaConsumo(idLogin, tipo_consumo);
+    if (consumo.status && consumo.dados.total != 0) {
+      return { status: true, consumo: consumo.dados.registros };
+    } else {
+      return { status: false, msg: "Consumo não encontrado!" };
+    }
+  }
+
+  static async BuscaFaturasPagas(id_cliente, inicio, fim) {
+    let financeiro = await BuscaFinanceiro(id_cliente, inicio, fim);
+    if (financeiro.status && financeiro.dados.total != 0) {
+      return { status: true, financeiro: financeiro.dados.registros };
+    } else {
+      return { status: false, msg: "Cliente não possui boletos!" };
+    }
+  }
+
+  static async BuscaBoletosAberto(id_cliente) {
+    let financeiro = await BuscaFinanceiroAberto(id_cliente);
+    
+    if (financeiro.status && financeiro.dados.total != 0) {
+      return { status: true, financeiro: financeiro.dados.registros };
+    } else {
+      return { status: false, msg: "Cliente não possui boletos!" };
+    }
+  }
+  static async BuscaChavePix(IdBoleto) {
+    let financeiro = await buscaPix(IdBoleto);
+    if (financeiro.status && financeiro.dados.type == "success") {
+      return { status: true, DadosPix: financeiro.dados.pix };
+    } else {
+      return {
+        status: false,
+        msg: "Esse boleto não possui uma cobrança PIX vinculada.",
+      };
+    }
+  }
+  static async BuscaArquivoPdf(IdBoleto) {
+    let financeiro = await buscaFaturaPdf(IdBoleto);
+
+    if (financeiro.status && financeiro.dados != "") {
+      return { status: true, BoletoBase64: financeiro.dados };
+    } else {
+      return {
+        status: false,
+        msg: "Esse boleto não possui pdf para impressao",
+      };
+    }
+  }
+
+  static async BuscaContratos(IdCliente) {
+    let contratos = await BuscaContratos(IdCliente);
+    if (contratos.status && contratos.dados != "") {
+      return { status: true, contratos: contratos.dados };
+    } else {
+      return {
+        status: false,
+        msg: "Esse cliente não possui contratos",
+      };
+    }
+  }
+  static async DesbloqueioConfiancaContratos(Idcontrato) {
+    let contratos = await DesbloqueioConfianca(Idcontrato);
+    if (contratos.status && contratos.dados != "") {
+      return { status: contratos.dados.tipo, mensagem: contratos.dados.mensagem };
+    } else {
+      return {
+        status: false,
+        msg: "Contrato precisa de atenção",
+      };
+    }
+  }
+  static async BuscaNotas(IdCliente) {
+    let notas = await BuscaVendasNotas(IdCliente);
+    if (notas.status && notas.dados != "") {
+      return { status: true, notas: notas.dados };
+    } else {
+      return {
+        status: false,
+        msg: "Esse cliente não possui notas",
+      };
+    }
+  }
+  static async ImprimirNotas(idvenda) {
+    let notas = await BuscaPDFNotas(idvenda);
+    if (notas.status && notas.dados != "") {
+      return { status: true, Notabase64: notas.dados };
+    } else {
+      return {
+        status: false,
+        msg: "Esse cliente não possui notas",
+      };
+    }
+  }
+  static async BuscaTelefonia(id_cliente) {
+    let circuitos = await BuscaCircuitosTelefoniaIXC(id_cliente);
+    
+    if (circuitos.status && circuitos.dados.total != 0) {
+      return { status: true, circuitos: circuitos.dados.registros };
+    } else {
+      return { status: false, msg: "Nenhum registro encontrado" };
+    }
+  }
+}
+
+module.exports = IxcFactory;

src/core/ixc/clientes.ixc.js

@@ -0,0 +1,132 @@
+const axios = require("axios");
+const { Integracao } = require("../../models/Integracao.model");
+
+module.exports = {
+  LoginCliente: async (usuario, senha) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/cliente",
+          {
+            qtype: "cliente.hotsite_email",
+            query: usuario,
+            oper: "=",
+            page: "1",
+            rp: "20",
+            sortname: "cliente.id",
+            sortorder: "desc",
+
+            json: true,
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    }else{
+      console.log("## Core IXC Clientes ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+    
+  },
+  buscacliente: async (cpfcliente) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/cliente",
+          {
+            qtype: "cliente.cnpj_cpf",
+            query: cpfcliente,
+            oper: "=",
+            page: "1",
+            rp: "20",
+            sortname: "cliente.id",
+            sortorder: "desc",
+
+            json: true,
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    }else{
+      console.log("## Core IXC Clientes ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+    
+  },
+
+  buscaclienteidixc: async (idixc) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/cliente",
+          {
+            qtype: "cliente.id",
+            query: idixc,
+            oper: "=",
+            page: "1",
+            rp: "20",
+            sortname: "cliente.id",
+            sortorder: "desc",
+
+            json: true,
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    }else{
+      console.log("## Core IXC Clientes ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+    
+  },
+};

src/core/ixc/contratos.ixc.js

@@ -0,0 +1,162 @@
+const axios = require("axios");
+const { Integracao } = require("../../models/Integracao.model");
+
+module.exports = {
+  BuscaContratos: async (iddocliente) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/cliente_contrato",
+          {
+            qtype: "cliente_contrato.id_cliente",
+            query: iddocliente,
+            oper: "=",
+            page: "1",
+            rp: "2000",
+
+            sortname: "cliente_contrato.tipo",
+            sortorder: "asc",
+            /*grid_param: JSON.stringify([
+              { TB: "fn_areceber.liberado", OP: "=", P: "S" },
+              { TB: "fn_areceber.status", OP: "!=", P: "C" },
+              { TB: "fn_areceber.status", OP: "!=", P: "R" },
+            ]),*/
+            json: true,
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+  BuscaVendasNotas: async (iddocliente) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/vd_saida",
+          {
+            qtype: "vd_saida.id_cliente",
+            query: iddocliente,
+            oper: "=",
+            page: "1",
+            rp: "200",
+
+            sortname: "vd_saida.id",
+            sortorder: "asc",
+            grid_param: JSON.stringify([
+              { TB: "vd_saida.id_tipo_documento", OP: "IN", P: "606,633,642,637" },
+            ]),
+            json: true,
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+  DesbloqueioConfianca: async (iddocontrato) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/desbloqueio_confianca",
+          {
+            id: iddocontrato
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+  BuscaPDFNotas: async (idvenda) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/imprimir_nota",
+          {
+            id: idvenda,
+            base64: "S",
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+};

src/core/ixc/financeiro.ixc.js

@@ -0,0 +1,217 @@
+const axios = require("axios");
+const { Integracao } = require("../../models/Integracao.model");
+
+module.exports = {
+  BuscaContratos: async (iddocliente) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/cliente_contrato",
+          {
+            qtype: "cliente_contrato.id_cliente",
+            query: iddocliente,
+            oper: "=",
+            page: "1",
+            rp: "200",
+
+            sortname: "cliente_contrato.id",
+            sortorder: "asc",
+            /*grid_param: JSON.stringify([
+              { TB: "fn_areceber.liberado", OP: "=", P: "S" },
+              { TB: "fn_areceber.status", OP: "!=", P: "C" },
+              { TB: "fn_areceber.status", OP: "!=", P: "R" },
+            ]),*/
+            json: true,
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+  BuscaFinanceiro: async (iddocliente, inicio, fim) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/fn_areceber",
+          {
+            qtype: "fn_areceber.id_cliente",
+            query: iddocliente,
+            oper: "=",
+            page: "1",
+            rp: "200",
+
+            sortname: "fn_areceber.data_vencimento",
+            sortorder: "asc",
+            grid_param: JSON.stringify([
+              { TB: "fn_areceber.liberado", OP: "=", P: "S" },
+              { TB: "fn_areceber.status", OP: "!=", P: "C" },
+              { TB: "fn_areceber.status", OP: "=", P: "R" },
+              { TB: "fn_areceber.data_vencimento", OP: ">", P: inicio },
+              { TB: "fn_areceber.data_vencimento", OP: "<", P: fim },
+            ]),
+            json: true,
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+  BuscaFinanceiroAberto: async (iddocliente) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/fn_areceber",
+          {
+            qtype: "fn_areceber.id_cliente",
+            query: iddocliente,
+            oper: "=",
+            page: "1",
+            rp: "20000",
+
+            sortname: "fn_areceber.data_vencimento",
+            sortorder: "asc",
+            grid_param: JSON.stringify([
+              { TB: "fn_areceber.liberado", OP: "=", P: "S" },
+              { TB: "fn_areceber.status", OP: "!=", P: "C" },
+              { TB: "fn_areceber.status", OP: "!=", P: "R" },
+            ]),
+            json: true,
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+  buscaPix: async (idlogin) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/get_pix",
+          {
+            id_areceber: idlogin,
+
+            json: true,
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+  buscaFaturaPdf: async (IdBoleto) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/get_boleto",
+          {
+            boletos: IdBoleto,
+            juro: "N",
+            multa: "N",
+            atualiza_boleto: "N",
+            tipo_boleto: "arquivo",
+            base64: "S",
+          },
+          {
+            headers: {
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+};

src/core/ixc/logins.ixc.js

@@ -0,0 +1,136 @@
+const axios = require("axios");
+const { Integracao } = require("../../models/Integracao.model");
+
+module.exports = {
+  buscaloginscliente: async (iddocliente) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/radusuarios",
+          {
+            qtype: "radusuarios.id_cliente",
+            query: iddocliente,
+            oper: "=",
+            page: "1",
+            rp: "20",
+            sortname: "radusuarios.login",
+            sortorder: "desc",
+
+            json: true,
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: false, dados: response.data.registros };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+  buscalogin: async (idlogin) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/radusuarios",
+          {
+            qtype: "radusuarios.id",
+            query: idlogin,
+            oper: "=",
+            page: "1",
+            rp: "20",
+            sortname: "radusuarios.login",
+            sortorder: "desc",
+
+            json: true,
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+  buscaConsumo: async (idlogin, tipo = 2) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      var tabela =
+        tipo == 1
+          ? "radusuarios_consumo"
+          : tipo == 2
+          ? "radusuarios_consumo_d"
+          : tipo == 3
+          ? "radusuarios_consumo_m"
+          : "radusuarios_consumo_d";
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/" + tabela,
+          {
+            qtype: tabela + ".id_login",
+            query: idlogin,
+            oper: "=",
+            page: "1",
+            rp: "200",
+            sortname: tabela + ".id",
+            sortorder: "desc",
+
+            json: true,
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+};

src/core/ixc/telefonia.ixc.js

@@ -0,0 +1,47 @@
+const axios = require("axios");
+const { Integracao } = require("../../models/Integracao.model");
+
+module.exports = {
+  BuscaCircuitosTelefoniaIXC: async (iddocliente) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 2)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      return axios
+        .post(
+          integracao.Url + "webservice/v1/view_voip_sippeers_cliente",
+          {
+            qtype: "view_voip_sippeers_cliente.cliente_id",
+            query: iddocliente,
+            oper: "=",
+            page: "1",
+            rp: "20",
+            sortname: "view_voip_sippeers_cliente.id",
+            sortorder: "desc",
+
+            json: true,
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization:
+                "Basic " + new Buffer.from(integracao.Token).toString("base64"),
+              ixcsoft: "listar",
+            },
+          }
+        )
+        .then(async function (response) {
+          return { status: true, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+  
+};

src/core/saperx/Saperx.factory.js

@@ -0,0 +1,28 @@
+const { AtualizaToken } = require("./Token.saperx");
+const { BuscaCircuitos, BuscaDIDCircuito } = require("./circuitos.saperx");
+
+class SaperxFactory {
+  static Iniciar(client, data) {}
+
+  static async RefreshToken() {
+    let token = await AtualizaToken();
+    if (true) {
+      return { status: true };
+    } else {
+      return { status: false, msg: "Nenhum registro encontrado" };
+    }
+  }
+  static async Buscacircuitos(id_sip) {
+    let circuitos = await BuscaCircuitos(id_sip);
+    if (circuitos.status) {
+      circuitos.dados.map(async (circuito) => {
+        circuito.Did = await BuscaDIDCircuito(circuito.id);
+      });
+      return { status: true, dados: circuitos.dados };
+    } else {
+      return { status: false, msg: "Nenhum registro encontrado" };
+    }
+  }
+}
+
+module.exports = SaperxFactory;

src/core/saperx/Token.saperx.js

@@ -0,0 +1,65 @@
+const axios = require("axios");
+const https = require("https");
+const { Integracao } = require("../../models/Integracao.model");
+const { default: knex } = require("knex");
+const moment = require("moment");
+
+module.exports = {
+  AtualizaToken: async (iddocliente) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 3)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+        const data = moment(integracao.Atualizacao);
+        const duasHorasAtras = moment().subtract(2, 'hours');
+        const eMaisAntiga = data.isBefore(duasHorasAtras);
+        if(!eMaisAntiga){
+            return { status: true, msg: "Token ainda é valido"}
+        }
+      var { Outros } = integracao;
+      var { client_id, client_secret, username, password } = JSON.parse(Outros);
+      return axios
+        .post(
+          integracao.Url + "oauth/token",
+          {
+            grant_type: "password",
+            client_id,
+            client_secret,
+            username,
+            password,
+            scope: "",
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+            },
+            httpsAgent: new https.Agent({ rejectUnauthorized: false }),
+          }
+        )
+        .then(async function (response) {
+          var { refresh_token, access_token } = response.data;
+
+          var nOutros = JSON.parse(Outros);
+          nOutros.Access_token = access_token;
+          nOutros.Refresh_token = refresh_token;
+
+          await integracao
+            .$query()
+            .patchAndFetchById(integracao.Id, {
+              Outros: JSON.stringify(nOutros),
+              Atualizacao: new Date()
+            })
+            .then();
+          return { status: false, dados: response.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+};

src/core/saperx/circuitos.saperx.js

@@ -0,0 +1,71 @@
+const axios = require("axios");
+const { Integracao } = require("../../models/Integracao.model");
+const https = require("https");
+module.exports = {
+
+
+  BuscaCircuitos: async (iddocliente) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 3)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      var { Outros } = integracao;
+      var { Access_token } = JSON.parse(Outros);
+      return axios
+        .get(`${integracao.Url}sip/${iddocliente}`, {
+          data: {
+            timestamp: Math.floor(Date.now() / 1000),
+          },
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer " + Access_token,
+          },
+          httpsAgent: new https.Agent({ rejectUnauthorized: false }),
+        })
+        .then(async function (response) {
+          console.log(response.data);
+          return { status: true, dados: response.data.data };
+        })
+        .catch((error) => {
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+  BuscaDIDCircuito: async (id_sip) => {
+    var integracao = await Integracao.query()
+      .where("Tipo", 3)
+      .first()
+      .then((integraca) => integraca);
+    if (integracao != []) {
+      var { Outros } = integracao;
+      var { Access_token } = JSON.parse(Outros);
+      return axios
+        .get(`${integracao.Url}did?id_sip=${id_sip}`, {
+          params: {
+            timestamp: Math.floor(Date.now() / 1000),
+            id_sip: id_sip,
+          },
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer " + Access_token,
+          },
+          httpsAgent: new https.Agent({ rejectUnauthorized: false }),
+        })
+        .then(async function (response) {
+          console.log(response.data);
+          return { status: true, dados: response.data.data };
+        })
+        .catch((error) => {
+          console.log(error);
+          return { status: false, msg: error };
+        });
+    } else {
+      console.log("## Core IXC Logins ", "Integração não configurada!!");
+      return { status: false, msg: "Integração não configurada!!" };
+    }
+  },
+};

src/core/saperx/database.saperx.js

@@ -0,0 +1,39 @@
+const { Integracao } = require("../../models/Integracao.model");
+
+module.exports = {
+  SaperxBanco: async () => {
+    var { conexaobanco, status } = GetDataBase();
+    if (status) {
+      return conexaobanco;
+    } else {
+      return false;
+    }
+  },
+};
+
+async function GetDataBase() {
+  var integracao = await Integracao.query()
+    .where("Tipo", 4)
+    .first()
+    .then((integraca) => integraca);
+  if (integracao != []) {
+    var { Url, Outros } = integracao;
+    var { usuario, senha, banco, porta } = JSON.parse(Outros);
+    var conexaobanco = require("knex")({
+      client: "mysql",
+      connection: {
+        host: Url,
+        port: porta == undefined ? 3306 : porta,
+        user: usuario,
+        password: senha,
+        database: banco,
+        charset: "utf8mb4",
+        collation: "utf8mb4_bin",
+      },
+    });
+    return { conexaobanco: conexaobanco, status: true };
+  } else {
+    console.log("## Core IXC Logins ", "Integração não configurada!!");
+    return { status: false, msg: "Integração não configurada!!" };
+  }
+}

src/factories/Banco.factory.js

@@ -0,0 +1,20 @@
+const clc = require("cli-color");
+var { version } = require("../../package.json");
+const { connection, knex } = require("../config/db.config");
+
+class BancodedadosFactory {
+  static Iniciar(client, data) {
+    connection.connect(function (err) {
+      if (err) throw err;
+      console.log(clc.green("BANCO DE DADOS CONECTOU ---> LoL!"));
+    });
+  }
+  static InstallMigrations() {
+    return knex.migrate.latest().then(() => {
+      console.log(clc.green("MIGRATIONS EXECUTADAS"));
+      return true;
+    });
+  }
+}
+
+module.exports = BancodedadosFactory;

src/factories/Config.factory.js

@@ -0,0 +1,13 @@
+const clc = require("cli-color");
+const { Configuracao } = require('../models/Configuracao');
+
+class ConfigFactory {
+    static Iniciar(server) {
+        Configuracao.query().where("Id", 1).first().then((config) => {
+            global.UrlBase = config.Url
+        })
+
+    }
+}
+
+module.exports = ConfigFactory;

src/factories/Core.factory.js

@@ -0,0 +1,22 @@
+const clc = require("cli-color");
+var { version } = require("../../package.json");
+const BancodedadosFactory = require("./Banco.factory");
+const ExpressFactory = require("./Server.factory");
+///const ConfigFactory = require("./Config.factory");
+//const RotinasFactory = require("./Rotinas.factory");
+
+
+class CoreFactory {
+    static async Iniciar() {
+        console.log(clc.green("BACKEND SENDO INICIADO!!"))
+        console.log(clc.green("VERSAO INICIADA ----> " + version))
+        //await BancodedadosFactory.InstallMigrations()
+        await BancodedadosFactory.Iniciar()
+        //await ConfigFactory.Iniciar()
+        //await RotinasFactory.Iniciar()
+        await ExpressFactory.Iniciar()
+        
+    }
+}
+
+module.exports = CoreFactory;

src/factories/Rotinas.factory.js

@@ -0,0 +1,11 @@
+const clc = require("cli-color");
+const Schedule = require("../middleware/Schedule");
+
+
+class RotinasFactory {
+    static Iniciar(server) {
+        Schedule.IniciaRotinas()
+    }
+}
+
+module.exports = RotinasFactory;

src/factories/Server.factory.js

@@ -0,0 +1,53 @@
+const clc = require("cli-color");
+const express = require('express');
+//const app = express();
+var bodyParser = require('body-parser');
+var cors = require('cors');
+const Roteamento = require("../routes");
+const { port } = require("../config/server");
+const SocketIoFactory = require("./SocketIo.factory");
+var { version } = require("./../../package.json");
+
+
+class ExpressFactory {
+
+
+    static Iniciar() {
+        this.app = express();
+        this.app.use(cors());
+        this.app.use(bodyParser.urlencoded({ extended: true }));
+        this.app.use(bodyParser.json({ limit: '50mb' }));
+        this.app.use(bodyParser.urlencoded({ limit: '50mb', extended: true }));
+        this.app.use('/data/img', express.static('data/img'))
+        this.app.use('/data/aud', express.static('data/aud'))
+        this.app.use('/data/arq', express.static('data/arq'))
+        this.app.use('/data/backup', express.static('backup/'))
+        this.app.use('/', express.static('frontend/'))
+        this.AtivarRotasStaticas(this.app)
+
+        Roteamento.IniciarRoteamento(this.app)
+        var server = this.app.listen(port, () => {
+            console.log(clc.blueBright("INICIANDO API NA PORTA: " + port));
+        });
+        SocketIoFactory.Iniciar(server)
+    }
+
+
+
+
+
+
+
+    static AtivarRotasStaticas(sistm) {
+        sistm.get('/help', async (req, res) => {
+
+            res.send({
+                Status: 'Ondeline!',
+                Versao: version                
+            })
+        })
+        
+    }
+}
+
+module.exports = ExpressFactory;

src/factories/SocketIo.factory.js

@@ -0,0 +1,19 @@
+const clc = require("cli-color");
+
+class SocketIoFactory {
+    static Iniciar(server) {
+        const io = require('socket.io')(server, {
+            cors: {
+                origin: '*',
+            }
+        });
+        global.io = io
+        io.on('connection', function (socket) {
+            //console.log(socket)
+        
+        });
+        
+    }
+}
+
+module.exports = SocketIoFactory;

src/functions/FuncoesArquivo.js

@@ -0,0 +1,49 @@
+const mysql = require("mysql");
+const fs = require("fs");
+const unidecode = require("unidecode");
+module.exports = {
+  lermestre: async (ano, mes) => {
+    const connection = mysql.createConnection({
+      host: "10.1.2.105",
+      user: "star",
+      password: "Bd121012%+",
+      database: "star",
+    });
+
+    connection.connect();
+
+    fs.readFile(
+      `mestre/RS189686640001042100U${ano}${mes}N01M.001`,
+      "utf-8",
+      (err, data) => {
+        if (err) throw err;
+
+        const lines = data.split("\n");
+
+        connection.query("TRUNCATE star.validacao", (err) => {
+          if (err) throw err;
+
+          for (let i = 0; i < lines.length; i++) {
+            const linha = lines[i];
+            const nome = unidecode(linha.slice(28, 62).replace(/ç/g, "c"));
+            const notaStar = linha.slice(95, 103);
+            const situacao = linha.slice(195, 196);
+            const valor = linha.slice(136, 147);
+
+            console.log(`${notaStar} ${nome} ${situacao} ${valor}`);
+
+            const sql =
+              "INSERT INTO validacao (Nota_star, Nome, Mes, Ano, Situacao, Valor) VALUES (?, ?, ?, ?, ?, ?)";
+            const values = [notaStar, nome, mes, ano, situacao, valor];
+
+            connection.query(sql, values, (err) => {
+              if (err) throw err;
+            });
+          }
+        });
+      }
+    );
+
+    connection.end();
+  },
+};

src/functions/FuncoesBanco.js

@@ -0,0 +1,47 @@
+const { knex } = require("../config/db.config");
+
+
+module.exports = {
+    batchUpdate: async ({ table, column }, collection) => {
+        const trx = await knex.transaction();
+        try {
+            await Promise.all(collection.map(async tuple => {
+
+
+                if (tuple[column] == undefined) {
+
+                    //await Condicao_horario.query().insert(tuple)
+                    knex(table)
+                        .insert(tuple)
+                        .transacting(trx)
+                        .then(async (condicao) => {
+                            console.log(condicao)
+                        })
+
+                } else {
+                    knex(table)
+                        .transacting(trx)
+                        .update(tuple)
+                        .where(column, tuple[column])
+                        .then(rows => {
+
+                        })
+                        .catch(e => {
+                            console.log("sim", e)
+                        })
+                    /*
+                      knex(table)
+                          .where(column, tuple[column])
+                          .update(tuple)
+                          .transacting(trx)
+        */
+                }
+            }
+            )
+            );
+            await trx.commit();
+        } catch (error) {
+            await trx.rollback();
+        }
+    }
+}

src/functions/clientes/AjustesCadastrais.js

@@ -0,0 +1,30 @@
+const { cpf } = require("cpf-cnpj-validator");
+
+module.exports = {
+  validacpfcnpf: async (cpfcliente) => {
+    var cpnjajustado = cpf.format(cpfcliente);
+    if (cpf.isValid(cpnjajustado)) {
+      //console.log("CPF VALIDO");
+    } else {
+      cpnjajustado = cnpj.format(cpfcliente);
+      if (cnpj.isValid(cpnjajustado)) {
+        //console.log("CNPJ VALIDO");
+      } else {
+        return { status: false, CpfCnpj: "" };
+      }
+    }
+    return { status: true, CpfCnpj: cpnjajustado };
+  },
+  OrganizaDados: async (dados) => {
+    dados.Id = dados.id;
+    dados.Nome = dados.razao;
+    dados.Telefone = dados.fone;
+    dados.Email = dados.email;
+    dados.Status = dados.ativo == "S" ? 1 : 0;
+
+    delete dados.senha
+    delete dados.hotsite_email
+    delete dados.ie_identidade
+    return dados
+  },
+};

src/middleware/Mailer.js

@@ -0,0 +1,17 @@
+const nodemailer = require("nodemailer");
+
+module.exports = {
+  TransporteMailer: async function () {
+    const transporter = nodemailer.createTransport({
+      host: "star.psi.br",
+      port: 465,
+      secure: true, // true for 465, false for other ports
+      auth: {
+        user: "naoresponda@star.psi.br",
+        pass: "1GW23telecom4",
+      },
+      tls: { rejectUnauthorized: false },
+    });
+    return transporter
+  },
+};

src/middleware/Schedule.js

@@ -0,0 +1,14 @@
+const nodeSchedule = require('node-schedule');
+var moment = require('moment');
+const { NotificaPendentes } = require('../core/Cron/Notificacao');
+
+const dt = new Date(2022, 1, 3, 10, 55);
+
+const job = nodeSchedule.scheduleJob('30 15 * * 0-5', () => {
+    NotificaPendentes()  
+    console.log("ROTINA: ", new Date());
+});
+process.env.TZ = "America/Sao_Paulo"
+var agora = moment().format('H:mm:ss');
+console.log("Hora atual: ", agora);
+//NotificaPendentes()

src/middleware/Validajwt.js

@@ -0,0 +1,24 @@
+const config = require("../config/pass");
+const jwt = require("jsonwebtoken");
+module.exports.verifyJWT = async function (req, res, next) {
+  let token = req.headers.authorization;
+  if (!token)
+    return res
+      .status(401)
+      .send({ erro: "Access Denied / Unauthorized request" });
+
+  try {
+    token = token.split(" ")[1]; // Remove Bearer from string
+
+    if (token === "null" || !token)
+      return res.status(401).send({ erro: "Unauthorized request" });
+
+    let verifiedUser = jwt.verify(token, config.secret); // config.TOKEN_SECRET => 'secretKey'
+    if (!verifiedUser)
+      return res.status(401).send({ erro: "Unauthorized request" });
+    req.user = verifiedUser; // user_id & user_type_id
+    next();
+  } catch (error) {
+    res.status(400).send({ erro: "Invalid Token" });
+  }
+};

src/models/Did.model.js

@@ -0,0 +1,37 @@
+const {knex} = require('../config/db.config');
+
+
+const { Model } = require('objection');
+Model.knex(knex);
+
+
+const unique = require("objection-unique")({
+  fields: ["id"],
+  identifiers: ["id"],
+});
+
+class Did extends unique(Model) {
+  static get tableName() {
+    return "did";
+  }
+
+  static get idColumn() {
+    return "";
+  }
+
+  static get relationMappings() {
+    const { Ramais } = require("./Ramais.model");
+    return {
+      ramal: {
+        relation: Model.HasOneRelation,
+        modelClass: Ramais,
+        join: {
+          from: "did.id_ramal",
+          to: "ramais.id",
+        },
+      },
+    };
+  }
+}
+
+module.exports.Did = Did;

src/models/Franquia.model.js

@@ -0,0 +1,37 @@
+const {knex} = require('../config/db.config');
+
+
+const { Model } = require('objection');
+Model.knex(knex);
+
+
+const unique = require("objection-unique")({
+  fields: ["id"],
+  identifiers: ["id"],
+});
+
+class Franquia extends unique(Model) {
+  static get tableName() {
+    return "franquia";
+  }
+
+  static get idColumn() {
+    return "";
+  }
+
+  static get relationMappings() {
+    const { Ramais } = require("./Ramais.model");
+    return {
+      ramal: {
+        relation: Model.HasOneRelation,
+        modelClass: Ramais,
+        join: {
+          from: "did.id_ramal",
+          to: "ramais.id",
+        },
+      },
+    };
+  }
+}
+
+module.exports.Franquia = Franquia;

src/models/Integracao.model.js

@@ -0,0 +1,19 @@
+const { knex } = require("../config/db.config");
+
+const { Model } = require("objection");
+Model.knex(knex);
+const unique = require("objection-unique")({
+  fields: ["Id"],
+  identifiers: ["id"],
+});
+
+class Integracao extends unique(Model) {
+  static get tableName() {
+    return "integracao";
+  }
+  static get idColumn() {
+    return "Id";
+  }
+}
+
+module.exports.Integracao = Integracao;

src/models/Ramais.model.js

@@ -0,0 +1,62 @@
+const { knex } = require("../config/db.config");
+
+const { Model } = require("objection");
+Model.knex(knex);
+
+const unique = require("objection-unique")({
+  fields: ["id"],
+  identifiers: ["id"],
+});
+
+class Ramais extends unique(Model) {
+  static get tableName() {
+    return "ramais";
+  }
+
+  static get idColumn() {
+    return "id";
+  }
+  static get relationMappings() {
+    const { RamalFranquias } = require("./RamalFranquias.model");
+    const { Did } = require("./Did.model");
+    return {
+      did: {
+        relation: Model.HasManyRelation,
+        modelClass: Did,
+        join: {
+          from: "did.id_ramal",
+          to: "ramais.id",
+        },
+      },
+      ramais_franquias: {
+        relation: Model.HasManyRelation,
+        modelClass: RamalFranquias,
+        join: {
+          from: "ramais.id",
+          to: "ramais_franquias.id_ramais",
+          on: (builder) => {
+            builder.andOn(
+              "ramais.id_planos",
+              "=",
+              "ramais_franquias.id_planos"
+            );
+          },
+          modify: (query) => {
+            query.select(
+              "franquias.nome as nome_franquia",
+              "ramais_franquias.franquia_segundos as segundos_disponiveis",
+              "franquias.franquia_minutos as total_minutos_franquia",
+              Ramal.raw("IF(franquias.LC = 1, 'LC', '') as LC"),
+              Ramal.raw("IF(franquias.LDN = 1, 'LDN', '') as LDN"),
+              Ramal.raw("IF(franquias.VC1 = 1, 'VC1', '') as VC1"),
+              Ramal.raw("IF(franquias.VC2 = 1, 'VC2', '') as VC2"),
+              Ramal.raw("IF(franquias.VC3 = 1, 'VC3', '') as VC3")
+            );
+          },
+        },
+      },
+    };
+  }
+}
+
+module.exports.Ramais = Ramais;

src/models/RamalFranquias.model.js

@@ -0,0 +1,37 @@
+const {knex} = require('../config/db.config');
+
+
+const { Model } = require('objection');
+Model.knex(knex);
+
+
+const unique = require("objection-unique")({
+  fields: ["id"],
+  identifiers: ["id"],
+});
+
+class RamalFranquias extends unique(Model) {
+  static get tableName() {
+    return "ramais_franquias";
+  }
+
+  static get idColumn() {
+    return "";
+  }
+
+  static get relationMappings() {
+    const { Ramais } = require("./Ramais.model");
+    return {
+      ramal: {
+        relation: Model.HasOneRelation,
+        modelClass: Ramais,
+        join: {
+          from: "did.id_ramal",
+          to: "ramais.id",
+        },
+      },
+    };
+  }
+}
+
+module.exports.RamalFranquias = RamalFranquias;

src/models/Usuario.js

@@ -0,0 +1,20 @@
+const { knexlocal } = require('../config/db.config');
+const { Model } = require('objection');
+
+Model.knex(knexlocal);
+const unique = require('objection-unique')({
+    fields: ['Login'],
+    identifiers: ['Id']
+});
+
+class Usuario extends unique(Model) {
+    static get tableName() {
+        return 'usuario';
+    }
+
+    static get idColumn() {
+        return 'Id';
+    }
+}
+
+module.exports.Usuario = Usuario;

src/routes/Login.Rotas.js

@@ -0,0 +1,9 @@
+const express = require("express");
+const router = express.Router();
+const controller = require("../controllers/Login.Controller");
+const { verifyJWT } = require("../middleware/Validajwt");
+
+router.post("/", verifyJWT, controller.ListaLogin);
+router.post("/consumo", verifyJWT, controller.LoginConsumo);
+
+module.exports = router;

src/routes/Telefonia.Rotas.js

@@ -0,0 +1,12 @@
+const express = require('express');
+const router = express.Router();
+const controller = require('../controllers/Telefonia.Controller');
+const { verifyJWT } = require('../middleware/Validajwt')
+
+router.post('/', controller.Circuitos);
+router.post('/circuitos', controller.BuscaCircuitos);
+router.get('/atualiza', controller.Token);
+router.post('/fatura', controller.Fatura);
+
+
+module.exports = router;

src/routes/Usuario.Rotas.js

@@ -0,0 +1,15 @@
+const express = require('express');
+const router = express.Router();
+const controller = require('../controllers/UsuarioController');
+const { verifyJWT } = require('../middleware/Validajwt')
+
+
+router.post('/', verifyJWT, controller.Listar);
+router.post('/cadastrar', verifyJWT, controller.Cadastrar);
+router.post('/editar', verifyJWT, controller.Editar);
+router.post('/login', controller.Login);
+router.post('/loginixc', controller.Ixc);
+router.post('/status', verifyJWT, controller.Status);
+
+
+module.exports = router;

src/routes/index.js

@@ -0,0 +1,14 @@
+
+const Saperx = require("./Telefonia.Rotas");
+const Usuario = require("./Usuario.Rotas");
+const Login = require("./Login.Rotas");
+
+class Roteamento {
+  static IniciarRoteamento(app) {
+    app.use("/telefonia", Saperx);
+    app.use("/usuario", Usuario);
+    app.use("/login", Login);
+  }
+}
+
+module.exports = Roteamento;