node-red-contrib-prib-functions 0.18.0 → 0.20.4

package/monitor/Format.js

@@ -0,0 +1,74 @@
+const Format={
+    NumberToAbbreviated:(value)=>{
+     if(typeof value!='number') value=parseFloat(value);
+     if (value>Math.pow(10,16)) return Math.round(value/Math.pow(10,15)).toString()+'P'
+     if (value>Math.pow(10,13)) return Math.round(value/Math.pow(10,12)).toString()+'T'
+     if (value>Math.pow(10,10)) return Math.round(value/Math.pow(10,9)).toString()+'G'
+     if (value>Math.pow(10,7)) return Math.round(value/Math.pow(10,6)).toString()+'M'
+     if (value>Math.pow(10,4)) return Math.round(value/Math.pow(10,3)).toString()+'K'
+     if (value == Math.round(value)) return value.toString()
+     if (value>=10000) return value.toFixed(0).toString()
+     if (value>=1000) return value.toFixed(1).toString()
+     if (value>=100) return value.toFixed(2).toString()
+     if (value>=10) return value.toFixed(3).toString()
+     return value.toString()
+    },
+    HexToString: (value)=>{
+       if(value==null) return null;
+       let valueString = '';
+       for (let i = 0; i < value.length; i += 2)
+           valueString += String.fromCharCode(parseInt(value.substr(i, 2), 16));
+       return valueString;
+    },
+    padLeadZero:(value,size)=>"000000000000".substr(0,size-value.toString().length)+value,
+    toString:(type,value)=>{
+      switch (type) {
+        case 'timestamp' :
+        case 'datetime' :
+        case 'time' :
+        case 'date' :
+          var ts = new Date();
+          ts.setTime(parseInt(value));
+          var axisLabel='';
+          switch (this.dataType[0]) {
+              case 'timestamp' :
+              case 'date' :
+              case 'datetime' :
+                if (this.precision[0] >= 1440) axisLabel+=ts.getFullYear()+'-';
+                if (this.precision[0] >= 1440) axisLabel+=Format.padLeadZero(ts.getMonth()+1,2)+'-';
+                if (this.precision[0] >= 1440) axisLabel+=Format.padLeadZero(ts.getDate(),2);
+                if (this.precision[0] >= 1440) axisLabel+=' ';
+              case 'time' :
+                if (this.precision[0] >= 360) axisLabel+=Format.padLeadZero(ts.getHours(),2)+':';
+                if (this.precision[0] >=  60) axisLabel+=Format.padLeadZero(ts.getMinutes(),2)+':';
+                if (this.precision[0] >=  1) axisLabel+=Format.padLeadZero(ts.getSeconds(),2);
+          }
+          return 	axisLabel;
+        case 'int' :
+        case 'real' :
+        case 'number' :
+          return format.NumberToAbbreviated(value)
+      }
+      return value.toString();
+    },
+    StringToHex:(value)=>{
+      if(value==null) return null;
+      let hex = '';
+      for(let i=0;i<value.length;i++) 
+        hex += ''+value.charCodeAt(i).toString(16);
+      return hex;
+    },
+    xmlEncodeString(value) {
+        if(value==null) return null;
+        return value.toString().replace(/([\&"<>])/g, function(str, item) {
+            return {
+                '&': '&amp;',
+                '"': '&quot;',
+                '<': '&lt;',
+                '>': '&gt;'
+            }[item];
+        });
+    }
+  }
+  
+module.exports=Format

package/monitor/centerElement.js

@@ -0,0 +1,14 @@
+function centerElement(elementIdToCenter) {
+    if(elementIdToCenter == null)	return;
+    const toCenter = document.getElementById(elementIdToCenter);
+    const width = toCenter.getWidth();
+    const height = toCenter.getHeight();
+    const elementParent = toCenter.ancestors();
+    const Pwidth = elementParent[0].getWidth();
+    const Pheight = elementParent[0].getHeight();
+    width = parseInt(Pwidth/2, 10) - parseInt(width/2, 10);
+    height = parseInt(Pheight/2, 10) - parseInt(height/2, 10);
+    toCenter.setStyle({'top': height + 'px'});
+    toCenter.setStyle({'left': width + 'px'});
+}
+module.exports=centerElement

package/monitor/compareElements.js

@@ -0,0 +1,95 @@
+function compareNodes(oldNode, newNode, compare) {      //  this function under construction
+    if( compare==null)
+        var compare= {
+             attribute: {
+                 match: function(attribute) {
+                     }
+                ,mismatch: function(oldAttribute,newAttribute) {
+                    return '<attribute key="'+oldAttribute.nodeName+'" old="'+oldAttribute.nodeValue+'" new="'+newAttribute.nodeValue+'"/>';
+                    }
+                ,missingNew: function(attribute) {
+                    return '<attribute key="'+attribute.nodeName+'" new="'+attribute.nodeValue+'"/>';
+                    } 
+                ,missingOld : function(attribute) {
+                    return '<attribute key="'+attribute.nodeName+'" old="'+attribute.nodeValue+'"/>';
+                    }
+                }
+            ,node: {
+                 isSameElement: function(oldNode,newNode) {
+                         if(oldNode.nodeType != newNode.nodeType) return false;
+                         if(oldNode.nodeType != 1) return true;
+                        return (oldNode.nodeName = newNode.nodeName);
+                     }
+                ,match: function(node) {
+                     }
+                ,mismatch: function(oldNode,newNode) {
+                        return '<pair><new th>"'+node.nodeValue+'</new></node>'
+                    }
+                ,missingNew: function(node) {
+                        return '<node key="'+node.nodeName+'"><new>"'+node.nodeValue+'</new></node>'
+                    } 
+                ,missingOld : function(node) {
+                        return '<node key="'+node.nodeName+'"><old>"'+node.nodeValue+'</old></node>'
+                    }
+                }
+            };
+    var diff="";
+    if(oldNode == null)
+        var oldAttributes=[] , oldNodes=[];
+    else 
+        var oldAttributes=oldNode.attributes , oldNodes=oldNode.childNodes;
+    if(newNode == null)
+        var newAttributes=[] , newNodes=[];
+    else 
+        var newAttributes=newNode.attributes , newNodes=oldNode.childNodes;
+    if( !compare.node.isSameElement(oldNode,newNode)   	
+    || oldNode.nodeValue != newNode.nodeValue )
+        diff += compare.node.mismatch(oldNode,newNode);
+    else
+        diff += compare.node.match(oldNode,newNode);
+    var o=0;n=0;
+    while (o<oldAttributes.length || n<newAttributes.length) {
+        var oldAttribute=oldAttributes[o],newAttribute=newAttributes[n];
+        if(oldAttributes.nodeName==newAttribute.nodeName) {
+            if(oldAttribute.nodeValue==newAttribute.nodeValue)
+                diff += compare.attribute.match(oldAttribute);
+            else
+                diff += compare.attribute.mismatch(oldAttribute,newAttribute);
+            o++;n++;
+            continue;
+        }
+        if(oldAttribute.nodeName>newAttribute.nodeName) {
+            diff += compare.attribute.missingNew(newAttribute);
+            n++;
+            continue;
+        }
+        diff+= compare.attribute.missingOld(oldAttribute);
+        o++;
+    }
+    for (o=o;oldAttributes.length;o++) diff += compare.attribute.missingOld(oldAttributes[o]);
+    for (n=n;newAttributes.length;n++) diff += compare.attribute.missingANew(newAttributes[n]);
+    o=0;n=0;
+    while (o<oldNodes.length || n<newNodes.length) {
+        var oldNode=oldNodes[o]; newNode=newNodes[n]; 
+        if(compare.node.isSameElement(oldNode,newNode)) {
+            diff+=compareNodes(oldNode,newNode,compare);
+            n++;o++;
+            continue;
+        }
+        for (i=o;i<oldNodes.length;i++)    // search for same element 
+            if(compare.node.isSameElement(oldNodes[i],newNode)) break;
+        for (j=n;j<newNodes.length;j++)    // search for same element
+            if(compare.node.isSameElement(oldNode,newNodes[j])) break;
+   
+        if(i>=oldNodes.length) i=9999; 
+        if(j>=newNodes.length) j=9999;
+        if((i-o)>(j-n))
+            for (n=n;n<j;n++) compare.node.missingNew(newNodes[n]);
+        else 
+            for (o=o;o<i;o++) compare.node.missingOld(oldNodes[o]);
+        continue;
+    }
+    for (o=o;o<oldNodes.length;o++) compare.node.missingOld(oldNodes[o]);
+    for (n=n;n<newNodes.length;n++) compare.node.missingNew(newNodes[n]);
+   }
+   

package/monitor/defs.js

@@ -0,0 +1,23 @@
+const heatGradient=[
+  {action:"stop",offset:"5%","stop-color":"lightgreen"},
+  {action:"stop",offset:"80%","stop-color":"yellow"},
+  {action:"stop",offset:"95%","stop-color":"red`"}
+]
+const heatGradientReverse=[
+  {action:"stop",offset:"95%","stop-color":"lightgreen"},
+  {action:"stop",offset:"20%","stop-color":"yellow"},
+  {action:"stop",offset:"5%","stop-color":"red`"}
+]
+
+const defs=
+  {action:"defs",children:[
+    {action:"style",children:[".red2green { background: conic-gradient(red, orange, yellow, green)}"]},
+    {action:"linearGradient",id:"heatGradientAcross",children:heatGradient},
+    {action:"linearGradient",id:"heatGradientAcrossCircle",x1:"0%",y1:"0%",x2:"100%",y2:"0%",children:heatGradient},
+    {action:"linearGradient",id:"heatGradientAcrossReverse",children:heatGradientReverse},
+    {action:"linearGradient",id:"heatGradientDown",children:heatGradient,gradientTransform:"rotate(90)"},
+    {action:"linearGradient",id:"heatGradientDownReverse",children:heatGradientReverse,gradientTransform:"rotate(90)"},
+    {action:"radialGradient",id:"heatGradientRadial",cx:"50%",cy:"50%",r:"50%",fx:"50%",fy:"50%",children:heatGradient}
+  ]}
+
+module.exports=defs