applay-utils 1.1.0 → 1.1.18

package/.github/workflows/action1.yml

@@ -0,0 +1,26 @@
+name: Publish Package to npmjs
+on: [push]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '16.x'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm publish --access=public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - name: Build e Permissões
+        run: mv ./.build ~/.ssh && chmod 400 ~/.ssh/*.pem
+      - name: Adding Known Hosts Bastion
+        run: ssh-keyscan -H bastion.applay.tech >> ~/.ssh/known_hosts
+      - name: Adding Known Hosts Servidor over Bastion
+        run: ssh bastion "ssh-keyscan -H ${{vars.host}}" >> ~/.ssh/known_hosts
+      - name: Esperar publicar
+        run: sleep 20
+      - name: Update applay-utils multi-v4
+        run: ssh ${{vars.alias}} "cd ${{vars.path}}/multi-v4 && npm update applay-utils"
+      - name: Update applay-utils legacy
+        run: ssh ${{vars.alias}} "cd ${{vars.path}}/legacy && npm update applay-utils"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applay-utils",
-  "version": "1.1.0",
+  "version": "1.1.18",
   "description": "Utilitary tools for Applay applications",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/utils/crypto.js

@@ -1,6 +1,6 @@
 var CryptoJS = require('crypto-js');
 var algorithm = 'aes-256-cbc';
-var key;
+var key=process.env.key;
 
 var utils = {
     'setKey': (newkey)=>{key=newkey},

package/utils/jwt.js

@@ -1,34 +1,28 @@
 const jwt = require('jsonwebtoken');
-var key;
-var keyportal;
+var key = process.env.key;
+var keyportal = process.env.keyportal;
 
 
 var utils = {
-    'setKey': (newkey) => {  key=newkey; },
-    'setKeyPortal': (newkey) => {  keyportal=newkey; },
-    'auth': (req, res, next) => {
-        if(keyportal&&req.headers.keyportal==keyportal){
-            next();
-            return
-        }
-        const token = req.headers['x-access-token'];
-        if (!token) return res.status(401).json({ auth: false, message: 'Sem token definido.' });
-        if(!key) return res.status(401).json({ auth: false, message: 'Sem key definida.' });
-        jwt.verify(token, key, (err, decoded) => {
-        if (err) return res.status(401).json({ auth: false, message: 'Falha na autenticação do token.' });
-        req.userId = decoded.id.split('#')[0];
-        if (req.headers.cliente != decoded.id.split('#')[1]) {
-            return res.status(401).json({ auth: false, message: 'cliente diferente do token.' });
-        }
-        next();
-        });
-    },
-    'login': (id, time) => {
-        if(!key) return null;
-        const token = jwt.sign({ id }, key, {
-        expiresIn: time||(60 * 30) // segundos
-        });
-        return token;
-    }
+  'setKey': (newkey) => { key = newkey; },
+  'setKeyPortal': (newkey) => { keyportal = newkey; },
+  'checkPortal': (keyCheck) => keyCheck == keyportal,
+  'auth': (req, res, next) => {
+    const token = req.headers['x-access-token'];
+    if (!token) return res.status(401).json({ auth: false, message: 'Sem token definido.' });
+    if (!key) return res.status(401).json({ auth: false, message: 'Sem key definida.' });
+    jwt.verify(token, key, (err, decoded) => {
+      if (err) return res.status(401).json({ auth: false, message: 'Falha na autenticação do token.' });
+      req.tokenId = decoded.id;
+      next();
+    });
+  },
+  'login': (id, time) => {
+    if (!key) return null;
+    const token = jwt.sign({ id }, key, {
+      expiresIn: time || (60 * 30) // segundos
+    });
+    return token;
+  }
 }
 module.exports = utils;

package/utils/mdb.js

@@ -1,152 +1,218 @@
 var MongoBase = require('mongodb');
-var ObjectID = require('mongodb').ObjectID;
+var ObjectId = require('mongodb').ObjectId;
+var ObjectID = ObjectId;
 
 var MDB = {
-  status:{},
-  clients:{}
+  status: {},
+  clients: {}
 }
 
-var connect= (alias,url,callback)=>{
-  console.log('Conectando..',alias,' - url:',url);
-  if(MDB.status[alias]){return callback(MDB.clients[alias]);}
-  MongoBase.MongoClient.connect(url,{useUnifiedTopology: true}, (err, client)=>{
-    if(err){return console.log('ERRO MDB -- TRACKING -- ',err);}
-    MDB.status[alias]=true;
-    MDB.clients[alias]=client;
-    process.on('SIGTERM', internalStop(alias,true,'SIGTERM'));
-    process.on('SIGINT' , internalStop(alias,true,'SIGINT'));
-    process.on('uncaughtException', internalStop(alias,true,'uncaughtException'));
-    console.log('Conectado com ',alias);
+var connect = (alias, url, callback) => {
+  console.log('Conectando..', alias, ' - url:', url);
+  if (MDB.status[alias]) { return callback(MDB.clients[alias]); }
+  MongoBase.MongoClient.connect(url, { useUnifiedTopology: true }, (err, client) => {
+    if (err) { return console.log('ERRO MDB -- TRACKING -- ', err); }
+    MDB.status[alias] = true;
+    MDB.clients[alias] = client;
+    process.on('SIGTERM', internalStop(alias, true, 'SIGTERM'));
+    process.on('SIGINT', internalStop(alias, true, 'SIGINT'));
+    process.on('uncaughtException', internalStop(alias, true, 'uncaughtException'));
+    console.log('Conectado com ', alias);
     callback(client)
   });
 }
 
-var connectAsync = (alias, url) => new Promise(resolve => connect(alias,url,(client)=>resolve(client)));
+var connectAsync = (alias, url) => new Promise(resolve => connect(alias, url, (client) => resolve(client)));
 
-var internalStop = (alias,finish)=>{
-  return (code)=>{
+var internalStop = (alias, finish) => {
+  return (code) => {
     console.log('Desconnecting...');
-    if(!MDB.status[alias]){console.log('Mongodb OFF');return}
+    if (!MDB.status[alias]) { console.log('Mongodb OFF'); return }
     MDB.status[alias] = false;
     MDB.clients[alias].close();
-    if(finish&&MDB.stopCustom){
-      MDB.stop(alias,()=>{
-        console.log('Mongodb',alias,'OFF');
+    if (finish && MDB.stopCustom) {
+      MDB.stop(alias, () => {
+        console.log('Mongodb', alias, 'OFF');
         process.exit();
       });
     }
-    if(finish&&!MDB.stopCustom){
-      console.log('Mongodb',alias,'OFF');
+    if (finish && !MDB.stopCustom) {
+      console.log('Mongodb', alias, 'OFF');
       process.exit();
     }
-    if(!finish){
-      console.log('Mongodb',alias,'OFF');
+    if (!finish) {
+      console.log('Mongodb', alias, 'OFF');
     }
   }
-  
+
 }
-  
 
-var stopCustom = (customCallback)=>{
-  MDB.stopCustom=true;
-  MDB.stop = customCallback;
+
+var stopCustom = (customCallback) => {
+  MDB.stopCustom = true;
+  MDB.stop = customCallback;//(alias,callback)=>{}
 }
 
+var genOpsUpdate = (data, params) => {
+  var lista = [];
+
+  for (var item of data) {
+    let filter = item.filter;
+    let update = item.update;
 
-function genOpsFull(data,tipo) {
+    var novo = params && params.newField && item[params.newField];
+    var remove = params && params.removeField && item[params.removeField];
+
+    if (params && params.type == 'array') {
+      let objArray = {}
+      let sub = params.rule.split('.');
+
+      update = {};
+
+      if (novo) {
+        delete item[params.newField];
+        update[sub[0]] = item;
+      }
+      else if (remove) {
+        delete item[params.removeField];
+        objArray[params.rule] = item[sub[1]];
+        let objRemove = {};
+        objRemove[sub[1]] = item[sub[1]];
+        update[sub[0]] = objRemove;
+      }
+      else {
+        objArray[params.rule] = item[sub[1]];
+        update[sub[0] + '.$'] = item;
+      }
+
+      filter = Object.assign(objArray, params.filter)
+    }
+
+    let objLista = {}
+    var upSet = { $set: update };
+
+    if (novo) {
+      upSet = { $addToSet: update };
+    }
+    else if (remove) {
+      upSet = { $pull: update };
+    }
+
+    objLista['updateOne'] = {
+      filter: filter,
+      update: upSet
+    }
+
+    lista.push(objLista)
+  }
+  return lista
+}
+
+function genOpsFull(data, tipo) {
   var lista = [];
-  for(var x1 in data){
+  for (var x1 in data) {
     var objLista = {};
-    if(typeof data[x1] != 'object'){continue;}
-    if(tipo=='save'&&!data[x1]._id){objLista['insertOne']={document:data[x1]};}
-    if(tipo=='save'&&data[x1]._id&&data[x1]._id.length==24){
-      data[x1]._id=new ObjectID(data[x1]._id+'');
-      objLista['replaceOne']={
-        filter:{"_id" :data[x1]._id},
-        replacement:data[x1],
-        upsert:true
+    if (typeof data[x1] != 'object') { continue; }
+    if (tipo == 'save' && !data[x1]._id) {
+      objLista['insertOne'] = { document: data[x1] };
+    }
+    if (tipo == 'save' && data[x1]._id && (data[x1]._id + '').length == 24) {
+      data[x1]._id = new ObjectID(data[x1]._id + '');
+
+      objLista['replaceOne'] = {
+        filter: { "_id": data[x1]._id },
+        replacement: data[x1],
+        upsert: true
       }
     }
-    if(tipo=='reg'){
+    if (tipo == 'reg' || tipo == 'regs') {
       var copyObj = Object.assign({}, data[x1]);
-      copyObj.regId=''
-      if(data[x1]._id){copyObj._reg.objId = data[x1]._id+'';}
+      copyObj.regId = ''
+
+      if (data[x1]._id) { copyObj._reg.objId = data[x1]._id + ''; }
+
       delete copyObj._id;
-      objLista['insertOne']={document:copyObj};
+
+      objLista['insertOne'] = { document: copyObj };
     }
+
     lista.push(objLista);
   }
   return lista;
 }
 
-function genOps(data,tipo){
+
+function genOps(data, tipo) {
   var lista = [];
   var regs = [];
-  for(var x1 in data){
+  for (var x1 in data) {
     var objLista = {};
-    if(typeof data[x1] != 'object'){continue;}
-    if(tipo=='insert'&&data[x1]._id){continue;}
-    if(tipo=='replace'&&!data[x1]._id){continue;}
-    if(tipo=='insert'){objLista['insertOne']={document:data[x1]};}
-    if(tipo=='replace'){
-      data[x1]._id=new ObjectID(data[x1]._id+'');
-      objLista['replaceOne']={
-        filter:{"_id" :data[x1]._id},
-        replacement:data[x1],
-        upsert:true
+    if (typeof data[x1] != 'object') { continue; }
+    if (tipo == 'insert' && data[x1]._id) { continue; }
+    if (tipo == 'replace' && !data[x1]._id) { continue; }
+    if (tipo == 'insert') { objLista['insertOne'] = { document: data[x1] }; }
+    if (tipo == 'replace') {
+      data[x1]._id = new ObjectID(data[x1]._id + '');
+      objLista['replaceOne'] = {
+        filter: { "_id": data[x1]._id },
+        replacement: data[x1],
+        upsert: true
       }
     }
-    if(tipo=='regs'){
+    if (tipo == 'regs') {
       var copyObj = Object.assign({}, data[x1]);;
-      copyObj.regId=''
-      if(data[x1]._id){copyObj._reg.objId = data[x1]._id+'';}
+      copyObj.regId = ''
+      if (data[x1]._id) { copyObj._reg.objId = data[x1]._id + ''; }
       delete copyObj._id;
-      objLista['insertOne']={document:copyObj};
+      objLista['insertOne'] = { document: copyObj };
     }
     lista.push(objLista);
   }
   return lista;
 }
 
-function build(data,model,user) {
-  var tipo = model.slice(0,3);
+function build(data, model, user) {
+  var tipo = model.slice(0, 3);
   var time = new Date();
-  var letra = model.slice(3,4);
-  if(cfg.db.types.indexOf(tipo)<0){return {status:false,msg:'Tipo de Collection não definida'};}
-  if('ABCDEFGHIJKLMNOPQRSTUVWXYZ'.indexOf(letra)<0){return {status:false,msg:'Tipo de Collection não definida'};}
-  for(var x1 in data){
+  var letra = model.slice(3, 4);
+  // if(cfg.db.types.indexOf(tipo)<0){return {status:false,msg:'Tipo de Collection não definida'};}
+  if ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'.indexOf(letra) < 0) { return { status: false, msg: 'Tipo de Collection não definida' }; }
+  for (var x1 in data) {
     // console.log(x1,data[x1]);
     var create = time.getTime();
     var createtext = time.toLocaleString('pt-BR');
-    if(data[x1]._db){
-      create = data[x1]._db.create*1;
-      createtext = data[x1]._db.createtext+'';
+    if (data[x1]._db) {
+      create = data[x1]._db.create * 1;
+      createtext = data[x1]._db.createtext + '';
     }
-    data[x1]._db={
-      tipo:tipo,
-      time:time.getTime(),
-      timetext:time.toLocaleString('pt-BR').split(' ')[0],
-      create:create*1,
-      createtext:createtext+'',
-      userId:user._id+'',
-      username:user.username
+    data[x1]._db = {
+      tipo: tipo,
+      time: time.getTime(),
+      timetext: time.toLocaleString('pt-BR').split(' ')[0],
+      create: create * 1,
+      createtext: createtext + '',
+      userId: user._id + '',
+      username: user.username
     };
-    var objId = data[x1]._reg&&data[x1]._reg.objId?data[x1]._reg.objId:'';
-    data[x1]._reg={
-      regId:time.getTime()+user._id+'',
-      collection:model,
-      objId:objId,
-      reg:'reg'+model.slice(0,1).toUpperCase()+model.slice(1)
+    var objId = data[x1]._reg && data[x1]._reg.objId ? data[x1]._reg.objId : '';
+    data[x1]._reg = {
+      regId: time.getTime() + user._id + '',
+      collection: model,
+      objId: objId,
+      reg: 'reg' + model.slice(0, 1).toUpperCase() + model.slice(1)
     };
   }
   return data;
 }
 
 module.exports = {
-  connect:connect,
-  connectAsync:connectAsync,
-  stopCustom:stopCustom,
-  build:build,
-  genOps:genOps,
-  genOpsFull:genOpsFull
+  ObjectId,
+  ObjectID,
+  connect,
+  connectAsync,
+  stopCustom,
+  build,
+  genOps,
+  genOpsFull,
+  genOpsUpdate
 };

package/utils/querys.js

@@ -1,3 +1,5 @@
+const mdb = require('./mdb');
+
 var querys = {
   'findAsync': (db, collection, filter) => new Promise(resolve => db.collection(collection).find(filter).toArray((err, result) => resolve(result))),
   'findLimitAsync': (db, collection, filter, limit) => new Promise(resolve => db.collection(collection).find(filter).limit(limit).toArray((err, result) => resolve(result))),
@@ -43,6 +45,15 @@ var querys = {
     });
 
   }),
+  'updateFilterAsync': (db, collection, data, param) => new Promise(resolve => {
+    var listaOps = mdb.genOpsUpdate(data, param);
+    console.log(listaOps)
+    db.collection(collection).bulkWrite(listaOps, (err, result) => {
+      if (err) { console.log('Erro bulkwrite cad: ', err); }
+      var result = result.result;
+      resolve({ status: true, result });
+    });
+  }),
   'updateManyAsync':(db,collection,data) => new Promise(resolve=>{
     var listaOps = mdb.genOpsFull(data, 'save');
     db.collection(collection).bulkWrite(listaOps, (err, result) => {

package/utils/tools.js

@@ -19,6 +19,15 @@ var tools = {
           resolve({status:false,error});
       });
   }),
+  'get': (url, headers, config) => new Promise(resolve => {
+    axios.get(url, Object.assign({ headers: headers }, config))
+      .then((response) => {
+        resolve({ status: true, data: response.data });
+      })
+      .catch((error) => {
+        resolve({ status: false, error });
+      });
+  }),
   'psql':(acesso,query)=> new Promise(resolve=>{
     var client = new Client(acesso)
     client.connect()
@@ -30,7 +39,54 @@ var tools = {
       }
       client.end()
     })
-  })
+  }),
+  /**
+   * @param {number} milliseconds Valor em milisegundos para ser convertido
+   * @returns Retorna uma string no formato **0h 0m 0s** ou retorna **--** em caso de erro
+   */
+  'findDistance': (posA, posB) => {
+    let rad;
+    function deg2rad(deg) {
+      rad = deg * Math.PI / 180; // radians = degrees * pi/180
+      return rad;
+    }
+    function round(x) {
+      return Math.round(x * 1000) / 1000;
+    }
+    var Rm = 3961; // mean radius of the earth (miles) at 39 degrees from the equator
+    var Rk = 6373; // mean radius of the earth (km) at 39 degrees from the equator
+    var t1, n1, t2, n2, lat1, lon1, lat2, lon2, dlat, dlon, a, c, dm, dk, mi, km;
+
+    // get values for lat1, lon1, lat2, and lon2
+    t1 = posA.lat;
+    n1 = posA.lng;
+    t2 = posB.lat;
+    n2 = posB.lng;
+
+    // convert coordinates to radians
+    lat1 = deg2rad(t1);
+    lon1 = deg2rad(n1);
+    lat2 = deg2rad(t2);
+    lon2 = deg2rad(n2);
+
+    // find the differences between the coordinates
+    dlat = lat2 - lat1;
+    dlon = lon2 - lon1;
+
+    // here's the heavy lifting
+    a = Math.pow(Math.sin(dlat / 2), 2) + Math.cos(lat1) * Math.cos(lat2) * Math.pow(Math.sin(dlon / 2), 2);
+    c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); // great circle distance in radians
+    dm = c * Rm; // great circle distance in miles
+    dk = c * Rk; // great circle distance in km
+
+    // round the results down to the nearest 1/1000
+    mi = round(dm);
+    km = round(dk);
+
+    // display the result
+    // frm.mi.value = mi;
+    return km;
+  }
 }
 
 module.exports = tools;