bonsaif 1.10.3

package/lib/utl.js

@@ -0,0 +1,1422 @@
+/**
+ * ::: B[]NSAIF() ::: => 2022
+ */
+
+'use strict';
+/**
+ * console.log con estilo de color
+ * @param {string} msg mensaje de log
+ * @param {<obj>} obj  Objeto o string
+ */
+
+const log=(msg, c, o)=>{ 
+  let color ='';
+  const color_white = "\x1b[37m", color_yellow = "\x1b[33m";
+  switch  (c){
+      case 'black':    color = "\x1b[30m"; break;
+      case 'green':    color = "\x1b[32m"; break;
+      case 'red':      color = "\x1b[31m"; break;
+      case 'green':    color = "\x1b[32m"; break;
+      case 'yellow':   color = "\x1b[33m"; break;
+      case 'blue':     color = "\x1b[34m"; break;
+      case 'purple':
+      case 'magenta':  color = "\x1b[35m"; break;
+      case 'cyan':     color = "\x1b[36m"; break;
+      case 'white':    color = "\x1b[37m"; break;
+      case 'gray':     color = "\x1b[38m"; break;
+
+      default:
+          if (c){
+              o = c;
+          }
+       color = "\x1b[32m"; 
+  }  
+  if (!o){
+      console.log(color,'['+dateHour()+']',color_white , msg);
+  }else{
+      console.log(color,'['+dateHour()+']',color_yellow, msg, color_white, o);
+  }
+}
+
+const addZero=(i)=> {
+    if (i < 10) { i = "0" + i; }
+    return i;
+}
+
+const getIp=(req)=>{
+    let ip ='';
+    try{
+        ip = 
+            (req.headers['x-forwarded-for'] || '').split(',').pop() ||   
+            req.socket.remoteAddress || 
+            req.connection.socket.remoteAddress ||
+            req.connection.remoteAddress ;
+        //2019/07/04 VRSZ Validacion de IPV6
+        ip = ip.replace('::ffff:', '');
+        
+    }catch(e){
+    }
+    if (!ip){
+      ip = '127.0.0.1'
+    }
+    return ip;
+} 
+
+const milisegundosASegundos=(milisegundos)=>(milisegundos / 1000);
+
+const miliseconds_to_seconds=(milisegundos)=>(milisegundos / 1000);
+
+const dateFormat=(format, date)=>{
+  const dayjs = require('dayjs');
+  let today = date ? dayjs(date) : dayjs();
+  return today.format(format);
+}
+
+const date_format=(format, date)=>{
+  const dayjs = require('dayjs');
+  let today = date ? dayjs(date) : dayjs();
+  return today.format(format);
+}
+
+const dateHour=()=>date()+' '+hour();
+
+const date_hour=()=>date()+' '+hour();
+
+const date=(format)=>{
+  let date='';
+  try{
+      let d = new Date();
+      if (format==null){
+        date = d.getFullYear()+'-'+addZero(d.getMonth()+1)+'-'+addZero(d.getDate());
+      }else{
+        const dayjs = require('dayjs');
+        let today = dayjs();
+        date = today.format(format);
+      }
+  }catch(e){
+      log('err.date:'+e);
+  }
+  return date;
+}
+
+const hour=()=>{
+  let hour='';
+  try{
+      let d = new Date();
+      hour = addZero(d.getHours())+':'+addZero(d.getMinutes())+":"+addZero(d.getSeconds());
+  }catch(e){
+      log('err.hour:'+e);
+  }
+  return hour;
+}
+
+const dateHourFull=()=>date()+' '+hourFull();
+
+const date_hour_full=()=>date()+' '+hourFull();
+
+const hourFull=()=>{
+  let hour='';
+  try{
+      let d = new Date();
+      hour = addZero(d.getHours())+':'+addZero(d.getMinutes())+":"+addZero(d.getSeconds())+":"+d.getMilliseconds();
+  }catch(e){
+      log('err.hour:'+e);
+  }
+  return hour;
+}
+
+//2019/08/25 VRSZ Ordenar json
+const sort=(data, key, orden)=> {
+  orden = orden==null?'asc':orden!=''?orden:'asc';
+  if (orden!=''){
+    orden = orden.toLowerCase() ;
+  }
+  
+  try{
+    return data.sort(function (a, b) {
+        let x = a[key], y = b[key];
+        x = Number.isInteger(x*1) ? x*1: x;
+        y = Number.isInteger(y*1) ? y*1: y;        
+
+        if (orden === 'asc') {
+            return ((x < y) ? -1 : ((x > y) ? 1 : 0));
+        }
+
+        if (orden === 'desc') {
+            return ((x > y) ? -1 : ((x < y) ? 1 : 0));
+        }
+    });
+  }catch(e){
+    log('e.sort:'+e);
+    return data;
+  }
+}
+
+//2022/04/27 VRSZ Convertir ArrayString a ArrayJson
+const ArraytoJson=(ArrayString)=>{
+  let ArrayJson = new Array();
+  try{
+    for (let x of ArrayString){
+      const xjson = JSON.parse(x);
+      ArrayJson.push(xjson);
+    }
+    return ArrayJson;
+  }catch(e){
+    log('err.ArraytoJson '+e);
+    return ArrayString;
+  }
+}
+
+const array_to_json=(ArrayString)=>{
+  let ArrayJson = new Array();
+  try{
+    for (let x of ArrayString){
+      const xjson = JSON.parse(x);
+      ArrayJson.push(xjson);
+    }
+    return ArrayJson;
+  }catch(e){
+    log('err.ArraytoJson '+e);
+    return ArrayString;
+  }
+}
+
+const isObjectEmpty=(obj)=> Object.keys(obj).length === 0;
+
+const is_object_empty=(obj)=> Object.keys(obj).length === 0;
+
+//2022/04/28 Ejecuta multiples funciones de abajo hacia arriba
+const compose = (...fns) => x=> fns.reduceRight((x, f) => f(y), x);
+
+//2022/04/28 Ejecuta multiples funciones de arriba hacia abajo
+const pipe = (...fns) => x=> fns.reduce((x, f) => f(y), x);
+
+//2022/04/28 realizar traza con la funcion de compose y pipe
+const trace = x => y => console.log(x,y);
+
+const find = f => xs => xs.find(f);
+
+const filter = f => xs => xs.filter(f);
+
+const hex_to_ascii=(str1)=>{
+	let hex  = str1.toString();
+	let str = '';
+	for (let n = 0; n < hex.length; n += 2) {
+		str += String.fromCharCode(parseInt(hex.substr(n, 2), 16));
+	}
+	return str;
+ }
+
+const traceId=(tag)=>{
+    tag = tag!=null?tag+':':'';
+    return tag +dateHour()+':'+random({length:4});
+}
+
+const trace_id=(tag)=>{
+  tag = tag!=null?tag+':':'';
+  return tag +dateHour()+':'+random({length:4});
+}
+
+const random=(o)=>{
+  o = o ? o : {};
+  const {min=0, max=0, length =0, string=false, special_characters=''}=o;
+  let opt = 0;
+  let hexDigits  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let numero = "0123456789";
+  let especial = special_characters ? special_characters : hexDigits;
+  let randString = "";
+
+  if (min>0 && max >0){
+      opt = 1;
+  }
+  if (length>0){
+      opt = 2;
+  }
+  if (string){
+      opt = 3;
+      for (let i = 0; i < length-2; i++){
+        randString += hexDigits.charAt(Math.floor(Math.random() * hexDigits.length));
+      }
+      randString += numero.charAt(Math.floor(Math.random() * numero.length));
+      randString += especial.charAt(Math.floor(Math.random() * especial.length));
+  }
+  switch (opt){
+      case 1:  return Math.floor(Math.random() * (max - min)) + min;
+      case 2:  return (Math.pow(10,length).toString().slice(length-1) + Math.floor((Math.random()*Math.pow(10,length))+1).toString()).slice(-length);
+      case 3:  return randString;
+      default: return Math.random();
+  }
+};
+
+const valueIn=(o)=>{
+  let vin = o.in != null ? o.in.split(',') : '';
+  let v = o.value != null ? o.value.split(',') : ''; 
+
+  for (let xv of v){
+      for (let xvin of vin ){
+          if (xv == xvin){
+              return true; break;
+          }
+      }
+  }
+
+  return false;
+}
+
+const value_in=(o)=>{
+  let vin = o.in != null ? o.in.split(',') : '';
+  let v = o.value != null ? o.value.split(',') : ''; 
+
+  for (let xv of v){
+      for (let xvin of vin ){
+          if (xv == xvin){
+              return true; break;
+          }
+      }
+  }
+
+  return false;
+}
+
+//2022/04/08 VRSZ Ajuste para obtener solo los campos principales
+const ObjectEmpty = (obj, target) =>{
+  try{
+    for (let  key in obj){
+      if (obj.hasOwnProperty(key)) {
+        if (key.toLowerCase()==target.toLowerCase()){
+          return true;
+        }
+      }
+    }
+  }catch(e){
+    log('err.ObjectEmpty:'+e);
+  }
+  return false;
+}
+
+const object_empty = (obj, target) =>{
+  try{
+    for (let  key in obj){
+      if (obj.hasOwnProperty(key)) {
+        if (key.toLowerCase()==target.toLowerCase()){
+          return true;
+        }
+      }
+    }
+  }catch(e){
+    log('err.ObjectEmpty:'+e);
+  }
+  return false;
+}
+
+  const ObjectId = (m = Math, d = Date, h = 16, s = s => m.floor(s).toString(h)) =>
+      s(d.now() / 1000) + ' '.repeat(h).replace(/./g, () => s(m.random() * h))
+
+  const object_id = (m = Math, d = Date, h = 16, s = s => m.floor(s).toString(h)) =>
+    s(d.now() / 1000) + ' '.repeat(h).replace(/./g, () => s(m.random() * h))
+
+    /* uuid({mask:'xxxx_xxxx'})*/
+  const uuid=(o)=>{
+      o = o !=null ? o : {};
+      let {mask='xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx'} = o;
+      let dt = new Date().getTime();
+      let uuid = '';
+      uuid = mask.replace(/[xy]/g, function(c) {
+        let r = (dt + Math.random()*16)%16 | 0;
+        dt = Math.floor(dt/16);
+        return (c=='x' ? r :(r&0x3|0x8)).toString(16);
+      });
+      return uuid;
+    }
+
+  class Timer{
+      constructor(o){
+          const {inputs=[], time=0, countdown=false, debug=false, callback, hearbeat={} }=o ? o : {};
+          this.blnTimer = false;
+          this.timeIni = 0;
+          this.timerId = 0;
+          this.time = time;
+          this.inputs = inputs;
+          this.timeDefault = time;
+          this.debug =debug;
+          this.countdown = countdown;
+          this.callback = callback;
+          this.hearbeat = hearbeat;
+      }
+      start(){
+          if (!this.blnTimer){
+              this.timeIni = new Date();
+              this.timerId =setInterval(() => {this.chrono();}, 1000); 
+              this.blnTimer = true;
+          }
+      }
+      stop(){
+          if (this.blnTimer){
+              clearTimeout(this.timerId);
+              this.timeIni = 0;
+              this.timerId =0;
+              this.blnTimer = false;
+          }
+      }
+      reset(time){
+          this.stop();
+          this.time = time?time:0;
+          this.timeDefault = time?time:0;
+          this.start();
+      }
+      chrono(){
+          let timeActual = new Date();
+          let diff = Math.round(timeActual.getTime() / 1000) - Math.round(this.timeIni.getTime() / 1000);
+          this.time = this.countdown ? (this.timeDefault) - (diff*1) : (diff*1)+this.timeDefault ;
+          this.show();
+          if (this.countdown &&  this.time=='0'){
+              this.stop();
+              this.callback ? this.callback() : ''; 
+          }
+          try{  // 2022/11/06 Heartbeat
+              let {pulse=0, timeIni=0, startEvent = false} = this.hearbeat ? this.hearbeat: {};
+              if (pulse>0){
+                  if (startEvent){
+                      this.hearbeat.startEvent = false;
+                      this.hearbeat.event ? this.hearbeat.event(0) : ''; 
+                  }
+                  timeIni == 0 ? this.hearbeat.timeIni = timeActual : '';
+                  let diffpulse = Math.round(timeActual.getTime() / 1000) - Math.round(this.hearbeat.timeIni.getTime() / 1000);
+                  if ( diffpulse >= pulse ){
+                      this.hearbeat.timeIni = 0;
+                      this.hearbeat.event ? this.hearbeat.event(diffpulse) : ''; 
+                  }
+              }
+          }catch(e){
+              console.log('heartbeat.err',e);
+          }
+          this.debug ? console.log(' date => countdown['+this.countdown+'] '+this.timeIni+' Time ==>'+this.time+' display =>' +this.display(this.time)) : '';
+      }
+      getTime(){
+          return this.time;
+      }
+      display(time){
+          let hours =  Math.floor(time / 3600);
+          let minutes = Math.floor((time - (hours * 3600)) / 60);
+          let seconds = time - (hours * 3600) - (minutes * 60);
+          if (hours   < 10) {hours   = "0"+hours;}
+          if (minutes < 10) {minutes = "0"+minutes;}
+          if (seconds < 10) {seconds = "0"+seconds;}
+          return hours+':'+minutes+':'+seconds;
+      }
+      show(){
+          this.inputs.forEach(x=>{const {id='', property='innerHTML', display=false}  = x;  OB_(id) ? eval (`OB_('${id}').${property}='${display? this.display(this.time) :this.time}';`) : '';});
+      }
+  }
+  
+  class Sauron {
+        constructor(o) {
+          Object.assign(this, o);
+          this.observers = [];
+      }
+      notify(topic, data){
+          //console.log(`notify "${topic}"`, this.observers);
+          if(this.observers[topic]){
+              this.observers[topic].forEach(observer => observer.fn(data));
+          }else{
+              console.log(`No existe topico: ${topic}`);
+          }
+      }
+      subscribe(topic, observer){
+          if(!this.observers[topic]){
+              this.observers[topic] = new Array();
+          }
+          //console.log(`suscribiendo a "${topic}"`, this.observers[topic]);
+          this.observers[topic].push(observer);
+      }
+      unsubscribeTopic(topic, id) {
+          //console.log(`unsuscribe :${id}`);
+          this.observers[topic] = this.observers[topic].filter(subscriber => subscriber.id !== id);
+      }
+  }
+
+  Date.prototype.getWeekNumber = function () {
+    let d = new Date(+this);  //Creamos un nuevo Date con la fecha de "this".
+    d.setHours(0, 0, 0, 0);   //Nos aseguramos de limpiar la hora.
+    d.setDate(d.getDate() + 4 - (d.getDay() || 7)); // Recorremos los días para asegurarnos de estar "dentro de la semana"
+    //Finalmente, calculamos redondeando y ajustando por la naturaleza de los números en JS:
+    return Math.ceil((((d - new Date(d.getFullYear(), 0, 1)) / 8.64e7) + 1) / 7);
+  };
+
+  const getId_key=(o)=>{  // Genera Identificador Unico  Ultimo Digito del Anio+dia de la semana 2 digitos + hora 2 digitos + min 2 digitos + random 4 digitos
+    let ID = '';
+    const {mask='',length=6, token = ''}=o?o:{};
+    let extra = random({length});
+
+    if (mask!=''){
+        extra = uuid({mask});
+    }
+    
+    try{
+        let dt = new Date();
+        let YY = dt.getFullYear().toString().substr(-2);
+        let SW = addZero(dt.getWeekNumber());
+        let Hora = addZero(dt.getHours())+''+addZero(dt.getMinutes())+''+addZero(dt.getSeconds())+token+extra;
+        ID = YY+''+SW+'-'+Hora;
+        ID = ID.toUpperCase();
+    }catch(e){
+      console.log(e);
+    }
+    return ID;
+  }
+  
+  const get_id_key=(o)=>{  // Genera Identificador Unico  Ultimo Digito del Anio+dia de la semana 2 digitos + hora 2 digitos + min 2 digitos + random 4 digitos
+    let ID = '';
+    const {mask='',length=6, token = ''}=o?o:{};
+    let extra = random({length});
+
+    if (mask!=''){
+        extra = uuid({mask});
+    }
+    
+    try{
+        let dt = new Date();
+        let YY = dt.getFullYear().toString().substr(-2);
+        let SW = addZero(dt.getWeekNumber());
+        let Hora = addZero(dt.getHours())+''+addZero(dt.getMinutes())+''+addZero(dt.getSeconds())+token+extra;
+        ID = YY+''+SW+'-'+Hora;
+        ID = ID.toUpperCase();
+    }catch(e){
+      console.log(e);
+    }
+    return ID;
+  }
+  
+const health_check=(o)=>{
+  try{
+    const {uri='', pulse=0, user='', pass='' } = o;
+    if (uri==''){
+        log('healthCheck.notUri:', o);
+        return;
+    }
+    const timerHelth= new Timer({
+      hearbeat:{pulse, startEvent:true, 
+        event:function(pulseEvent){
+          const request = require('request');
+          let auth = "Basic " + Buffer.from(user + ":" + pass).toString("base64");
+          o.pulseEvent = pulseEvent;
+          o.date = dateHour();
+          const options = {
+            url:uri,  
+            headers:{
+              'Content-Type': 'application/json',
+              'authorization': auth
+            },
+            body: JSON.stringify(o) 
+          }
+          request.post(options, function(err, resp, body) {
+              if (err) {
+                  log('healthCheck.err', err);
+              }else{
+                  log('healthCheck.hearbeat', resp.statusCode);
+              }
+            })
+        }
+      }
+    });
+    timerHelth.start();
+  }catch(e){
+    log('healthCheck.err',e);
+  }
+}
+
+const endpointAuth=(json)=>{
+  let obj;
+  try{
+    let {o = {}, req = {}} = json ? json : {};
+    let {authorization}=req.headers ? req.headers : {};
+    obj = {...o};
+    if (authorization) {
+      let auth = new Buffer.from(authorization.split(' ')[1],'base64').toString().split(':');
+      obj.user = auth[0]
+      obj.password = auth[1];
+    }
+  }catch(e){
+      log('endpointAuth.err:',e)
+  }
+  return obj;
+}
+
+const endpoint_auth=(json)=>{
+  let obj;
+  try{
+    let {o = {}, req = {}} = json ? json : {};
+    let {authorization}=req.headers ? req.headers : {};
+    obj = {...o};
+    if (authorization) {
+      let auth = new Buffer.from(authorization.split(' ')[1],'base64').toString().split(':');
+      obj.user = auth[0]
+      obj.password = auth[1];
+    }
+  }catch(e){
+      log('endpointAuth.err:',e)
+  }
+  return obj;
+}
+
+const execute_command = async (o)=> {
+  const {command} = o;
+  return new Promise(function (resolve, reject) {
+        if (command==''){
+           resolve({code:400, ds_code:'no se informo comando'});
+        }
+        let exec = require('child_process').exec;
+        exec(command, (err, stdout, stderr) => {
+           if (err){
+              resolve({code:400, err, stderr });
+           }
+           stdout= stdout.trim();
+           resolve({code:200, stdout, command });
+        });
+     }
+  );
+}
+
+const parse_url = (url)=> {
+  let result=[];
+  try{
+    const re  = /^(?:([A-Za-z]+):)?(\/{0,3})([0-9.\-A-Za-z]+)(?::(\d+))?(?:\/([^?#]*))?(?:\?([^#]*))?(?:#(.*))?$/;
+    result = re .exec(url); 
+  }catch(e){
+    log('parse_url.err',e);
+  }
+  return result;
+}
+
+const join = async(conjuntosUno, prefijo1, llave1, conjuntosDos, prefijo2, llave2, tipoJoin, salida=[]) => {
+	let res =[];
+	let separador = '_';
+	try{
+		if(ObjectEmpty(conjuntosUno[0],llave1) && ObjectEmpty(conjuntosDos[0],llave2) ){
+			let propertiesA = Object.getOwnPropertyNames(conjuntosUno[0]);
+			let propertiesB = Object.getOwnPropertyNames(conjuntosDos[0]);
+			switch(tipoJoin){
+				case 'right':
+					res = conjuntosDos.map(function(conjuntoDos) {
+						let obj = {};
+						let conjuntoC = conjuntosUno.filter(function(p) { 
+							return p[llave1] === conjuntoDos[llave2];
+						})[0];
+						propertiesA.forEach((property) => {
+              try{
+                let descriptor = conjuntoC ? Object.getOwnPropertyDescriptor(conjuntoC, property) :  Object.getOwnPropertyDescriptor({ property1: '' }, 'property1');
+                if (salida.length>0){
+                  for (let e of salida){
+                    if (property==e.property && prefijo1==e.prefijo){
+                      Object.defineProperty(obj, e.alias, descriptor); break;
+                    }
+                  }
+                }else{
+                  Object.defineProperty(obj, prefijo1+separador+property, descriptor);
+                }   
+              }catch(e){
+              }               
+						});
+						propertiesB.forEach((property) => {
+              try{
+                let descriptor = Object.getOwnPropertyDescriptor(conjuntoDos, property);
+                if (salida.length>0){
+                  for (let e of salida){
+                    if (property==e.property && prefijo2==e.prefijo){
+                      Object.defineProperty(obj, e.alias, descriptor); break;
+                    }
+                  }
+                }else{
+                  Object.defineProperty(obj, prefijo2+separador+property, descriptor);   
+                }
+              }catch(e){
+              }               
+						});                    
+						if (Object.keys(obj).length!==0){
+							return obj;
+						}
+					});				
+				break;
+				case 'left':
+					res = conjuntosUno.map(function(conjuntoUno) {
+						let obj = {} 
+						let conjuntoC = conjuntosDos.filter(function(p) {    
+							return p[llave2] === conjuntoUno[llave1];    
+						})[0];
+						propertiesA.forEach((property) => {
+              try {
+                let descriptor = Object.getOwnPropertyDescriptor(conjuntoUno, property);
+                if (salida.length>0){
+                  for (let e of salida){
+                    if (property==e.property && prefijo1==e.prefijo){
+                      Object.defineProperty(obj, e.alias, descriptor); break;
+                    }
+                  }
+                }else{
+                  Object.defineProperty(obj, prefijo1+separador+property, descriptor);
+                }
+              }catch(e){
+              }               
+						});
+						propertiesB.forEach((property) => {
+              try{
+                let descriptor = conjuntoC ? Object.getOwnPropertyDescriptor(conjuntoC, property) :  Object.getOwnPropertyDescriptor({ property1:''}, 'property1');
+                if (salida.length>0){
+                  for (let e of salida){
+                    if (property==e.property && prefijo2==e.prefijo){
+                      Object.defineProperty(obj, e.alias, descriptor); break;
+                    }
+                  }
+                }else{
+                  Object.defineProperty(obj, prefijo2+separador+property, descriptor);   
+                }
+              }catch(e){
+              }                          
+						});
+						if (Object.keys(obj).length!==0){
+							return obj;
+						}
+					});				 
+				break;
+				case 'inner':  
+				res = conjuntosUno.map(function(conjuntoUno) {
+					let obj = {}
+					let conjuntoC = conjuntosDos.filter(function(p) {    
+						return p[llave2] === conjuntoUno[llave1];    
+					})[0];
+					if (conjuntoC){
+						propertiesA.forEach((property) => {
+              try{
+                let descriptor = Object.getOwnPropertyDescriptor(conjuntoUno, property);
+                if (salida.length>0){
+                  for (let e of salida){
+                    if (property==e.property && prefijo1==e.prefijo){
+                      Object.defineProperty(obj, e.alias, descriptor); break;
+                    }
+                  }
+                }else{
+                  Object.defineProperty(obj, prefijo1+separador+property, descriptor);
+                }
+              }catch(e){
+              }               
+						});
+						propertiesB.forEach((property) => {
+              try{
+                let descriptor = conjuntoC ? Object.getOwnPropertyDescriptor(conjuntoC, property) :  Object.getOwnPropertyDescriptor({ property1: '' }, 'property1');
+                // Valor del campo  log('descriptor', descriptor);
+                if (salida.length>0){
+                  for (let e of salida){
+                    if (property==e.property && prefijo2==e.prefijo){
+                      Object.defineProperty(obj, e.alias, descriptor); break;
+                    }
+                  }
+                }else{
+                  Object.defineProperty(obj, prefijo2+separador+property, descriptor);   
+                }
+              }catch(e){
+              }                      
+						});
+						if (Object.keys(obj).length!==0){
+							return obj;
+						}
+					}
+				});
+				break;
+			}
+		}else{
+			console.log("joins.err Ambas o alguna llave no existe, verificar argumento de la función");
+		}
+		res = res.filter(function(array) {
+			return array != undefined;    
+		});
+	}catch(e){
+		console.log('joins.err', e);
+	}
+	return res;
+  }
+
+  const tag=(path='', split='/', ext=false)=>{
+    let result = '';
+    try{
+      path = path.replace(/\\/g,"/");
+      path = path.split(split);
+      if (path.length>0){
+        result = path[path.length-1];
+        if (!ext){
+          let result_ext=result.split('.');
+          try{result=result.replace('.'+result_ext[result_ext.length-1],'')}catch(e){}
+        }
+      }
+    }catch(e){
+      console.log('tag.err', e);
+    }
+    return result;
+  }
+
+/**
+ * Convierte un json array a un json de tipo resultSet
+ * @param {array<String>} json example: [{id:1, ds:'|'}, {id:2, ds:'2'}] 
+ * @param {json<string>} {} example: {dml='', time=0, results='', code=200, error=0, msg='', extra=''}
+ * @returns {json<string>}
+ */
+const jsonToResultSet=async(json, {dml='', time=0, results='', code=200, error=0, msg='', extra='' }={} )=>{
+  let headers = "", ltheaders=[];
+  let  columns = 0;
+  const rows = json;
+  const irows = rows.length?rows.length:0;
+  try{ ltheaders = Object.keys(json[0]);  }catch(e){}
+  try{ headers = Object.keys(json[0]); headers = headers.join("|");  }catch(e){}
+  columns  = ltheaders.length;
+  return {
+      dml,
+      time,
+      headers,
+      ltheaders,
+      columns, 
+      rows,
+      irows,
+      nextIndex : 0,
+      row:{},
+      next:function(){
+          if (this.nextIndex < this.rows.length){
+              this.row = this.rows[this.nextIndex++];
+              return true;
+          }else{
+              return false;
+          }
+      },
+      get:function(x){
+          if (!isNaN(x)){
+              x = this.ltheaders[x];
+          }
+          return this.row[x]!=null?this.row[x]:'';
+      },
+      reset:function(){
+          this.nextIndex = 0;
+      },
+      results,
+      code,
+      error,
+      msg,
+      extra
+  }
+}
+
+const json_to_result=async(json, {dml='', time=0, results='', code=200, error=0, msg='', extra='' }={} )=>{
+  let headers = "", ltheaders=[];
+  let  columns = 0;
+  const rows = json;
+  const irows = rows.length?rows.length:0;
+  try{ ltheaders = Object.keys(json[0]);  }catch(e){}
+  try{ headers = Object.keys(json[0]); headers = headers.join("|");  }catch(e){}
+  columns  = ltheaders.length;
+  return {
+      dml,
+      time,
+      headers,
+      ltheaders,
+      columns, 
+      rows,
+      irows,
+      nextIndex : 0,
+      row:{},
+      next:function(){
+          if (this.nextIndex < this.rows.length){
+              this.row = this.rows[this.nextIndex++];
+              return true;
+          }else{
+              return false;
+          }
+      },
+      get:function(x){
+          if (!isNaN(x)){
+              x = this.ltheaders[x];
+          }
+          return this.row[x]!=null?this.row[x]:'';
+      },
+      reset:function(){
+          this.nextIndex = 0;
+      },
+      results,
+      code,
+      error,
+      msg,
+      extra
+  }
+}
+
+const differenceInDays=(day1, day2)=>{
+  let days = 0;
+  try{
+      let date1 = new Date(day1);
+      let date2 = new Date(day2);
+      let Difference_In_Time = date2.getTime() - date1.getTime();
+      days = Difference_In_Time / (1000 * 3600 * 24);
+  }catch(e){
+      console.log('differenceInDays.err',e);
+  }
+  return days;
+}
+
+const difference_day=(day1, day2)=>{
+  let days = 0;
+  try{
+      let date1 = new Date(day1);
+      let date2 = new Date(day2);
+      let Difference_In_Time = date2.getTime() - date1.getTime();
+      days = Difference_In_Time / (1000 * 3600 * 24);
+  }catch(e){
+      console.log('differenceInDays.err',e);
+  }
+  return days;
+}
+
+const datePart=(date='1990-01-01 00:00:00')=>{
+  let d = new Date(date);
+  return {
+      date: d,
+      year: d.getFullYear(),
+      month: addZero(d.getMonth()+1),
+      day: addZero(d.getDate()),
+      hours:  addZero(d.getHours()),
+      minutes: addZero(d.getMinutes()),
+      seconds: addZero(d.getSeconds())
+  }
+}
+
+const date_part=(date='1990-01-01 00:00:00')=>{
+  let d = new Date(date);
+  return {
+      date: d,
+      year: d.getFullYear(),
+      month: addZero(d.getMonth()+1),
+      day: addZero(d.getDate()),
+      hours:  addZero(d.getHours()),
+      minutes: addZero(d.getMinutes()),
+      seconds: addZero(d.getSeconds())
+  }
+}
+
+const ascii_to_hexa=(str)=>{
+  let arr1 = [];
+  for (let n = 0, l = str.length; n < l; n++) {
+      let hex = Number(str.charCodeAt(n)).toString(16);
+      arr1.push(hex);
+  }
+  return arr1.join('');
+}
+
+const get_user_agent=(user_agent)=>{
+  let ua = {};
+  try{
+    let parser = require('ua-parser-js');
+    ua = parser(user_agent);
+  }catch(e){
+  }
+  return ua;
+} 
+
+
+const get_formatted_date=(date, prefomattedDate = false, hideYear = false)=>{
+  const MONTH_NAMES = [
+      'Ene', 'Feb', 'Mar', 'Abr', 'May', 'Jun','Jul', 'Ago', 'Sep', 'Oct', 'Nov', 'Dic'
+    ];
+  const day = date.getDate();
+  const month = MONTH_NAMES[date.getMonth()];
+  const year = date.getFullYear();
+  const hours = date.getHours();
+  let minutes = date.getMinutes();
+
+  if (minutes < 10) {
+    // Adding leading zero to minutes
+    minutes = `0${ minutes }`;
+  }
+
+  if (prefomattedDate) {// Today at 10:20 // Yesterday at 10:20
+    return `${ prefomattedDate } ${ hours }:${ minutes }`;
+  }
+
+  if (hideYear) {// 10. January at 10:20
+    return `${ day }. ${ month } ${ hours }:${ minutes }`;
+  }
+
+  // 10. January 2017. at 10:20
+  return `${ day }. ${ month } ${ year }. ${ hours }:${ minutes }`;
+}
+
+/**
+ * devuelve formato de fecha
+ * https://muffinman.io/blog/javascript-time-ago-function/
+ * @param {date} dateParam 
+ * @param {string} language 
+ * @returns 
+ */
+const time_ago=(dateParam, language='spanish') =>{
+  if (!dateParam) {
+    return null;
+  }
+
+  const date = typeof dateParam === 'object' ? dateParam : new Date(dateParam);
+  const DAY_IN_MS = 86400000; // 24 * 60 * 60 * 1000
+  const today = new Date();
+  const yesterday = new Date(today - DAY_IN_MS);
+  const seconds = Math.round((today - date) / 1000);
+  const minutes = Math.round(seconds / 60);
+  const isToday = today.toDateString() === date.toDateString();
+  const isYesterday = yesterday.toDateString() === date.toDateString();
+  const isThisYear = today.getFullYear() === date.getFullYear();
+
+  if (seconds < 5) {
+    return 'ahora';//'now';
+  } else if (seconds < 60) {
+    return `hace ${ seconds } sec`;
+  } else if (seconds < 90) {
+    return 'hace 1 minuto';//'about a minute ago';
+  } else if (minutes < 60) {
+    return `hace ${ minutes } min`;
+  } else if (isToday) {
+    return get_formatted_date(date, 'Hoy'); // Today at 10:20
+  } else if (isYesterday) {
+    return get_formatted_date(date, 'Ayer'); // Yesterday at 10:20
+  } else if (isThisYear) {
+    return get_formatted_date(date, false, true); // 10. January at 10:20
+  }
+  return get_formatted_date(date); // 10. January 2017. at 10:20
+}
+/**
+ * Convierte segundos a formato time
+ * @param {int} seconds example 10 
+ * @returns formato time  00:00:00
+ */
+const seconds_to_time=(seconds)=>{
+  let hour = Math.floor(seconds / 3600);
+  hour = (hour < 10)? '0' + hour : hour;
+  let minute = Math.floor((seconds / 60) % 60);
+  minute = (minute < 10)? '0' + minute : minute;
+  let second = seconds % 60;
+  second = (second < 10)? '0' + second : second;
+  return hour + ':' + minute + ':' + second;
+}
+
+/**
+ * Detiene flujo por x tiempo
+ * @param {*} ms milisegundos
+ * @returns 
+ */
+const sleep =(ms, debug=false)=> {
+  debug ? log(':::::::::::::::> sleep ',ms) : '';
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Get name page web
+ * @param {*} path 
+ * @param {*} split 
+ * @returns 
+ */
+const get_name_pw=(path)=>{
+  let result = '';
+  try{
+    path = tag(path);
+    path = path.replace("pw_","");
+    path = path.replace(".js","");
+    try{ if (!isNaN(path)) {path = path*1;} }catch(e){}
+    result = path;
+  }catch(e){
+    console.log('tag.err', e);
+  }
+  return result;
+}
+
+
+/**
+ * Metodo que realiza intentos sincronos o asincronos en cualquir tipo de peticion utiliza la librerio de request
+ * @param {json<string>} {} example: apix({options:{url:'[url]'}, retries=3, time:30, async:false, callback:function(){}}); default: retries=3, time=60, status_ok=[200]
+ * @returns {err, statusCode, res, body, retry, Object_id}
+ */
+const apix=async(o)=>{
+  let result;
+  try{
+      let { retry=1, retries=3, time=60, async=false, status_ok=[200], callback} = o ? o:{}; 
+      let status = status_ok.toString();
+      if (async){ // Metodo asincrono
+          o.retries = 1;  // Incializar reintentos para no realizar un cliclo sin fin
+          try{delete o.callback }catch(e){} // Se elimina callback en async: true ya  que se ejecutara cuando terminen los intentos          
+          do {
+              result = await apix_backend(o);
+              if ( valueIn({ value:''+result.statusCode, in:status }) ){
+                  break;
+              }
+              retry++;
+              o.retry = retry;
+              await sleep(time*1000);
+          } while (retry <= retries);
+          callback ? callback({...result}) : '';
+      }else{
+          result = await apix_backend(o);
+      }
+  }catch(e){
+      log('apix.err', e);
+  }
+  return result;
+}
+
+/**
+* Metodo que realiza  cualquier tipo de peticion utiliza la librerio de request
+* @param {json<string>} {} example: apix_backend({options:{url:'[url]'}, retries=3, time:30, async:false, callback:function(o){}}); default: retries=3, time=60, status_ok=[200]
+* @returns {err, statusCode, res, body, retry, Object_id}
+*/
+const apix_backend=async(o)=>{
+  let result;
+  try{
+    let {method='get', options='', retry=1, retries=3, time=60, status_ok=[200], Object_id, callback} = o ? o:{}; 
+      const request   = require('request');
+      const tag='apix';
+      let status = status_ok.toString();
+      
+      if (!Object_id){
+          o.Object_id = ObjectId()+`_${retry}_${retries}_${time}`;   // id_intento_intentos_time
+      }else{
+          let Object_id_new = Object_id.split('_');
+          Object_id_new[1]=retry;
+          o.Object_id=Object_id_new.toString().replace(/,/gi,'_');
+      }
+      let {url=''} = options ? options : {};
+      eval(`result = new Promise((resolve, reject) => { 
+              try{
+                  request.${method}( options, (err, res, body) => {
+                      const {statusCode=404} = res ? res : {};                        
+                      if ( !valueIn({ value:''+statusCode, in:'${status}' }) ){
+                          log(tag+' ${o.Object_id} '+statusCode,\`apix({method:"${method}", options, time:${time}, url:"${url}"});\`);
+                          if (retry<retries){ // Solo permite el numero de intentos
+                              o.retry = retry+1;
+                              const timer = new Timer({time:${time}, countdown: true,
+                                  callback:async function(){
+                                      apix_backend(o);
+                                  }
+                              });
+                              timer.start();
+                            }else{
+                              callback ? callback({err, statusCode, res, body, retry, Object_id:'${o.Object_id}' }) : ''; 
+                            }
+                      }else{
+                          callback ? callback({err, statusCode, res, body, retry, Object_id:'${o.Object_id}' }) : '';
+                          if (retry>1){
+                              log(tag+' ${o.Object_id} '+statusCode, \`apix({method:"${method}", options, time:${time}, url:"${url}"});\`);
+                          } 
+                      }
+                      resolve ({err, statusCode, res, body, retry, Object_id:'${o.Object_id}'});
+                  });
+              }catch(e){
+                  log('apix_backend request err', e);
+              }
+          });
+      `);
+  }catch(e){
+      log('apix_backend.err', e);
+      result = 'err:'+e;
+  }
+  return result;
+}
+
+/**
+* Metodo que agrega o quita un intervalo (day,hour,minute,second) a una fecha
+* @param {json} {} example: date_add({date:new Date(), interval:-10, unit:'day'}); default:format='YYYY-MM-DD HH:mm:ss'
+* @returns date
+ */
+const date_add=(o)=>{
+  let {date, interval, unit, format='YYYY-MM-DD HH:mm:ss'} = o ? o : {};
+  let newDate;
+  try{
+    unit = unit.toLowerCase();
+    switch(unit){
+        case 'day' :    newDate =  new Date(date.getTime() + interval*24*60*60*1000); break;
+        case 'hour':    newDate =  new Date(date.getTime() + interval*60*60*1000); break;
+        case 'minute':  newDate =  new Date(date.getTime() + interval*60*1000); break;
+        case 'second':  newDate =  new Date(date.getTime() + interval*1000); break;
+        default: newDate =  new Date(date.getTime());
+    }
+    newDate =  dateFormat(format,newDate);
+  }catch(e){
+    log('date_add.err', e);
+  }
+  return newDate;
+}
+
+const remove_accents=(text)=>{
+  return text.normalize('NFD').replace(/[\u0300-\u036f]/g,"");
+}
+
+/**
+* Metodo que agrega todos los campos de un json a otro ya creado
+* @param {json_main, json} {} example: add_json(json_main, json);
+* @returns {}
+ */
+const add_json=(json_main, json)=>{
+  try{
+      for (let  key in json){
+        json_main[key] = json[key];
+      }
+  }catch(e){
+    log('add_json.err', e);
+  }
+  return json_main;
+}
+
+/**
+ *  Method that returns the operating system
+ * @param  path __dirname 
+ * @param  folder folder substring
+ * @returns {}
+ */
+const info_path=(path, folder='')=>{
+  let result = {so:'linux'}; // default linux
+  try{
+     path = path.replace(/\\/g,"/");
+     result.array_path =  path.split('/');
+     if (path.length>0){
+        result.last_path= result.array_path[result.array_path.length-1];
+        result.subpath = path.replace(result.last_path,'');
+     }
+     result.path = path;
+     if (path.includes("C:")){ // windows
+        result.so = 'windows';
+     }
+     try{
+        let main_path = path.substring(0,path.indexOf(folder));
+        result.main_path = main_path;
+        result.submain_path = path.replace(main_path,'');
+     }catch(e){
+
+     }
+  }catch(e){
+     result.err = e;
+  }
+  return result;
+}
+
+const json_to_csv=(obj={}, token=',')=>{
+  let linea = "";
+  for (const key in obj) {
+      try{
+          let value = ""+obj[key];  // Convert text
+          value = value.replace(/\"/gm, '\"\"'); // Escape double quote
+          value = value.replace(null, ''); //  replace nulls with whitespace
+          value = value.replace(/[\t|\r|\n|\t\n\r|\r\n]/gm, ''); //Remove tabs, carriage returns and enters
+          if (linea.length>0){
+              linea = linea + `${token}`;
+          }
+          linea = linea + `"`+value+`"`;
+      }catch(e){
+          log('json_to_csv.err key['+key+'] value['+value+']',e)
+      }
+  }
+  return linea+"\n";
+}
+
+/**
+ * Create csv file by default the file is saved in ascii
+ * @param {<string>} path example: /var/test.csv
+ * @param {<string>} data  example: "test1","test2"
+ * @param {<string>} charset example: utf8, ascii default: ascii
+ */
+const create_file_csv=async(path, data, charset='ascii')=>{
+    const fs  = require('fs');
+    return new Promise ((resolve, reject)=>{
+    try{
+        if (path){
+            fs.writeFile(path, data, charset, function(err) {
+                if (err) {
+                    return resolve ({ error:1, err });
+                } else {
+                    return resolve ({ error:0, path });
+                }
+            });
+        }   
+    }catch(e){
+        return resolve({ error:0, err:e });
+    }
+  });
+}
+
+const is_valid_email = (email) => {
+  const regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+  return regex.test(email);
+};
+
+/**
+ * Segment  array of json objects
+ * @param {[]} rows : Array 
+ * @param {int} elements_number: number of elements to be separated
+ * @param {String} key_id: Not required; key of a field inside the json to get the ids
+ * @returns 
+ */
+const parts_array=async(array=[], elements_number=1, key_id)=>{
+  let ir = 0;
+  let batch_array = [], batch_total = [];
+  let row_part =[];
+  let batch_ids = [], ids_part=[];
+  try{
+    for (let row of array){
+        ir++;
+        row_part.push(row);
+        try{ key_id ? ids_part.push(row[key_id]) : ''; }catch(e){ }
+        if (ir == elements_number){
+            batch_total.push(ir);
+            batch_array.push(row_part);
+            try{ key_id ? batch_ids.push(ids_part) : ''; ids_part=[] }catch(e){ }
+            row_part=[];
+            ir = 0;
+        }
+    }
+    if (ir>0 && ir<elements_number){
+        batch_total.push(ir);
+        batch_array.push(row_part);
+        try{ key_id ? batch_ids.push(ids_part) : ''; ids_part=[] }catch(e){ }
+        row_part=[];
+        ir = 0;
+    }
+  }catch(e){
+    log(tag+' parts_array.err', e);
+  }
+  return {batch_array, batch_total, parts: batch_array.length, total:array.length, batch_ids };
+}
+
+const hour_to_seconds=(hour='00:00')=>{
+  let current_seconds = 0;
+  try{
+      let current_time = hour.split(":");
+      current_seconds = (parseInt(current_time[0], 10) * 60 * 60) + (parseInt(current_time[1], 10) * 60);
+  }catch(e){
+
+  }
+  return current_seconds;
+}
+
+/**
+* Group on array json 
+* @param {string} key : Name of the field to group by
+* @param {array} array    : Array 
+* @param {string} field_id : Not required; adds only the object field default: adds the entire object
+* @returns 
+*/
+const group_by_array=async (array, key, field_id='')=>{
+  let group = {};
+  try{
+      for (let x of array){
+          let value_key = x[key] ? x[key] : '';
+          let value_field_id = x[field_id] ? x[field_id] : '';
+          value_key = ''+value_key;
+          if (value_key){
+              let object_key = group[value_key] ? group[value_key] : [];
+              if (field_id){
+                  object_key.push(value_field_id);
+              }else{
+                  object_key.push(x);
+              }
+              group[value_key] = object_key;
+          }
+      }
+  }catch(e){
+      log(tag+' group_by_array.err', e);
+  }
+  return group;
+}
+
+/**
+* Returns comma-separated values ​​from an array
+* @param {array} array  
+* @param {string} keys_id example: id,ds keys separated by commas
+* @returns {json} 
+*/
+const keys_array_ids=async(array=[], keys='')=>{
+  let ids = {};
+  keys = keys.split(',');
+  try{
+      for (let x of array){
+          for (let key of keys){
+              let value_key = x[key] ? x[key] : '';
+              let object_key = ids[key] ? ids[key] : [];
+              object_key.push(value_key);
+              ids[key] = object_key;
+          }
+      }
+  }catch(e){
+      log(tag+' keys_array_ids.err', e);
+  }
+  return ids;
+
+}
+
+  module.exports={
+    log,
+    addZero,
+    getIp,
+    milisegundosASegundos,
+    date,
+    hour,
+    dateHour,
+    sort,
+    ArraytoJson,
+    find,
+    filter,
+    isObjectEmpty,
+    compose,
+    pipe,
+    trace,
+    traceId,
+    random,
+    valueIn,
+    hex_to_ascii,
+    ObjectEmpty,
+    ObjectId,
+    uuid,
+    dateFormat,
+    dateHourFull,
+    getId_key,
+    Timer,
+    Sauron,
+    health_check,
+    endpointAuth,
+    endpoint_auth,
+    execute_command,
+    parse_url,
+    join,
+    tag,
+    jsonToResultSet,
+    differenceInDays,
+    datePart,
+    ascii_to_hexa,
+    get_user_agent,
+    get_formatted_date,
+    time_ago,
+    seconds_to_time,
+    sleep,
+    get_name_pw,
+    apix,
+    date_add,
+    remove_accents,
+    add_json,
+    info_path,
+    json_to_csv,
+    create_file_csv,
+    is_valid_email,
+    miliseconds_to_seconds,
+    parts_array,
+    hour_to_seconds,
+    group_by_array,
+    keys_array_ids,
+    date_format,
+    date_hour,
+    date_hour_full,
+    array_to_json,
+    is_object_empty,
+    trace_id,
+    value_in,
+    object_empty,
+    object_id,
+    get_id_key,
+    json_to_result,
+    difference_day,
+    date_part
+  }