bonsaif 1.10.3

package/lib/hookup/mongodb.js

@@ -0,0 +1,681 @@
+/**
+ * ::: B[]NSAIF() ::: => 2022
+ */
+
+ 'use strict';
+
+ const utl          = require('../utl');
+ let debug = false;
+ let tag = ` ::: B[]NSAIF() ::: => mongodb.js `;
+ const ObjectId = require('mongodb').ObjectId;
+
+const find=async(options,dbm, col, query, orderby, limit)=>{
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  limit = limit!=null?limit*1:0;
+  if (limit=-1){
+    limit = 0;
+  }
+  orderby = orderby!=null?orderby:'';
+  const start = Date.now();
+  //console.log(' ****find ['+JSON.stringify(query)+'] limit ['+limit+']');
+  
+  let results = new Array();
+  //let obj_result = {"alias":alias,"dml":dml,"headers":"","columns":0,"error":0,"msg":"","ip":ip, "time":0}
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).find(query).sort(orderby).limit(limit).toArray(function(err, result) {
+            const end = Date.now();
+            const time = end - start;
+
+            if (err) {
+              resolve({"result":{"dml":"find", "headers":"", "time":utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              resolve({"result":{"dml":"find", "headers":getFields(result[0]), "time":utl.milisegundosASegundos(time), code:200, error:0}, data:result});
+            }
+
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.find '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({"result":{"dml":"find", "headers":"", time:0, code:404, error:1}, "results":err});
+    });
+  })
+}
+
+
+const count=async(options,dbm, col, json)=>{
+  let {filter:query={}}=json;  
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).find(query).count(function(err, res) {
+
+           const end = Date.now();
+           const time = end - start;
+
+            if (err) {
+              resolve({result:{dml:"count", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              let data = {"count":res};
+              resolve({"result":{dml:"count", headers:"count", "time":utl.milisegundosASegundos(time), code:200, error:0}, results:res, data});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.count '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({result:{dml:"insert", headers:"", time:0, code:404, error:1}, results:err});
+    });
+  })
+}
+
+const insert= async(options,dbm, col, json_obj)=>{
+  const exec        = require("./exec");
+
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+
+  //json_obj = formatAttributes(json_obj);
+  
+  let _id = ObjectId();
+  let json_insert ={};
+  try{
+    // 2022/12/08 VRSZ Se soluciona error en numeros enteros ya que los cambiaba a string
+    json_insert = { _id , ...json_obj };
+  }catch(e){
+    utl.log(e);
+  }
+
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).insertOne(json_insert, function(err, res) {
+          const end = Date.now();
+          const time = end - start;
+            if (err) {
+              resolve({result:{dml:"insert", headers:"insertId", insertId:_id, time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              let data = {"insertId":_id};
+              let ops=res.ops!=null?res.ops:{};
+              resolve({result:{dml:"insert", headers:"insertId", insertId:_id, time:utl.milisegundosASegundos(time), code:200, error:0}, results:{WriteResult:'1 document inserted', ops}, data:[data]});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.insert '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({"result":{"dml":"insert", "headers":"", time:0, code:404, error:1}, results:err});
+    });
+  })
+}
+
+const update=async(options,dbm, col, json_obj, query)=>{
+  const exec        = require("./exec");
+
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  
+  //json_obj = formatAttributes(json_obj);
+
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).updateOne(query, { $set: json_obj }, function(err, res) {
+           const end = Date.now();
+           const time = end - start;
+           let result, nModified=0;
+           try{ result = res.result; nModified = res.result.nModified; } catch(e){ }           
+            if (err) { 
+              resolve({result:{dml:"update", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              resolve({result:{dml:"update", headers:"update", time:utl.milisegundosASegundos(time), code:200, error:0}, results:{WriteResult:`${nModified} document Updated`, result }});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.update '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({result:{dml:"update", headers:"", time:0, code:404, error:1}, results:err});
+    });
+  })
+}
+
+const upsert=async(options,dbm, col, json_obj, query)=>{
+  return new Promise((resolve, reject)=>{
+  find(options, dbm,col, query)
+  .then(result=>{
+    if (result.error==1){
+      resolve(result);
+    }
+
+    if (result.data[0]){ //update
+      update(options,dbm,col, json_obj, query)
+      .then(result_update=>{
+        resolve(result_update);
+      })
+      .catch(err=>{
+        reject(err);
+      });
+    }else{  // Insert
+      insert(options,dbm,col, json_obj)
+      .then(result_insert=>{
+        resolve(result_insert);
+      })
+      .catch(err=>{
+        reject(err);
+      });
+    }
+  })
+  .catch(err=>{
+    reject(err);
+  });
+  })
+}
+
+
+const dbs=async(options)=>{
+  const exec        = require("./exec");
+
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db().admin();
+         db.listDatabases(function(err, res) {
+            const end = Date.now();
+            const time = end - start;
+            if (err) {
+              resolve({result:{dml:"dbs", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              res.time=utl.milisegundosASegundos(time);
+              let databases=res.databases!=null?res.databases:{};
+              let totalSize=res.totalSize!=null?res.totalSize:0;
+              resolve({result:{dml:"dbs", headers:getFields(databases[0]), time:utl.milisegundosASegundos(time), code:200, error:0}, results:{totalSize}, data:databases});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.dbs '+e);
+            }
+         });
+      }
+      ).catch(err=>{
+        resolve({result:{dml:"dbs", headers:"", time:0, code:404, error:1}, results:err});
+      });
+  })
+}
+
+const collections=async(options,dbm)=>{
+  const exec        = require("./exec");
+
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.listCollections().toArray(function(err, res) {
+
+           const end = Date.now();
+           const time = end - start;
+
+            if (err) {
+              resolve({result:{dml:"collections", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              resolve({result:{dml:"collections", headers:"name", time:utl.milisegundosASegundos(time), code:200, error:0}, results:res, data:res});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.collections '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({result:{dml:"collections", headers:"", time:0, code:404, error:1}, results:err});
+    });
+  })
+}
+
+const formatAttributes=(json_obj)=>{
+  for(let attributename in json_obj){
+    let vl = json_obj[attributename];
+    //2022/04/21 VRSZ Se realiza ajuste  de lo contrario los vacios los toma como un numero
+    if (!isNaN(vl*1)){
+      eval(" json_obj."+attributename+"="+vl*1+";");
+    }
+  }
+  return json_obj;
+}
+
+const getFields=(json)=>{
+  let fields = '';
+  try{
+    for(let field in json){
+      if (fields.length>0){
+        fields = fields + "|";
+      }
+      fields = fields +  field;
+    }
+  }
+  catch(e){
+    utl.log('err.getFields ['+e+']');
+  }
+  return fields;
+}
+
+//2022/04/28 VRSZ Construye el query para utilizarlo en mongo
+const buildQuery=(field,value)=>{
+  let where = {}, query = {};
+  let ltField, ltValue;
+  try{
+    ltField = field.split("|");
+    ltValue = value.split("|");
+  }catch(e){
+    //utl.log('err.1 buildQuery'+e);
+  }
+
+  try{
+    for (let i in ltField){
+      let query_in ={};
+      let val = ltValue[i];
+      let number = false;
+      let tipo = "";
+      try{
+        let valN = val *1;
+        if(!isNaN(valN)){
+            number = true;
+            tipo = "int";
+        }
+      }catch(e){
+
+      }
+
+      if (ltField[i]=='_id'){
+        tipo= "id";
+      }
+      //console.log('tipo:'+tipo);
+      switch (tipo){
+        case 'id':
+          eval('where.'+ltField[i]+' = new ObjectId('+val+'); '); 
+        break;
+
+        case 'int':
+          eval('where.'+ltField[i]+' = { $in:['+val+',"'+val+'"] };'); 
+        break;
+
+        default: 
+         //eval(' query_in.$regex = /^'+val+'$/i;');  //equals ignore case
+         //eval('where.'+ltField[i]+' = query_in;'); 
+         eval(`where.${ltField[i]} = ${val};`); 
+
+      }
+    }
+    if (field!=''){
+      eval('query.$and = [ where ];'); 
+    }
+  }catch(e){
+    //utl.log('err.2 buildQuery'+e);
+  }
+
+  return query;
+}
+
+const buildOrderBy=(fieldOrder, valueOrder)=>{
+  let orderby ={};
+  let  ltFieldOrder, ltValueOrder;
+  try{
+    ltFieldOrder = fieldOrder.split("|");
+    ltValueOrder = valueOrder.split("|");
+  }catch(e){
+    
+  }
+  try{
+    for (let i in ltFieldOrder){
+      let val = '1'; //order asc
+      try{
+        val = ltValueOrder[i];
+      }catch(e){
+
+      }
+      eval('orderby.'+ltFieldOrder[i]+' = '+val); 
+    }
+  }catch(e){
+
+  }
+  return orderby;
+}
+
+
+const command=async(options,dbm, json)=>{
+  
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+
+  let find = utl.ObjectEmpty(json, 'find') ? true: false;
+  //2022/09/15 VRSZ Se realiza validacion para poder buscar el _id en mongo
+
+  let _id=false;
+  try{if(json.filter._id){_id=json.filter._id}}catch(e){}
+
+  if (_id){
+    try{
+      if (typeof _id == "string") {
+          json.filter._id = new ObjectId(_id);
+      }else{  // fix filters in _id
+          for (let field in json.filter._id){
+            let value = json.filter._id[field];
+            json.filter._id[field] = new ObjectId(value);
+          }
+      }
+    }catch(e){
+      console.log('json.filter.err',e)
+    }
+  }
+
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.command(json,function(err, res) {
+            const end = Date.now();
+            const time = end - start;
+          
+            if (err) {
+              resolve({result:{dml:"command", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              if (find){
+                let rFind = res.cursor.firstBatch;
+                resolve({result:{dml:"find", headers:getFields(rFind[0]), time:utl.milisegundosASegundos(time), code:200, error:0}, data:rFind});
+              }else{
+                resolve({result:{dml:"command", headers:"", time:utl.milisegundosASegundos(time), code:200, error:0}, results:res});
+              }
+            }
+
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.find '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({result:{dml:"insert", headers:"", time:0, code:404, error:1}, results:err});
+    });
+  })
+}
+
+const deleteMany=async(options,dbm, col, json)=>{
+  let {filter:query={}}=json;  
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).deleteMany(query,function(err, res) {
+
+           const end = Date.now();
+           const time = end - start;
+
+            if (err) {
+              resolve({result:{dml:"deleteMany", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              resolve({"result":{dml:"deleteMany", headers:"", "time":utl.milisegundosASegundos(time), code:200, error:0}, results:res});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.deleteMany '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({result:{dml:"deleteMany", headers:"", time:0, code:404, error:1}, results:err});
+    });
+  })
+}
+
+const updateMany=async(options,dbm, col, json_obj, query)=>{
+  const exec        = require("./exec");
+
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  
+  //json_obj = formatAttributes(json_obj);
+
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).updateMany(query, { $set: json_obj }, function(err, res) {
+           const end = Date.now();
+           const time = end - start;
+           let result, nModified=0;
+           try{ result = res.result; nModified = res.result.nModified; } catch(e){ }           
+            if (err) { 
+              resolve({result:{dml:"updateMany", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              resolve({result:{dml:"updateMany", headers:"updateMany", time:utl.milisegundosASegundos(time), code:200, error:0}, results:{WriteResult:`${nModified} document Updated`, result }});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.updateMany '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({result:{dml:"update", headers:"", time:0, code:404, error:1}, results:err});
+    });
+  })
+}
+
+const drop=async(options,dbm, col)=>{ 
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).drop(function(err, res) {
+
+           const end = Date.now();
+           const time = end - start;
+
+            if (err) {
+              resolve({result:{dml:"drop", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              let data = {"drop":res};
+              resolve({"result":{dml:"drop", headers:"drop", "time":utl.milisegundosASegundos(time), code:200, error:0}, results:res, data});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.drop '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({result:{dml:"insert", headers:"", time:0, code:404, error:1}, results:err});
+    });
+  })
+}
+
+//fix: solves the problem of queries that have more than 23K records
+const findMany=async(options,dbm, col, json)=>{
+  const start = Date.now();
+  let {limit=0, sort={}} = json ? json : {};
+  let result=[];
+  if (limit>0){
+    let result = await command(options,dbm,json);
+    return {...result};
+  }else{
+    let {_id:_id_sort=''}=sort?sort:{};
+    if (_id_sort=='-1'){
+      json.sort._id = 1;
+    }
+    let count_rows = await count(options,dbm,col, json);
+    //utl.log('count_rows',count_rows);
+    let {count:total=0} = count_rows.data ? count_rows.data :0;
+    let limit_part = 3000;  // fix:15000 version: 3.2.11
+    let parts = Math.ceil(total / limit_part);
+    json.limit= limit_part;
+    json.batchSize= limit_part;
+
+    let batch_rows = [], last_row={}, _id ='';
+    let dataset = [];
+    if (total==0){
+      result= await command(options,dbm,json);
+    }
+
+    while (parts>0){
+      if (_id!=''){
+        eval(`json.filter._id = { '$gt': _id } `);
+      }
+
+      result= await command(options,dbm,json);
+      batch_rows = result.data;
+
+      for (let rows of batch_rows){
+        dataset.push(rows);
+      }
+
+      last_row = batch_rows.pop();
+      _id = last_row._id;
+      parts--;
+    }
+    const end = Date.now();
+    const time = end - start;
+    try{
+      result.result.time=time;
+      result.data = dataset;
+    }catch(e){
+    }
+    return {...result};
+  }
+}
+
+const api=async(options,dbm, json)=>{
+  let dml = '';  let json_api, query, col;
+  let {filter=''} = json;
+  try{
+    /* 2022/12/08 Se quita esta regla para evitar problemas en los filtros en el update 
+    let field='', value='';
+    for (let x in filter){
+      if (field.length>0){ field = field +"|"; value = value +"|"; }
+      field = field +x; value = value+ JSON.stringify(filter[x]); //value = value+ filter[x];
+    } query  = buildQuery(field,value); 
+    */
+    let {_id=false} = filter ? filter : {};
+    if (_id){
+      filter._id = new ObjectId(_id);
+    }
+    query = filter;
+  }catch(e){
+  }
+
+  if (utl.ObjectEmpty(json, 'upsert')){
+    dml = 'upsert'; 
+    json_api = json.document; 
+  }
+
+  if (utl.ObjectEmpty(json, 'insert')){
+    dml = 'insert'; 
+    json_api = json.documents?json.documents:[];
+    if (json_api.length==1){
+        json_api = json.documents[0];
+    }else{
+      dml = 'insertMany'; 
+    }
+  }
+
+  if (utl.ObjectEmpty(json, 'update')){
+    dml = 'update'; 
+    json_api = json.documents?json.documents:[];
+    if (json_api.length==1){
+        json_api = json.documents[0];
+    }else{
+      dml = 'updateMany'; 
+    }
+  }
+
+  if (utl.ObjectEmpty(json, 'updateMany')){
+    dml = 'updateMany'; 
+    json_api = json.documents?json.documents:[];
+    if (json_api.length==1){
+        json_api = json.documents[0];
+    }else{
+      dml = 'updateMany'; 
+    }
+  }
+
+  let ltdml = ['find','delete','count','dbs','collections','deleteMany','drop'];
+  for (let x of ltdml){
+    if (utl.ObjectEmpty(json,x)){
+      dml = x; break;
+    }   
+  }
+
+  eval(` try{ col = json.${dml}; } catch(e){ } `);
+  let r;
+  switch (dml){
+    case 'insert':      r = await insert(options,dbm,col, json_api); break;
+    case 'upsert':      r = await upsert(options,dbm,col, json_api, query); break;
+    case 'update':      r = await update(options,dbm,col, json_api, query); break;
+    case 'count':       r = await count(options,dbm,col, json); break;
+    case 'dbs':         r = await dbs(options); break;
+    case 'collections': r = await collections(options,dbm); break;
+    case 'deleteMany':  r = await deleteMany(options,dbm,col, json); break;
+    case 'updateMany':  r = await updateMany(options,dbm,col, json_api, query); break;
+    case 'drop':        r = await drop(options,dbm,col); break;
+    case 'find':        r = await findMany(options,dbm,col,json); break;
+    default:            r = await command(options,dbm,json); 
+    }
+
+  return new Promise((resolve, reject)=>{ 
+    resolve(r);
+  })
+}
+
+module.exports ={
+    find,
+    insert,
+    update,
+    count,
+    dbs,
+    collections,
+    upsert,
+    buildQuery,
+    buildOrderBy,
+    command,
+    api,
+    drop,
+    findMany
+}