@theotherwillembotha/node-red-plugincore 0.0.50

package/src/core/metrics/template/MetricsTemplate.html

@@ -0,0 +1,54 @@
+<script type="text/javascript" template-section="onCompose">
+    node
+        .addDefault("metricsEnabled", { value:false, required:true})
+        .addDefault("metricsReference", {type:"MetricsConfigNode", required:false})
+</script>
+
+<script type="text/javascript" template-section="onIncludeEditPrepare">
+    let node = this;   
+
+    let metricsEnabled = $("#{{defaults.metricsEnabled}}");
+    let metricsEnabledSection = $("#section_metricsEnabled");
+
+    metricsEnabled.on('change', function() {
+        if(metricsEnabled.prop("checked")){
+            metricsEnabledSection.show();
+            node._def.defaults.metricsReference.required = true;
+        }
+        else{
+            metricsEnabledSection.hide()
+            node._def.defaults.metricsReference.required = false;
+        }
+    });
+</script>
+
+<script type="text/javascript" template-section="onIncludeEditSave">
+ 
+</script>
+
+<script type="text/html" template-section="onIncludeEditForm">
+    <div id="section_metricsconfig">
+        <div class="form-row editorsectionheading">
+            <i class="w-16 fa fa-eye"></i> <span>Metrics</span>
+        </div>
+        <div class="editorgroupborder">
+            <div class="form-row nomargin metricsEnableCheck">
+                <input type="checkbox" id="{{defaults.metricsEnabled}}" value="false" style="margin:8px 0 10px 102px; width:20px;" />
+                <label style="width:auto" for="{{defaults.metricsEnabled}}"><span>Enable Metrics</span></label>
+            </div>
+
+            <div id="section_metricsEnabled">
+                <div class="form-row nomargin">
+                    <label class="towb_editorlabel" for="{{defaults.metricsReference}}">Metric Collector</label>
+                    <input id="{{defaults.metricsReference}}" placeholder="metrics" />
+                </div>
+            </div>
+        </div>
+    </div>
+</script>
+
+<script type="text/markdown" template-section="onIncludeDocumentation">
+### Metrics
+: *enable metrics* (boolean) : if checked, then the node will produce metrics output to the specified metrics provider.
+: *metric collector* (metricconfig) : the collection point or grouping where this particular metric will be attached.
+</script>

package/src/core/metrics/template/MetricsTemplate.ts

@@ -0,0 +1,18 @@
+import { SourceUtility } from "../../NodeGenerator";
+import { BaseNodeConfig, Template, TemplateDescriptor } from "../../NodeConstructor"
+import { MetricsConfigNode } from "../node/MetricsConfigNode";
+import { MetricsReference } from "../service/MetricsService";
+
+export interface MetricsTemplateConfig extends BaseNodeConfig, MetricsReference {
+}
+
+export class MetricsTemplate extends Template {
+   
+    public static getTemplateDescriptor(): TemplateDescriptor {
+        return new TemplateDescriptor(
+            "metrics",
+            MetricsTemplate, 
+            SourceUtility.getSourcePath("/build/", "/src/") + "MetricsTemplate.html",
+            [MetricsConfigNode]);
+    }
+}

package/src/core/metrics/template/TimerMetricTemplate.html

@@ -0,0 +1,39 @@
+<script type="text/javascript" template-section="onCompose">
+    node
+        .addDefault("timerConfig", { type:"TimerMetricConfigNode", required: true })
+</script>
+
+<script type="text/javascript" template-section="onIncludeEditPrepare">
+    let metricsEnabled = $("#node-{{#if config.isConfigNode}}config-{{/if}}input-metricsEnabled");
+    let metricsEnabledSection = $("#section_metricsEnabled");
+
+    metricsEnabled.on('change', function() {
+        if(metricsEnabled.prop("checked")){
+            metricsEnabledSection.show();
+            node._def.defaults.metricsReference.required = true;
+        }
+        else{
+            metricsEnabledSection.hide()
+            node._def.defaults.metricsReference.required = false;
+        }
+    });
+</script>
+
+<script type="text/javascript" template-section="onIncludeEditSave">
+ 
+</script>
+
+<script type="text/html" template-section="onIncludeEditForm">
+
+    <div id="section_timermetricconfig">
+        <div class="form-row">
+            <label for="node-input-timerConfig"><i class="fa fa-tag"></i> Timer</label>
+            <input type="text" id="node-input-timerConfig" />
+        </div>
+    </div>
+</script>
+
+<script type="text/markdown" template-section="onIncludeDocumentation">
+    ### Timer
+    : *timer* (timerconfig) : the trimer that will be incremented / decremented / observed every time the node is entered.
+</script>

package/src/core/metrics/template/TimerMetricTemplate.ts

@@ -0,0 +1,14 @@
+import { SourceUtility } from "../../NodeGenerator";
+import { Template,  TemplateDescriptor } from "../../NodeConstructor"
+import { TimerMetricConfigNode } from "../node/TimerMetricConfigNode";
+
+export class TimerMetricTemplate extends Template {
+    
+    public static getTemplateDescriptor(): TemplateDescriptor {
+        return new TemplateDescriptor(
+            "timermetric",
+            TimerMetricTemplate, 
+            SourceUtility.getSourcePath("/build/", "/src/") + "TimerMetricTemplate.html",
+            [TimerMetricConfigNode]);
+    }
+}

package/src/core/other/InputDecorator.ts

@@ -0,0 +1,57 @@
+import { BaseNode, createPostConstructDecorator } from "../NodeConstructor";
+import { Message } from "../NodeGenerator";
+import { InputService, InputConfig } from "./service/InputService";
+
+class OnInputConfig{
+
+}
+
+const onInput = createPostConstructDecorator<OnInputConfig>('onInput')
+    // initialize the default decorator with one parameter containing nothing.
+    .withDefaultConfig({})
+
+    // validate that we have at lease 1 parameter for this decorator.
+    .withValidator((target, propertyKey, descriptor) => {
+        const method = descriptor.value;
+        
+        // Ensure at least one parameter
+        if (method.length === 0) {
+            throw new Error(
+                `Method must accept at least one parameter (message: {[key:string]: any}).`
+            );
+        }
+        
+        // Check parameter types via metadata if available
+        const paramTypes = Reflect.getMetadata?.('design:paramtypes', target, propertyKey);
+        if (paramTypes && paramTypes[0] !== Object) {
+            console.warn(
+                `First parameter should be of type {[key:string]: any} (object), but got ${paramTypes[0]?.name || 'unknown'}.`
+            );
+        }
+    })
+
+    // business logic to initialize the function and wire it to the input service.
+    .withInitLogic((instance, propertyKey, onInputConfig:OnInputConfig) => {
+        //console.log(`Registering onInput callback`,  "PROPERTYKEY", propertyKey, "WEBHOOK CONFIG", onInputConfig, "THIS", this);
+
+        let node = instance as BaseNode<InputConfig>;
+        let nodeConfig = node.config();
+        let onInputFunction = instance[propertyKey];
+
+        InputService.create(instance, nodeConfig, (message, errorHandler) => {
+            try{
+                let result = onInputFunction.apply(node, [message, errorHandler]);
+                if(result instanceof Promise){
+                    result.catch((error:any) => errorHandler(error));
+                }
+            }
+            catch(error){
+                errorHandler(error);
+            }
+        });
+    })
+    .build();
+
+export {
+    onInput
+}

package/src/core/other/service/InputService.ts

@@ -0,0 +1,36 @@
+import { BaseNode, BaseNodeConfig, Template } from "../../NodeConstructor";
+
+export class Input{
+    constructor(node:BaseNode<BaseNodeConfig>, config:InputConfig, handler:(message:any, errorHandler:(error:any) => void) => void){
+        node.node().on("input", function(msg, send, done){
+            try{
+                handler(msg, done);
+            }
+            catch(error:any){
+                console.log(error);
+                done(error);
+            }
+        })
+    }
+}
+
+export class InputService {
+    private constructor(){}
+
+    static create(node:BaseNode<BaseNodeConfig>, config:InputConfig, handler:(message:any, errorHandler:Function) => void):Input{
+        return new Input(node, config, handler);
+    }
+}
+
+export interface InputConfig extends BaseNodeConfig {
+    
+}
+
+export abstract class InputHandler {
+    public abstract onInput(message:any, errorHandler:Function):void;
+}
+
+export class InputTemplate extends Template {
+
+}
+  

package/src/core/other/service/SettingsService.ts

@@ -0,0 +1,103 @@
+import {BaseNode, BaseNodeConfig, BaseService, NodeManager, ServiceDescriptor} from "../../NodeConstructor"
+import { Node, NodeAPI, NodeDef, NodeAPISettingsWithData} from "node-red";
+
+export class SettingsService extends BaseService {
+
+    static create(node:BaseNode<BaseNodeConfig>, config:SettingsConfig): Settings{
+        // load the settings from the settings file.
+        let settings = NodeManager.RED.settings.get("NodeSettings_" + config.id);
+        //console.log("Retriving Settings for: " + "NodeSettings_" + config.id + " value: " + JSON.stringify(settings));
+        if(settings === undefined){
+            settings = {};
+        }
+
+        return new Settings(settings, config);
+    }
+
+    public constructor(){
+        super("SettingsService");
+    }
+
+    public init(red: NodeAPI<NodeAPISettingsWithData>): void {
+
+        red.httpAdmin.post("/utils/getNodeSettings", red.auth.needsPermission("inject.write"), async function(request,response) {
+            let config = request.body;
+        
+            // get the settings for the node.
+            let settings = red.settings.get("NodeSettings_" + config.nodeId);
+        
+            // send the response.
+            response.send({
+                status: "ok",
+                settings: settings
+            })
+        });
+    }
+
+    public deinit(red: NodeAPI<NodeAPISettingsWithData>): void {
+        red.httpAdmin.post("/utils/getNodeSettings", red.auth.needsPermission("inject.write"), async function(request,response) {
+            response.status(404);
+        });
+    }
+
+    static override getServiceDescriptor():ServiceDescriptor {
+        return new ServiceDescriptor(
+            "@theotherwillembotha/settingsservice",
+            "SettingsService",
+            "services-plugin",
+            "@theotherwillembotha/node-red-plugincore",
+            SettingsService
+        );
+    }
+}
+
+export class Settings{
+
+    private _settings:any;
+    private _config:any;
+
+    constructor(settings:SettingsConfig, config:SettingsConfig){
+        this._settings = settings;
+        this._config = config;
+
+        // if config unchanged, we can update the settings version.
+        if(!this.hasChanged()){
+            Object.keys(this._settings).forEach(key => this._config[key] = this._settings[key]);
+        }
+    }
+
+    value(key:string):any{
+        return this._settings[key];
+    }
+
+    values():any{
+        return this._settings;
+    }
+
+    update(key:string, value:any){
+        this._settings[key] = value;
+    }
+
+    updateAll(value:any){
+        this._settings = value;
+    }
+
+    // the settings are considdered changed if the settingsTimestamp value is different;
+    hasChanged():boolean{
+        return (this._settings.settingsTimestamp !== this._config.settingsTimestamp);
+    }
+
+    persist() {
+        NodeManager.RED.settings.set("NodeSettings_" + this._config.id, this._settings);
+        //console.log("Persisted Settings for: " + "NodeSettings_" + this._config.id + " value: " + JSON.stringify(this._settings));
+    }
+
+    delete(){
+        NodeManager.RED.settings.delete("NodeSettings_" + this._config.id);
+        //console.log("Deleted Settings for: " + "NodeSettings_" + this._config.id + " value: " + JSON.stringify(this._settings));
+    }
+}
+
+export interface SettingsConfig extends BaseNodeConfig {
+    settingsTimestamp:number
+}

package/src/core/other/template/BasicTemplate.html

@@ -0,0 +1,76 @@
+
+<div template-section="onIncludeOnce">
+<!-- BasicTemplate:includeOnce -->
+<style>
+  .editorgroupborder {
+      border-width:1px;
+      border-style:solid;
+      border-color:lightgray;
+      padding: 3px;
+      margin-top: 2px;
+      margin-bottom: 2px;
+  }
+
+  .editorsectionheading {
+      font-weight: 600;
+      margin-bottom:1px !important; 
+      margin-top:6px !important; 
+  }
+
+  .nomargin {
+      margin-bottom:1px !important; 
+      margin-top:1px !important; 
+  }
+
+  .slidecontainer {
+    width: 100%;
+  }
+
+  .slider {
+    -webkit-appearance: none;
+    appearance: none;
+    width: 100%;
+    height: 25px;
+    background: #d3d3d3;
+    outline: none;
+    opacity: 0.7;
+    -webkit-transition: .2s;
+    transition: opacity .2s;
+  }
+  
+  .slider:hover {
+    opacity: 1;
+  }
+  
+  .slider::-webkit-slider-thumb {
+    -webkit-appearance: none;
+    appearance: none;
+    width: 25px;
+    height: 25px;
+    background: #04AA6D;
+    cursor: pointer;
+  }
+  
+  .slider::-moz-range-thumb {
+    width: 25px;
+    height: 25px;
+    background: #04AA6D;
+    cursor: pointer;
+  }
+</style>
+
+<style>
+    .towb_editorlabel {
+        width: 120px !important;
+    }
+    .towb_editorfield {
+        width: 70% !important;
+    }
+    .towb_editorfield_short {
+        width: 30% !important;
+    }
+
+</style>
+
+
+</div>

package/src/core/other/template/BasicTemplate.ts

@@ -0,0 +1,15 @@
+import { NodeAPI, NodeAPISettingsWithData } from "node-red"
+import { Template, TemplateDescriptor } from "../../NodeConstructor"
+import { SourceUtility } from "../../NodeGenerator";
+
+export class BasicTemplate extends Template {
+
+  public static getTemplateDescriptor(): TemplateDescriptor {
+    return new TemplateDescriptor(
+      "basic", 
+      BasicTemplate,
+      SourceUtility.getSourcePath("/build/", "/src/") + "BasicTemplate.html",
+      []
+    );   
+  }
+}

package/src/core/other/template/SettingsTemplate.html

@@ -0,0 +1,128 @@
+
+<script type="text/javascript" template-section="onCompose">
+    node
+        .addDefault("settingsTimestamp", { value:0})
+</script>
+
+<div template-section="onIncludeOnce">
+    <script type="text/javascript">
+        getNodeSettings = function(nodeId, callback){
+            console.log("Rerieving settings for node id: " + nodeId);
+
+            $.ajax({
+                url: "utils/getNodeSettings" ,
+                type: "POST",
+                data: JSON.stringify({nodeId:nodeId}),
+                contentType: "application/json; charset=utf-8",
+                success: function (response) {
+                    callback(response.settings);
+                },
+                error: function (jqXHR, textStatus, errorThrown) {
+                    console.log(jqXHR);
+                }
+            });
+        }
+
+        handleNodeSettings = function(node){
+
+            // if "settingsTimestamp" is "0" then there shouldnt be any settings to retrieve.
+            if(node.settingsTimestamp === undefined || node.settingsTimestamp === 0){
+                console.log("settingstimestamp = 0. No settings to retrieve");
+                return;
+            }
+
+            // if "settingsTimestamp" is not "0", retieve the settings.
+            console.log("settingstimestamp != 0. Load settings");
+            getNodeSettings(node.id, settings => {
+                //console.log("settings retrieved: " + JSON.stringify(settings, null, 2));
+                // if the settings is undefined, it means that the node has not been persisted yet.
+                if(settings === undefined){
+                    console.log("no settings retrieved");
+                    return;
+                }
+
+                console.log("Settings timestamp: " + settings.settingsTimestamp);
+                console.log("Node timestamp: " + node.settingsTimestamp);
+
+                if(settings.settingsTimestamp !== node.settingsTimestamp){
+                    // if "settingsTimestamp" is different than the one that was returned by getSettings(), 
+                    // then dont replace the current values with settings.
+                    console.log("config timestamp different than settings timestamp. no update")
+                    return;
+                }
+
+                // TODO:
+                // if "settingsTimestamp" is the same as the one returned by getSettings(), then replace the config values with those from settings.
+                console.log("Replacing Settings");
+
+                // go through the defaults and find the elements and their types that are assigned to them.
+                let inputValueSetters = {
+                    "text" : (input, value) => { input.val(value) },
+                    "number" : (input, value) => { input.val(value) },
+                    "select-one" : (input, value) => { input.val(value) },
+                    "hidden" : (input, value) => { input.val(value) },
+                    "checkbox" : (input, value) => { input.val(value).prop("checked", value).trigger('change') },
+                    // todo: add the other types of inputs here.
+                };
+
+                let prefix = (node._def.category === "config") ? "#node-config-input-" : "#node-input-";
+                Object.keys(node._def.defaults)
+                    .filter(entry => settings.hasOwnProperty(entry))
+                    .forEach(entry => {
+                    try{
+                        // get the field.
+                        let field = $(prefix + entry);
+
+                        if(!field[0]){
+                            console.log("field " + (prefix + entry) + "[0] not found");
+                            return;
+                        }
+
+                        // get the setter for the field.
+                        let setValue = inputValueSetters[field[0].type];
+                        if(setValue){
+                            try{
+                                //console.log("setting " + prefix + entry + " to " + settings[entry]);
+                                setValue(field, settings[entry]);
+                            }
+                            catch(error){
+                                console.log(error);
+                            }
+                        }
+                        else{
+                            console.log("no setter for type: " + field[0].type + " (" + entry + ")")
+                        }
+                    }
+                    catch(error){
+                        console.log(error);
+                    }
+                })
+                return;
+            });
+        }
+    </script>    
+</div>
+
+<script type="text/javascript" template-section="onIncludeEditPrepare">
+    handleNodeSettings(node);
+</script>
+
+<script type="text/javascript" template-section="onIncludeEditSave">
+    // set the value for "settingsTimestamp" to now() - this will ensure that values are not overwritten if the editor is opened again before a deploy.
+
+    // NOTE on ONDEPLOY on the server side: 
+    // when the deployment is being done and there are no settings, then this is a first deployment. Do the intialization and persist to settings (remember to include 'settingsTimestamp')
+    // when the deployment is being done and 'settingsTimestamp' from config is the same as 'settingsTimestamp' from settings, then nothing actually changed. its a redeployment
+    // when the deployment is being done and 'settingsTimestamp' from config is different from 'settingsTimestamp' from settings then its an update. (save to settings + include settingsTimestap)
+    $("#node-config-input-settingsTimestamp").val(new Date().getTime());
+    $("#node-input-settingsTimestamp").val(new Date().getTime());
+</script>
+
+<script type="text/html" template-section="onIncludeEditForm">
+    <input type="hidden" id="node-config-input-settingsTimestamp" />
+    <input type="hidden" id="node-input-settingsTimestamp" />
+</script>
+
+<script type="text/markdown" template-section="onIncludeDocumentation">
+
+</script>

package/src/core/other/template/SettingsTemplate.ts

@@ -0,0 +1,17 @@
+import { NodeAPI, NodeAPISettingsWithData } from "node-red"
+import { BaseNode, BaseNodeConfig, NodeManager, Template, TemplateDescriptor } from "../../NodeConstructor"
+import { SourceUtility } from "../../NodeGenerator";
+
+export class SettingsTemplate extends Template {
+
+
+    
+    public static getTemplateDescriptor(): TemplateDescriptor {
+        return new TemplateDescriptor(
+            "settings", 
+            SettingsTemplate, 
+            SourceUtility.getSourcePath("/build/", "/src/") + "SettingsTemplate.html",
+            []
+        );    
+    }
+}

package/src/core/tagging/NodeDescriptionDecorator.ts

@@ -0,0 +1,39 @@
+import { NodeDependencyType, NodeDescriptor, TemplateConfig } from "../NodeConstructor";
+import { ITemplateClass } from "../NodeGenerator";
+
+export type NodeDescriptionConfig = {
+    id: string;
+    name:string,
+    group: string;
+    sourceFile: string;
+    package: string;
+    templates?: {template:ITemplateClass, config:TemplateConfig}[];
+    dependencies?: NodeDependencyType[];
+    tags?:string[];
+}
+
+export function NodeDescription(config:NodeDescriptionConfig) {
+    return function(target: any) {
+        let descriptor:NodeDescriptor = new NodeDescriptor(config.group, config.id, config.sourceFile, config.package);
+        
+        if(config.templates){
+            for(let template of config.templates){
+                descriptor.addTemplate(template.template, template.config);
+            }
+        }
+
+        if(config.tags){
+            for(let tag of config.tags){
+                descriptor.addTag(tag);
+            }
+        }
+
+        if(config.dependencies){
+            for(let dependency of config.dependencies){
+                descriptor.addDependency(dependency);
+            }
+        }
+
+        target.getNodeDescriptor = (): NodeDescriptor => descriptor;
+    };
+}

package/src/core/tagging/service/NodeTypeService.ts

@@ -0,0 +1,67 @@
+import { INodeClass } from "../../NodeGenerator";
+import { BaseService, ConfigNode, FlowDeployment, ServiceDescriptor } from "../../NodeConstructor";
+import { NodeAPI, NodeAPISettingsWithData } from "node-red";
+
+
+export class NodeTypeService extends BaseService {
+    private red!: NodeAPI<NodeAPISettingsWithData>;
+    private nodeTypes:{[key:string]:INodeClass[]} = {};
+
+    constructor(){
+        super("nodetypes")
+    }
+
+    public init(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void> {
+        this.red = red;
+
+        // update the config/
+        this.red.httpAdmin.get("/nodetypeservice/find", this.red.auth.needsPermission("inject.write"), (request,response) => {
+            let tag = request.query.tag as string;
+
+            // serialize the types to a javascript friendly format
+            let types = this.getNodeTypesForTag(tag).map( type => {
+                let description = type.getNodeDescriptor();
+                return {
+                    "id": description.name(),
+                    "name": description.name(),
+                };
+            })
+
+            response.send(types);
+        });
+
+        return Promise.resolve();
+    }
+
+    public deinit(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void> {
+        return Promise.resolve();
+    }
+
+    public onDeploy(flowDeployment: FlowDeployment): void | Promise<void> {
+        
+    }
+
+    public registerNodeType(tag:string, resource: INodeClass): Promise<void> {
+        let nodes = this.nodeTypes[tag];
+        if(!nodes){
+            this.nodeTypes[tag] = nodes = [];
+        }
+        nodes.push(resource);
+        return Promise.resolve();
+    }
+
+    public getNodeTypesForTag(tag:string):INodeClass[] {
+        return this.nodeTypes[tag] ? this.nodeTypes[tag] : [];
+    }
+
+    static override getServiceDescriptor():ServiceDescriptor {
+        return new ServiceDescriptor(
+            "@theotherwillembotha/nodetypeservice",
+            "NodeTypeService",
+            "services-plugin",
+            "@theotherwillembotha/node-red-plugincore",
+            NodeTypeService,
+            []
+        );
+    }
+}