applay-utils 0.0.1

package/index.js

@@ -0,0 +1,11 @@
+var query = require('./utils/query');
+
+var utils = Object.assign({
+    mdb:require('./utils/mdb'),
+    crypto:require('./utils/crypto'),
+    jwt:require('./utils/jwt')
+},query);
+
+module.exports = utils;
+
+

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "applay-utils",
+  "version": "0.0.1",
+  "description": "Utilitary tools for Applay applications",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "main": "index.js",
+  "keywords": [
+    "v5",
+    "applay"
+  ],
+  "author": "William Stuani",
+  "license": "ISC",
+  "dependencies": {
+    "crypto-js": "^4.1.1",
+    "jsonwebtoken": "^8.5.1",
+    "mongodb": "^4.12.1"
+  }
+}

package/utils/crypto.js

@@ -0,0 +1,34 @@
+var CryptoJS = require('crypto-js');
+var algorithm = 'aes-256-cbc';
+var key;
+
+var utils = {
+    'setKey': (newkey)=>{key=newkey},
+    'genIV': () => {
+        return Math.random().toString(36).substr(2, 30);
+    },
+    'encrypt': (text, iv) => {
+        if(!key) return null;
+        let base = CryptoJS.AES.encrypt(text, key, { iv: iv });
+        return base.toString();
+    },
+    'decrypt': (text, iv) => {
+        if(!key) return null;
+        let data = CryptoJS.AES.decrypt(text, key, { iv: iv }).toString(CryptoJS.enc.Utf8);
+        return data;
+    },
+    'protect': (data) => {
+        var iv = utils.genIV();
+        return { cipher: utils.encrypt(JSON.stringify(data), iv), iv: iv, protect: true, app_key: '', app_secret: '' }
+    },
+    'extract': (data) => {
+        if(!key) return null;
+        return JSON.parse(utils.decrypt(data.cipher, data.iv));
+    },
+    'envelope': (dataFull) => {
+        dataFull.data = utils.protect(dataFull.data);
+        return dataFull;
+    }
+}
+
+module.exports=utils;

package/utils/jwt.js

@@ -0,0 +1,34 @@
+const jwt = require('jsonwebtoken');
+var key;
+var 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;
+    }
+}
+module.exports = utils;

package/utils/mdb.js

@@ -0,0 +1,144 @@
+var MongoBase = require('mongodb');
+var ObjectID = require('mongodb').ObjectID;
+
+var MDB = {
+  status:{},
+  clients:{}
+}
+
+var connect= (alias,url,callback)=>{
+  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());
+    process.on('SIGINT' , internalStop());
+    process.on('uncaughtException', internalStop());
+    callback(client)
+  });
+}
+
+var connectAsync = (alias, url) => new Promise(resolve => connect(alias,url,(client)=>resolve(client)));
+
+var internalStop = (alias,finish)=>{
+  MDB.status[alias] = false;
+  MDB.clients[alias].close();
+  if(finish&&MDB.stopCustom){
+    MDB.stop(alias,()=>{
+      process.exit();
+    });
+  }
+  if(finish&&!MDB.stopCustom){
+    process.exit();
+  }
+}
+
+var stopCustom = (customCallback)=>{
+  MDB.stopCustom=true;
+  MDB.stop = customCallback;
+}
+
+var stop = (alias)=>{
+  internalStop(alias,false);
+}
+
+
+function genOpsFull(data,tipo) {
+  var lista = [];
+  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(tipo=='reg'){
+      var copyObj = Object.assign({}, data[x1]);
+      copyObj.regId=''
+      if(data[x1]._id){copyObj._reg.objId = data[x1]._id+'';}
+      delete copyObj._id;
+      objLista['insertOne']={document:copyObj};
+    }
+    lista.push(objLista);
+  }
+  return lista;
+}
+
+function genOps(data,tipo){
+  var lista = [];
+  var regs = [];
+  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(tipo=='regs'){
+      var copyObj = Object.assign({}, data[x1]);;
+      copyObj.regId=''
+      if(data[x1]._id){copyObj._reg.objId = data[x1]._id+'';}
+      delete copyObj._id;
+      objLista['insertOne']={document:copyObj};
+    }
+    lista.push(objLista);
+  }
+  return lista;
+}
+
+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){
+    // 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+'';
+    }
+    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)
+    };
+  }
+  return data;
+}
+
+module.exports = {
+  connect:connect,
+  connectAsync:connectAsync,
+  stop:stop,
+  stopCustom:stopCustom,
+  build:build,
+  genOps:genOps,
+  genOpsFull:genOpsFull
+};

package/utils/query.js

@@ -0,0 +1,48 @@
+var utils = {
+  '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))),
+  'distinctAsync': (db, collection, filter, campo) => new Promise(resolve => db.collection(collection).distinct(campo, filter, (err, result) => resolve(result))),
+  'findLimitSortAsync': (db, collection, filter, sort, limit) => new Promise(resolve => db.collection(collection).find(filter).sort(sort).limit(limit).toArray((err, result) => resolve(result))),
+  'findSortAsync': (db, collection, filter, sort) => new Promise(resolve => db.collection(collection).find(filter).sort(sort).toArray((err, result) => resolve(result))),
+  'findTextAsync': (db, collection, filter) => new Promise(resolve => db.collection(collection).find(filter.query).project(filter.score).sort(filter.score).limit(20).toArray((err, result) => resolve(result))),
+  'findOneAsync': (db, collection, filter) => new Promise(resolve => db.collection(collection).findOne(filter, (err, result) => resolve(result))),
+  'countAsync': (db, collection, filter) => new Promise(resolve => db.collection(collection).countDocuments(filter, (err, result) => resolve(result))),
+  'updateAsync': (db, collection, item) => new Promise(resolve => db.collection(collection).replaceOne({ _id: new mdb.ObjectID(item._id) }, item, (err, result) => { if (err) { console.log('erro', err); } return resolve(result); })),
+  'insertOne': (db, collection, item) => new Promise(resolve => db.collection(collection).insertOne(item, (err, result) => resolve(result))),
+  'insertMany': (db, collection, item) => new Promise(resolve => db.collection(collection).insertMany(item, (err, result) => resolve(result))),
+  'findLastAsync': (db, collection, filter) => new Promise(resolve => db.collection(collection).find(filter).sort({ _id: -1 }).limit(1).toArray((err, result) => resolve(result[0]))),
+  'updateSetAsync': (db, collection, itemId, itemSet) => new Promise(resolve => db.collection(collection).findOneAndUpdate(itemId, { $set: itemSet }, (err, result) => resolve(result))),
+  'updateAllAsync': (db, collection, filter, itemSet) => new Promise(resolve => db.collection(collection).updateMany(filter, itemSet, (err, result) => resolve(err || result))),
+  'saveAsync': (db, collection, dataOrItem, user) => new Promise(resolve => {
+    console.log("🚀 ~ db", db)
+    console.log("🚀 ~ collection", collection)
+    
+    var data = Array.isArray(dataOrItem) ? dataOrItem : [dataOrItem];
+    console.log("🚀 ~ data", data)
+    var dataBuild = mdb.build(data, collection, user);
+    console.log("🚀 ~ dataBuild", dataBuild)
+    var listaOps = mdb.genOpsFull(dataBuild, 'save');
+    console.log("🚀 ~ listaOps", listaOps)
+
+    db.collection(collection).bulkWrite(listaOps, (err, result) => {
+      if (err) { console.log('Erro bulkwrite cad: ', err); }
+
+      var ids = result.getInsertedIds();
+      ids.forEach(e => dataBuild[e.index]._reg.objId = e._id + '');
+
+      var regsOps = mdb.genOpsFull(dataBuild, 'reg');
+      var regCollection = 'reg' + collection.slice(0, 1).toUpperCase() + collection.slice(1);
+
+      db.collection(regCollection).bulkWrite(regsOps, (err2, result2) => {
+        if (err2) { console.log('Erro bulkwrite reg: ', err2); }
+
+        var resObj = { ids: ids, regs: result2 }
+
+        resolve(resObj);
+      });
+    });
+
+  })
+}
+
+module.exports = utils;