Add nanoflow support

Author: Stanley-Okwii

src/MicroflowTimer/MicroflowTimer.xml

@@ -2,17 +2,13 @@
 <widget id="MicroflowTimer.widget.MicroflowTimer" needsEntityContext="true" xmlns="http://www.mendix.com/widget/1.0/">
     <name>MicroflowTimer</name>
     <description>The description of this widget.</description>
-
     <icon></icon>
 
     <properties>
         <property key="interval" type="integer" defaultValue="30000">
             <caption>Interval (in ms)</caption>
             <category>Behavior</category>
-            <description>
-                Defines how often the microflow is called. Note that the inteval is in milliseconds, so the default, 30000, equals 30 seconds. Note that, unless Execute Once is set to true, the microflow is invoked immediately after loading the form for the first
-                time.
-            </description>
+            <description>Defines how often the microflow is called. Note that the inteval is in milliseconds, so the default, 30000, equals 30 seconds. Note that, unless Execute Once is set to true, the microflow is invoked immediately after loading the form for the first time. </description>
         </property>
         <property key="once" type="boolean" defaultValue="false">
             <caption>Execute once</caption>
@@ -24,12 +20,27 @@
             <category>Behavior</category>
             <description>If true (and execute once is false), the microflow will be invoked the first time if the widget has loaded. If false, the microflow will be invoked the first time after interval has passed.</description>
         </property>
-        <property key="microflow" type="microflow" required="true">
+        <property key="callEvent" type="enumeration" defaultValue="callMicroflow">
+            <caption>Call event</caption>
+            <category>Behavior</category>
+            <description/>
+            <enumerationValues>
+                <enumerationValue key="callMicroflow">Call a microflow</enumerationValue>
+                <enumerationValue key="callNanoflow">Call a nanoflow</enumerationValue>
+            </enumerationValues>
+        </property>
+        <property key="microflow" type="microflow" required="false">
             <caption>Microflow</caption>
             <category>Behavior</category>
             <description>The microflow to be executed. If the microflow returns false, it will not be executed any longer until the context changes.</description>
             <returnType type="Boolean"/>
         </property>
+        <property key="nanoflow" type="nanoflow" required="false">
+            <caption>Nanoflow</caption>
+            <category>Behavior</category>
+            <description>The nanoflow to be executed. If the nanoflow returns false, it will not be executed any longer until the context changes.</description>
+            <returnType type="Boolean"/>
+        </property>
         <property key="firstIntervalAttr" type="attribute" required="false">
             <caption>First tick delay</caption>
             <category>Context</category>

src/MicroflowTimer/widget/MicroflowTimer.js

@@ -12,7 +12,9 @@ define([
         interval: 30000,
         once: false,
         startatonce: true,
+        callEvent: null,
         microflow: "",
+        nanoflow: "",
         firstIntervalAttr: null,
         intervalAttr: null,
         timerStatusAttr: null,
@@ -113,33 +115,33 @@ define([
 
         _runTimer: function() {
             logger.debug(this.id + "._runTimer", this.interval);
-            if (this.microflow !== "" && this._contextObj) {
+            if (this.callEvent !== "" && this._contextObj) {
                 this._timerStarted = true;
 
                 //if there's a first interval, get and use that first, then use the regular interval
                 if (this.firstIntervalAttr) {
                     var firstInterval = this._contextObj.get(this.firstIntervalAttr);
 
                     if (this.once) {
-                        this._timeout = setTimeout(lang.hitch(this, this._execMf), firstInterval);
+                        this._timeout = setTimeout(lang.hitch(this, this._executeEvent), firstInterval);
                     } else {
                         if (this.startatonce) {
-                            this._execMf();
+                            this._executeEvent();
                         }
                         this._timeout = setTimeout(lang.hitch(this, function() {
-                            this._execMf();
-                            this._timer = setInterval(lang.hitch(this, this._execMf), this.interval);
+                            this._executeEvent();
+                            this._timer = setInterval(lang.hitch(this, this._executeEvent), this.interval);
                         }), firstInterval);
                     }
                     //otherwise just use the regulat interval
                 } else {
                     if (this.once) {
-                        this._timeout = setTimeout(lang.hitch(this, this._execMf), this.interval);
+                        this._timeout = setTimeout(lang.hitch(this, this._executeEvent), this.interval);
                     } else {
                         if (this.startatonce) {
-                            this._execMf();
+                            this._executeEvent();
                         }
-                        this._timer = setInterval(lang.hitch(this, this._execMf), this.interval);
+                        this._timer = setInterval(lang.hitch(this, this._executeEvent), this.interval);
                     }
                 }
             }
@@ -161,6 +163,14 @@ define([
             }
         },
 
+        _executeEvent: function() {
+            if(this.callEvent == "callMicroflow") {
+                this._execMf()
+            } else {
+                this._executeNanoFlow()
+            }
+        },
+
         _execMf: function() {
             logger.debug(this.id + "._execMf");
             if (!this._contextObj) {
@@ -197,6 +207,30 @@ define([
             }
         },
 
+        _executeNanoFlow: function() {
+            logger.debug(this.id + "._executeNanoFlow");
+            if (!this._contextObj) {
+                return;
+            }
+
+            if (this.nanoflow.nanoflow) {
+                mx.data.callNanoflow({
+                    nanoflow: this.nanoflow,
+                    origin: this.mxform,
+                    context: this.mxcontext,
+                    callback: lang.hitch(this, function(result) {
+                        if (!result) {
+                            logger.debug(this.id + "._executeNanoFlow callback, stopping timer");
+                            this._stopTimer();
+                        }
+                    }),
+                    error: lang.hitch(this, function(error) {
+                        logger.error(this.id + ": An error ocurred while executing nanoflow: ", error);
+                    })
+                });
+            }
+        },
+
         // Reset subscriptions.
         _resetSubscriptions: function() {
             // Release handles on previous object, if any.