@gregoriusrippenstein/node-red-contrib-nodedev 0.0.6

package/nodes/20-pkg-file.html

@@ -0,0 +1,135 @@
+<script type="text/html" data-template-name="PkgFile">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <div style="display: inline-block; width: calc(100% - 105px)"><input type="text" id="node-input-name" placeholder="Name"></div>
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-filename"><i class="fa fa-tag"></i> Filename</label>
+        <div style="display: inline-block; width: calc(100% - 105px)"><input type="text" id="node-input-filename" placeholder="dir1/dir2/file.txt"></div>
+    </div>
+
+    <div class="form-row" style="position: relative; margin-bottom: 0px;">
+        <label for="node-input-template"><i class="fa fa-file-code-o"></i> Template</span></label>
+        <input type="hidden" id="node-input-template" autofocus="autofocus">
+        <div style="position: absolute; right:0;display:inline-block; text-align: right; font-size: 0.8em;">
+            Syntax:
+            <select id="node-input-format" style="width:110px; font-size: 10px !important;  height: 24px; padding:0;">
+                <option value="handlebars">mustache</option>
+                <option value="html">HTML</option>
+                <option value="json">JSON</option>
+                <option value="javascript">JavaScript</option>
+                <option value="css">CSS</option>
+                <option value="markdown">Markdown</option>
+                <option value="php">PHP</option>
+                <option value="python">Python</option>
+                <option value="sql">SQL</option>
+                <option value="yaml">YAML</option>
+                <option value="base64">Base64</option>
+                <option value="text">Text</option>
+            </select>
+            <button type="button" id="node-pkgfile-expand-editor" class="red-ui-button red-ui-button-small"><i class="fa fa-expand"></i></button>
+        </div>
+    </div>
+
+    <div class="form-row node-text-editor-row">
+        <div style="height: 250px; min-height:150px;" class="node-text-editor" id="node-input-pkgfile-editor" ></div>
+    </div>
+    
+    <div class="form-row">
+        <label for="node-input-syntax"><i class="fa fa-code"></i> Syntax</label>
+        <select id="node-input-syntax" style="width:180px;">
+            <option value="mustache">Mustache</option>
+            <option value="plain">Plain</option>
+        </select>
+    </div>
+
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('PkgFile',{
+        color:"#e5e4ef",
+        category: 'nodedev',
+        defaults: {
+            name: {value:""},
+            filename: { value: ""},
+            format: {value:"handlebars"},
+            syntax: {value:"mustache"},
+            template: {value:""},
+            output: {value:"str"},
+        },
+        inputs:1,
+        outputs:1,
+        icon: "font-awesome/fa-file-o",
+        label: function() {
+            return this.name || this.filename || this._def.paletteLabel;
+        },
+        labelStyle: function() {
+            return this.name?"node_label_italic":"";
+        },
+        oneditprepare: function() {
+            const that = this;
+            const stateId = RED.editor.generateViewStateId("node", this, "");
+
+            if (!this.syntax) {
+                this.syntax = 'mustache';
+                $("#node-input-syntax").val(this.syntax);
+            }
+
+            this.editor = RED.editor.createEditor({
+                id: 'node-input-pkgfile-editor',
+                mode: 'ace/mode/html',
+                stateId: stateId,
+                value: $("#node-input-template").val()
+            });
+
+            $("#node-input-format").on("change", function() {
+                var mod = "ace/mode/"+$("#node-input-format").val();
+                that.editor.getSession().setMode({
+                    path: mod,
+                    v: Date.now()
+                });
+            });
+            RED.popover.tooltip($("#node-pkgfile-expand-editor"), RED._("node-red:common.label.expand"));
+            $("#node-pkgfile-expand-editor").on("click", function (e) {
+                e.preventDefault();
+                const value = that.editor.getValue();
+                that.editor.saveView();
+                RED.editor.editText({
+                    mode: $("#node-input-format").val(),
+                    value: value,
+                    stateId: stateId,
+                    width: "Infinity",
+                    focus: true,
+                    complete: function (v, cursor) {
+                        that.editor.setValue(v, -1);
+                        setTimeout(function () {
+                            that.editor.restoreView();
+                            that.editor.focus();
+                        }, 250);
+                    }
+                })
+            })
+        },
+        oneditsave: function() {
+            $("#node-input-template").val(this.editor.getValue());
+            this.editor.destroy();
+            delete this.editor;
+        },
+        oneditcancel: function() {
+            this.editor.destroy();
+            delete this.editor;
+        },
+        oneditresize: function(size) {
+            var rows = $("#dialog-form>div:not(.node-text-editor-row)");
+            var height = $("#dialog-form").height();
+            for (var i=0; i<rows.length; i++) {
+                height -= $(rows[i]).outerHeight(true);
+            }
+            var editorRow = $("#dialog-form>div.node-text-editor-row");
+            height -= (parseInt(editorRow.css("marginTop"))+parseInt(editorRow.css("marginBottom")));
+            $("#dialog-form .node-text-editor").css("height",height+"px");
+            this.editor.resize();
+        }
+    });
+</script>

package/nodes/20-pkg-file.js

@@ -0,0 +1,209 @@
+/**
+ * Copyright JS Foundation and other contributors, http://js.foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ **/
+
+module.exports = function (RED) {
+    "use strict";
+    var mustache = require("mustache");
+
+    function extractTokens(tokens, set) {
+        set = set || new Set();
+        tokens.forEach(function (token) {
+            if (token[0] !== 'text') {
+                set.add(token[1]);
+                if (token.length > 4) {
+                    extractTokens(token[4], set);
+                }
+            }
+        });
+        return set;
+    }
+
+    function parseContext(key) {
+        var match = /^(flow|global)(\[(\w+)\])?\.(.+)/.exec(key);
+        if (match) {
+            var parts = {};
+            parts.type = match[1];
+            parts.store = (match[3] === '') ? "default" : match[3];
+            parts.field = match[4];
+            return parts;
+        }
+        return undefined;
+    }
+
+    function parseEnv(key) {
+        var match = /^env\.(.+)/.exec(key);
+        if (match) {
+            return match[1];
+        }
+        return undefined;
+    }
+
+    /**
+     * Custom Mustache Context capable to collect message property and node
+     * flow and global context
+     */
+
+    function NodeContext(msg, nodeContext, parent, escapeStrings, cachedContextTokens) {
+        this.msgContext = new mustache.Context(msg, parent);
+        this.nodeContext = nodeContext;
+        this.escapeStrings = escapeStrings;
+        this.cachedContextTokens = cachedContextTokens;
+    }
+
+    NodeContext.prototype = new mustache.Context();
+
+    NodeContext.prototype.lookup = function (name) {
+        // try message first:
+        try {
+            var value = this.msgContext.lookup(name);
+            if (value !== undefined) {
+                if (this.escapeStrings && typeof value === "string") {
+                    value = value.replace(/\\/g, "\\\\");
+                    value = value.replace(/\n/g, "\\n");
+                    value = value.replace(/\t/g, "\\t");
+                    value = value.replace(/\r/g, "\\r");
+                    value = value.replace(/\f/g, "\\f");
+                    value = value.replace(/[\b]/g, "\\b");
+                }
+                return value;
+            }
+
+            // try env
+            if (parseEnv(name)) {
+                return this.cachedContextTokens[name];
+            }
+
+            // try flow/global context:
+            var context = parseContext(name);
+            if (context) {
+                var type = context.type;
+                var store = context.store;
+                var field = context.field;
+                var target = this.nodeContext[type];
+                if (target) {
+                    return this.cachedContextTokens[name];
+                }
+            }
+            return '';
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+
+    NodeContext.prototype.push = function push(view) {
+        return new NodeContext(view, this.nodeContext, this.msgContext, undefined, this.cachedContextTokens);
+    };
+
+    function PkgFileNode(n) {
+        RED.nodes.createNode(this, n);
+        this.name = n.name;
+        this.filename = n.filename;
+        this.template = n.template;
+        this.format = n.format;
+        this.syntax = n.syntax || "mustache";
+        this.outputFormat = "str";
+
+        var node = this;
+
+        function output(nde, msg, value, send, done) {
+            if (!Array.isArray(msg.contents)) {
+                RED.util.setMessageProperty(msg, "contents", []);
+            }
+
+            msg.contents.push({
+                type: nde.format,
+                name: nde.filename,
+                contents: value
+            })
+
+            send(msg);
+            done();
+        }
+
+
+        node.on("input", function (msg, send, done) {
+
+            try {
+                /***
+                * Allow template contents to be defined externally
+                * through inbound msg.template IFF node.template empty
+                */
+                var template = node.template;
+                if (msg.hasOwnProperty("template")) {
+                    if (template == "" || template === null) {
+                        template = msg.template;
+                    }
+                }
+
+                if (node.syntax === "mustache") {
+                    var is_json = (node.outputFormat === "json");
+                    var promises = [];
+                    var tokens = extractTokens(mustache.parse(template));
+                    var resolvedTokens = {};
+                    tokens.forEach(function (name) {
+                        var env_name = parseEnv(name);
+                        if (env_name) {
+                            var promise = new Promise((resolve, reject) => {
+                                var val = RED.util.evaluateNodeProperty(env_name, 'env', node)
+                                resolvedTokens[name] = val;
+                                resolve();
+                            });
+                            promises.push(promise);
+                            return;
+                        }
+
+                        var context = parseContext(name);
+                        if (context) {
+                            var type = context.type;
+                            var store = context.store;
+                            var field = context.field;
+                            var target = node.context()[type];
+                            if (target) {
+                                var promise = new Promise((resolve, reject) => {
+                                    target.get(field, store, (err, val) => {
+                                        if (err) {
+                                            reject(err);
+                                        } else {
+                                            resolvedTokens[name] = val;
+                                            resolve();
+                                        }
+                                    });
+                                });
+                                promises.push(promise);
+                                return;
+                            }
+                        }
+                    });
+
+                    Promise.all(promises).then(function () {
+                        var value = mustache.render(template, new NodeContext(msg, node.context(), null, is_json, resolvedTokens));
+                        output(node, msg, value, send, done);
+                    }).catch(function (err) {
+                        done(err.message);
+                    });
+                } else {
+                    output(node, msg, template, send, done);
+                }
+            }
+            catch (err) {
+                done(err.message);
+            }
+        });
+    }
+
+    RED.nodes.registerType("PkgFile", PkgFileNode);
+}

package/nodes/30-npm-tarball.html

@@ -0,0 +1,33 @@
+<script type="text/javascript">
+    RED.nodes.registerType('NpmTarBall', {
+        category: 'nodedev',
+        color: "#e5e4ef",
+        defaults: {
+            name: {
+                value: ""
+            }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-birthday-cake",
+        label: function() {
+            return this.name || this._def.paletteLabel;
+        },
+        labelStyle: function() {
+            return this.name?"node_label_italic": "";
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="NpmTarBall">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="node-red:common.label.name"></span></label>
+        <input type="text" id="node-input-name" data-i18n="[placeholder]node-red:common.label.name">
+    </div>
+</script>
+
+<script type="text/html" data-help-name="NpmTarBall">
+    <p>
+        NpmTarballirise msg content.
+    </p>
+</script>

package/nodes/30-npm-tarball.js

@@ -0,0 +1,53 @@
+module.exports = function (RED) {
+    function NpmTarBallFunctionality(config) {
+        RED.nodes.createNode(this, config);
+
+        var node = this;
+        var cfg = config;
+
+        const tarStream = require('tar-stream');
+        const pakoGzip = require('pako')
+
+        node.on('close', function () {
+            node.status({});
+        });
+
+        node.on("input", function (msg, send, done) {
+            const pack = tarStream.pack()
+
+            var buffer = [];
+
+            msg.contents.forEach((elem) => {
+                if (elem.type == "base64") {
+                    pack.entry({ name: "package/" + elem.name }, Buffer.from(elem.contents, 'base64'))
+                } else {
+                    pack.entry({ name: "package/" + elem.name }, elem.contents)
+                }
+            })
+
+            pack.on('end', function () {
+                try {
+                    var buf = Buffer.from(pakoGzip.gzip(Buffer.concat(buffer)))
+                    msg.payload = buf;
+                    send(msg);
+                } catch (ex) {
+                    msg.errors = ex
+                    done("failed to encode buffer", msg)
+                }
+            });
+
+            pack.on('data', function (data) {
+                buffer.push(data)
+            });
+
+            pack.on('error', (err) => {
+                msg.error = err
+                done("tar packing failed", msg)
+            })
+
+            pack.finalize() 
+        });
+    };
+
+    RED.nodes.registerType("NpmTarBall", NpmTarBallFunctionality);
+}

package/nodes/40-node-red-install.html

@@ -0,0 +1,141 @@
+<script type="text/javascript">
+ RED.comms.subscribe('nodedev:node-red-install-perform', (event,data) => {
+   if ( data.msg == "execfunc" ) {
+
+     var doSend = (data, nodeid, _msg) => {
+       if ( typeof data == "object" ) {
+         data = {
+           ..._msg,
+           ...data
+         };
+       }
+
+       $.ajax({
+         url:         "NodeRedInstall/" + nodeid,
+         type:        "POST",
+         contentType: "application/json; charset=utf-8",
+         data: JSON.stringify(data),
+
+         success: function (resp) {
+         },
+
+         error: function (jqXHR, textStatus, errorThrown) {
+           RED.notify("NodeRedInstall Communcation Failure: " +
+                      nodeid + ": " + textStatus, {
+             type: "error",
+             id: nodeid,
+             timeout: 3000
+           });
+         }
+       });
+     };
+
+     var doError = (msg, nodeid, _msg) => {
+       RED.notify("NodeRedInstall Failed: " + nodeid + ": " + msg, {
+         type: "error",
+         id: nodeid,
+         timeout: 3000
+       });
+
+       console.log( "NodeRedInstall: Error with node: " + nodeid + ": " + msg);
+     };
+
+     var nodeid = data.nodeid;
+     var _msg = data._msg;
+
+     var node = {
+       send: (dt) => {
+         doSend(dt, nodeid, _msg)
+       },
+       error: (mg) => {
+         doError(mg, nodeid, _msg)
+       },
+       id: data.nodeid
+     };
+
+     var payload = data.payload;
+     var topic = data.topic;
+
+
+      var f = new File([new Blob([new Uint8Array(payload.data)])], "tarball.tgz", { type: "application/x-gzip" });
+
+      var data = new FormData();
+      data.append("tarball", f);
+      var filename = f.name;
+
+      $.ajax({
+          url: 'nodes',
+          data: data,
+          cache: false,
+          contentType: false,
+          processData: false,
+          method: 'POST',
+      }).always(function (data, textStatus, xhr) {
+      }).success(function() {
+          RED.notify("Installed new package", { type: "success"})
+      }).fail(function (xhr, textStatus, err) {
+          var message = textStatus;
+          if (xhr.responseJSON) {
+              message = xhr.responseJSON.message;
+          }
+          var notification = RED.notify(RED._('palette.editor.errors.installFailed', { module: filename, message: message }), {
+              type: 'error',
+              modal: true,
+              fixed: true,
+              buttons: [
+                  {
+                      text: RED._("common.label.close"),
+                      click: function () {
+                          notification.close();
+                      }
+                  }, {
+                      text: RED._("eventLog.view"),
+                      click: function () {
+                          notification.close();
+                          RED.actions.invoke("core:show-event-log");
+                      }
+                  }
+              ]
+          });
+      })
+
+   }
+ });
+
+  RED.nodes.registerType('NodeRedInstall',{
+    color: '#e5e4ef',
+    icon: "icons/subflow.svg",
+    category: 'nodedev',
+    paletteLabel: 'NRInstall',
+    defaults: {
+      name: {
+        value:"",
+      },
+    },
+    inputs:1,
+    outputs:1,
+
+    label: function() {
+      return (this.name || this._def.paletteLabel);
+    },
+
+    labelStyle: function() {
+      return this.name?"node_label_italic":"";
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="NodeRedInstall">
+    <div class="form-row">
+        <label for="node-input-name">
+          <i class="fa fa-tag"></i>
+          <span data-i18n="common.label.name">Name</span>
+      </label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+</script>
+
+<script type="text/html" data-help-name="NodeRedInstall">
+    <p>Install NPM tarball into Node-RED as new node package.</p>
+    Pass in the results of the NpmTarball node into here and the nodes will be installed into Node-RED.
+</script>

package/nodes/40-node-red-install.js

@@ -0,0 +1,48 @@
+module.exports = function (RED) {
+    function NodeRedInstallFunctionality(config) {
+        RED.nodes.createNode(this, config);
+
+        var node = this;
+        var cfg = config;
+
+        node.on('close', function () {
+            node.status({});
+        });
+
+        node.on("input", function (msg, send, done) {
+            RED.comms.publish(
+                "nodedev:node-red-install-perform",
+                RED.util.encodeObject({
+                    msg: "execfunc",
+                    payload: msg.payload,
+                    topic: msg.topic,
+                    nodeid: node.id,
+                    _msg: msg
+                })
+            );
+        });
+    }
+    RED.nodes.registerType("NodeRedInstall", NodeRedInstallFunctionality);
+
+    RED.httpAdmin.post("/NodeRedInstall/:id",
+        RED.auth.needsPermission("NodeRedInstall.write"),
+        (req, res) => {
+            var node = RED.nodes.getNode(req.params.id);
+            if (node != null) {
+                try {
+                    if (req.body && node.type == "NodeRedInstall") {
+                        node.send(req.body);
+                        res.sendStatus(200);
+                    } else {
+                        res.sendStatus(404);
+                    }
+                } catch (err) {
+                    res.sendStatus(500);
+                    node.error("NodeRedInstall: Submission failed: " +
+                        err.toString())
+                }
+            } else {
+                res.sendStatus(404);
+            }
+        });
+}