@steedos/service-package-registry 2.1.10 → 2.1.14

package/main/default/manager/registry.js

@@ -1,4 +1,4 @@
-const {exec,log,events} = require("@node-red/util");
+const {exec,log,events} = require("../util");
 const child_process = require('child_process');
 const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm'; 
 const yarnCommand = process.platform === 'win32' ? 'yarn.cmd' : 'yarn';  

package/main/default/objects/steedos_packages/buttons/install_purchased_packages.button.js

@@ -1,56 +1,66 @@
 module.exports = {
     install_purchased_packages: function (object_name, record_id) {
-        const purchasedPackages = Steedos.authRequest(Steedos.absoluteUrl('service/api/~packages-project-server/cloud/saas/packages/purchased'), {async: false, type: 'get'});
-        if(purchasedPackages && purchasedPackages.length === 0){
+        const result = Steedos.authRequest(Steedos.absoluteUrl('service/api/~packages-project-server/cloud/saas/packages/purchased'), {async: false, type: 'get'});
+        if(result && result.packages.length === 0){
             return toastr.info('您还未购买任何软件包')
         }else{
+            toastr.info('安装中，请稍后...', '', {
+                timeOut: 0,
+                progressBar: true,
+            })
             Steedos.authRequest(Steedos.absoluteUrl('service/api/~packages-project-server/cloud/saas/packages/purchased'), {type: 'post', error: function(XMLHttpRequest, textStatus, errorThrown){
-                console.error(XMLHttpRequest.responseJSON);
+                toastr.clear()
                 if (XMLHttpRequest.responseJSON && XMLHttpRequest.responseJSON.error) {
-                    try {
-                        const installErrors = JSON.parse(XMLHttpRequest.responseJSON.error);
-                        let errorsHtml = '';
-                        let index = 0;
-                        _.each(installErrors, function(v, k){
-                            index ++ 
-                            errorsHtml = `${errorsHtml}<li class="py-4">
-                            <div class="flex space-x-3">
-                              <div class="flex-1 space-y-1">
-                                <div class="flex items-center justify-between">
-                                  <h3 class="text-sm font-medium"><b>${k}</b></h3>
-                                  <p class="text-sm text-gray-500"><span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-pink-100 text-pink-800">
-                                  Error ${index}
-                                </span></p>
-                                </div>
-                                <p class="text-sm text-gray-500">${v}</p>
-                              </div>
+                    toastr.error(XMLHttpRequest.responseJSON.error)
+                }
+                else {
+                    toastr.error(XMLHttpRequest.responseJSON)
+                }
+            },
+            success: function(result){
+                try {
+                    toastr.clear()
+                    const installErrors = result.installErrors;
+                    let errorsHtml = '';
+                    let index = 0;
+                    _.each(installErrors, function(v, k){
+                        index ++ 
+                        errorsHtml = `${errorsHtml}<li class="py-4">
+                        <div class="flex space-x-3">
+                          <div class="flex-1 space-y-1">
+                            <div class="flex items-center justify-between">
+                              <h3 class="text-sm font-medium"><b>${k}</b></h3>
+                              <p class="text-sm text-gray-500"><span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-pink-100 text-pink-800">
+                              Error ${index}
+                            </span></p>
                             </div>
-                          </li>`
-                        })
+                            <p class="text-sm text-gray-500">${v}</p>
+                          </div>
+                        </div>
+                      </li>`
+                    })
+                    if(!_.isEmpty(installErrors)){
                         swal({
                             title: "安装软件包异常",
                             text: `<div>
                             <ul role="list" class="divide-y divide-gray-200">
                             ${errorsHtml}
                             </ul>
-                          </div>`,
+                        </div>`,
                             html: true,
                             showCancelButton: false,
                             closeOnConfirm: false,
                             cancelButtonText: t('Cancel'),
                             confirmButtonText: t('OK')
                         });
-                    } catch (error) {
-                        toastr.error(XMLHttpRequest.responseJSON.error)
+                    }else{
+                        toastr.success('安装完成')
                     }
+                    FlowRouter.reload();
+                } catch (error) {
+                    toastr.error(XMLHttpRequest.responseJSON.error)
                 }
-                else {
-                    toastr.error(XMLHttpRequest.responseJSON)
-                }
-            },
-            success: function(){
-                toastr.info('安装完成')
-                FlowRouter.reload();
+                
             }
             });
         }

package/main/default/objects/steedos_packages/buttons/uninstall.button.js

@@ -19,7 +19,7 @@ module.exports = {
                     success: function(){
                         setTimeout(function(){
                             if(record_id){
-                                SteedosUI.reloadRecord(object_name, record_id)
+                                return FlowRouter.go("/app/admin/steedos_packages/grid/all")
                             }
                             toastr.clear();
                             toastr.success('已卸载');

package/main/default/objects/steedos_packages/fields/metadata.$.type.field.yml

@@ -40,4 +40,6 @@ options:
   - label: 图表
     value: Chart
   - label: 页面
-    value: Page
+    value: Page
+  - label: 选项卡
+    value: Tab

package/main/default/util/events.js

@@ -0,0 +1,73 @@
+/*!
+ * 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.
+ **/
+
+ /**
+  * Runtime events
+  * @mixin @node-red/util_events
+  */
+
+const events = new (require("events")).EventEmitter();
+
+
+const deprecatedEvents = {
+    "nodes-stopped": "flows:stopped",
+    "nodes-started": "flows:started"
+}
+
+function wrapEventFunction(obj,func) {
+    events["_"+func] = events[func];
+    return function(eventName, listener) {
+        if (deprecatedEvents.hasOwnProperty(eventName)) {
+            const log = require("@node-red/util").log;
+            const stack = (new Error().stack).split("\n")[2].split("(")[1].slice(0,-1);
+            log.warn(`[RED.events] Deprecated use of "${eventName}" event from "${stack}". Use "${deprecatedEvents[eventName]}" instead.`)
+        }
+        return events["_"+func].call(events,eventName,listener)
+    }
+}
+
+
+events.on = wrapEventFunction(events,"on");
+events.once = wrapEventFunction(events,"once");
+events.addListener = events.on;
+
+
+
+module.exports = events;
+
+/**
+ * Runtime events emitter
+ * @mixin @node-red/util_events
+ */
+
+/**
+ * Register an event listener for a runtime event
+ * @name on
+ * @function
+ * @memberof @node-red/util_events
+ * @param {String} eventName - the name of the event to listen to
+ * @param {Function} listener - the callback function for the event
+ */
+
+ /**
+  * Emit an event to all of its registered listeners
+  * @name emit
+  * @function
+  * @memberof @node-red/util_events
+  * @param {String} eventName - the name of the event to emit
+  * @param {any} ...args - the arguments to pass in the event
+  * @return {Boolean} - whether the event had listeners or not
+  */

package/main/default/util/exec.js

@@ -0,0 +1,91 @@
+/*!
+ * 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.
+ **/
+
+/**
+ * Run system commands with event-log integration
+ * @mixin @node-red/util_exec
+ */
+
+const child_process = require('child_process');
+const events = require("./events");
+const util = require('./util');
+
+function logLines(id,type,data) {
+    events.emit("event-log", {id:id,payload:{ts: Date.now(),data:data,type:type}});
+}
+
+module.exports = {
+    /**
+     * Run a system command with stdout/err being emitted as 'event-log' events
+     * on the @node-red/util/events handler.
+     *
+     * The main arguments to this function are the same as passed to `child_process.spawn`
+     *
+     * @param {String} command - the command to run
+     * @param {Array}  args - arguments for the command
+     * @param {Object} options - options to pass child_process.spawn
+     * @param {Boolean} emit - whether to emit events to the event-log for each line of stdout/err
+     * @return {Promise} A promise that resolves (rc=0) or rejects (rc!=0) when the command completes. The value
+     *                   of the promise is an object of the form:
+     *
+     *       {
+     *           code: <exit code>,
+     *           stdout: <standard output from the command>,
+     *           stderr: <standard error from the command>
+     *       }
+
+     * @memberof @node-red/util_exec
+     */
+    run: function(command,args,options,emit) {
+        var invocationId = util.generateId();
+
+        emit && events.emit("event-log", {ts: Date.now(),id:invocationId,payload:{ts: Date.now(),data:command+" "+args.join(" ")}});
+
+        return new Promise((resolve, reject) => {
+            let stdout = "";
+            let stderr = "";
+            const child = child_process.spawn(command,args,options);
+            child.stdout.on('data', (data) => {
+                const str = ""+data;
+                stdout += str;
+                emit && logLines(invocationId,"out",str);
+            });
+            child.stderr.on('data', (data) => {
+                const str = ""+data;
+                stderr += str;
+                emit && logLines(invocationId,"err",str);
+            });
+            child.on('error', function(err) {
+                stderr = err.toString();
+                emit && logLines(invocationId,"err",stderr);
+            })
+            child.on('close', (code) => {
+                let result = {
+                    code: code,
+                    stdout: stdout,
+                    stderr: stderr
+                }
+                emit && events.emit("event-log", {id:invocationId,payload:{ts: Date.now(),data:"rc="+code}});
+
+                if (code === 0) {
+                    resolve(result)
+                } else {
+                    reject(result);
+                }
+            });
+        })
+    }
+}

package/main/default/util/hooks.js

@@ -0,0 +1,243 @@
+const Log = require("./log.js");
+
+const VALID_HOOKS = [
+    // Message Routing Path
+   "onSend",
+   "preRoute",
+   "preDeliver",
+   "postDeliver",
+   "onReceive",
+   "postReceive",
+   "onComplete",
+   // Module install hooks
+   "preInstall",
+   "postInstall",
+   "preUninstall",
+   "postUninstall"
+]
+
+
+// Flags for what hooks have handlers registered
+let states = { }
+
+// Doubly-LinkedList of hooks by id.
+// - hooks[id] points to head of list
+// - each list item looks like:
+//   {
+//       cb: the callback function
+//       location: filename/line of code that added the hook
+//       previousHook: reference to previous hook in list
+//       nextHook: reference to next hook in list
+//       removed: a flag that is set if the item was removed
+//   }
+let hooks = { }
+
+// Hooks by label
+let labelledHooks = { }
+
+/**
+ * Runtime hooks engine
+ *
+ * The following hooks can be used:
+ *
+ * Message sending
+ *  - `onSend` - passed an array of `SendEvent` objects. The messages inside these objects are exactly what the node has passed to `node.send` - meaning there could be duplicate references to the same message object.
+ *  - `preRoute` - passed a `SendEvent`
+ *  - `preDeliver` - passed a `SendEvent`. The local router has identified the node it is going to send to. At this point, the message has been cloned if needed.
+ *  - `postDeliver` - passed a `SendEvent`. The message has been dispatched to be delivered asynchronously (unless the sync delivery flag is set, in which case it would be continue as synchronous delivery)
+ *  - `onReceive` - passed a `ReceiveEvent` when a node is about to receive a message
+ *  - `postReceive` - passed a `ReceiveEvent` when the message has been given to the node's `input` handler(s)
+ *  - `onComplete` - passed a `CompleteEvent` when the node has completed with a message or logged an error
+ *
+ * @mixin @node-red/util_hooks
+ */
+
+/**
+ * Register a handler to a named hook
+ * @memberof @node-red/util_hooks
+ * @param {String} hookId - the name of the hook to attach to
+ * @param {Function} callback - the callback function for the hook
+ */
+function add(hookId, callback) {
+    let [id, label] = hookId.split(".");
+    if (VALID_HOOKS.indexOf(id) === -1) {
+        throw new Error(`Invalid hook '${id}'`);
+    }
+    if (label && labelledHooks[label] && labelledHooks[label][id]) {
+        throw new Error("Hook "+hookId+" already registered")
+    }
+    // Get location of calling code
+    const stack = new Error().stack;
+    const callModule = stack.split("\n")[2].split("(")[1].slice(0,-1);
+    Log.debug(`Adding hook '${hookId}' from ${callModule}`);
+
+    const hookItem = {cb:callback, location: callModule, previousHook: null, nextHook: null }
+
+    let tailItem = hooks[id];
+    if (tailItem === undefined) {
+        hooks[id] = hookItem;
+    } else {
+        while(tailItem.nextHook !== null) {
+            tailItem = tailItem.nextHook
+        }
+        tailItem.nextHook = hookItem;
+        hookItem.previousHook = tailItem;
+    }
+
+    if (label) {
+        labelledHooks[label] = labelledHooks[label]||{};
+        labelledHooks[label][id] = hookItem;
+    }
+
+    // TODO: get rid of this;
+    states[id] = true;
+}
+
+/**
+ * Remove a handled from a named hook
+ * @memberof @node-red/util_hooks
+ * @param {String} hookId - the name of the hook event to remove - must be `name.label`
+ */
+function remove(hookId) {
+    let [id,label] = hookId.split(".");
+    if ( !label) {
+        throw new Error("Cannot remove hook without label: "+hookId)
+    }
+    Log.debug(`Removing hook '${hookId}'`);
+    if (labelledHooks[label]) {
+        if (id === "*") {
+            // Remove all hooks for this label
+            let hookList = Object.keys(labelledHooks[label]);
+            for (let i=0;i<hookList.length;i++) {
+                removeHook(hookList[i],labelledHooks[label][hookList[i]])
+            }
+            delete labelledHooks[label];
+        } else if (labelledHooks[label][id]) {
+            removeHook(id,labelledHooks[label][id])
+            delete labelledHooks[label][id];
+            if (Object.keys(labelledHooks[label]).length === 0){
+                delete labelledHooks[label];
+            }
+        }
+    }
+}
+
+function removeHook(id,hookItem) {
+    let previousHook = hookItem.previousHook;
+    let nextHook = hookItem.nextHook;
+
+    if (previousHook) {
+        previousHook.nextHook = nextHook;
+    } else {
+        hooks[id] = nextHook;
+    }
+    if (nextHook) {
+        nextHook.previousHook = previousHook;
+    }
+    hookItem.removed = true;
+    if (!previousHook && !nextHook) {
+        delete hooks[id];
+        delete states[id];
+    }
+}
+
+
+function trigger(hookId, payload, done) {
+    let hookItem = hooks[hookId];
+    if (!hookItem) {
+        if (done) {
+            done();
+            return;
+        } else {
+            return Promise.resolve();
+        }
+    }
+    if (!done) {
+        return new Promise((resolve,reject) => {
+            invokeStack(hookItem,payload,function(err) {
+                if (err !== undefined && err !== false) {
+                    if (!(err instanceof Error)) {
+                        err = new Error(err);
+                    }
+                    err.hook = hookId
+                    reject(err);
+                } else {
+                    resolve(err);
+                }
+            })
+        });
+    } else {
+        invokeStack(hookItem,payload,done)
+    }
+}
+function invokeStack(hookItem,payload,done) {
+    function callNextHook(err) {
+        if (!hookItem || err) {
+            done(err);
+            return;
+        }
+        if (hookItem.removed) {
+            hookItem = hookItem.nextHook;
+            callNextHook();
+            return;
+        }
+        const callback = hookItem.cb;
+        if (callback.length === 1) {
+            try {
+                let result = callback(payload);
+                if (result === false) {
+                    // Halting the flow
+                    done(false);
+                    return
+                }
+                if (result && typeof result.then === 'function') {
+                    result.then(handleResolve, callNextHook)
+                    return;
+                }
+                hookItem = hookItem.nextHook;
+                callNextHook();
+            } catch(err) {
+                done(err);
+                return;
+            }
+        } else {
+            try {
+                callback(payload,handleResolve)
+            } catch(err) {
+                done(err);
+                return;
+            }
+        }
+    }
+    function handleResolve(result) {
+        if (result === undefined) {
+            hookItem = hookItem.nextHook;
+            callNextHook();
+        } else {
+            done(result);
+        }
+    }
+    callNextHook();
+}
+
+function clear() {
+    hooks = {}
+    labelledHooks = {}
+    states = {}
+}
+
+function has(hookId) {
+    let [id, label] = hookId.split(".");
+    if (label) {
+        return !!(labelledHooks[label] && labelledHooks[label][id])
+    }
+    return !!states[id]
+}
+
+module.exports = {
+    has,
+    clear,
+    add,
+    remove,
+    trigger
+}