@jambonz/node-red-contrib-jambonz 2.3.11 → 2.4.2

package/src/nodes/lcc.js

@@ -1,5 +1,5 @@
 var crypto = require('crypto');
-var {v_resolve, doLCC} = require('./libs')
+var {new_resolve, doLCC} = require('./libs')
 
 module.exports = function(RED) {
 /** LCC */
@@ -13,7 +13,7 @@ function lcc(config) {
 
       const {accountSid, apiToken} = server.credentials;
       const url = server.url;
-      const callSid = v_resolve(config.callSid, config.callSidType, this.context(), msg);
+      const callSid = new_resolve(RED, config.callSid, config.callSidType, node, msg);
       if (!url || !accountSid || !apiToken || !callSid) {
         node.log(`invalid / missing credentials or callSid, skipping LCC node: ${JSON.stringify(server.credentials)}`);
         send(msg);
@@ -45,11 +45,11 @@ function lcc(config) {
           opts.listen_status = 'resume';
           break;
         case 'redirect':
-          opts.call_hook = {url: v_resolve(config.callHook, config.callHookType, this.context(), msg)};
+          opts.call_hook = {url: new_resolve(RED, config.callHook, config.callHookType, node, msg)};
           break;
         case 'hold_conf':
           opts.conf_hold_status = 'hold';
-          opts.wait_hook = {url: v_resolve(config.waitHook, config.waitHookType, this.context(), msg)};
+          opts.wait_hook = {url: new_resolve(RED, config.waitHook, config.waitHookType, node, msg)};
           break;
         case 'unhold_conf':
           opts.conf_hold_status = 'unhold';
@@ -73,8 +73,8 @@ function lcc(config) {
         case 'start_call_recording':
           opts.record = { 
             action: 'startCallRecording',
-            siprecServerURL: v_resolve(config.siprecServerURL, config.siprecServerURLType, this.context(), msg),
-            recordingID: v_resolve(config.recordingID, config.recordingIDType, this.context(), msg) || crypto.randomUUID()
+            siprecServerURL: new_resolve(RED, config.siprecServerURL, config.siprecServerURLType, node, msg),
+            recordingID: new_resolve(RED, config.recordingID, config.recordingIDType, node, msg) || crypto.randomUUID()
           };
           break;
         case 'stop_call_recording':

package/src/nodes/lex.html

@@ -1,6 +1,12 @@
 <!-- Javascript -->
 <script src="resources/@jambonz/node-red-contrib-jambonz/editor.js"></script>
 <script type="text/javascript">
+  var mustacheType = {
+  value: 'mustache',
+  label: 'mustache',
+  hasvalue: true,
+  icon: 'resources/@jambonz/node-red-contrib-jambonz/icons/mustache.svg'
+}
   RED.nodes.registerType('lex',{
       category: 'jambonz',
       color: '#bbabaa',
@@ -48,33 +54,42 @@
 
         prepareTtsControls(node);
 
+        $('#node-input-eventHook').typedInput({
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
+          typeField: $('#node-input-eventHookType')
+        });
+        $('#node-input-actionHook').typedInput({
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
+          typeField: $('#node-input-actionHookType')
+        });
+
         $('#node-input-bot').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-botType')
         });
         $('#node-input-alias').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-aliasType')
         });
         $('#node-input-locale').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-localeType')
         });
-        $('#node-input-intent').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
-          typeField: $('#node-input-intentType')
-        });
         $('#node-input-inputTimeout').typedInput({
-          types: ['num', 'msg', 'flow', 'global'],
+          types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-inputTimeoutType')
         });
+        $('#node-input-intent').typedInput({
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
+          typeField: $('#node-input-intentType')
+        });
         $('#node-input-slots').typedInput({
           typeField: $('#node-input-slotsType'),
-          types: ['json', 'msg', 'flow', 'global']
+          types: ['json', 'msg', 'flow', 'global'],
         });
         $('#node-input-metadata').typedInput({
           typeField: $('#node-input-metadataType'),
-          types: ['json', 'msg', 'flow', 'global']
+          types: ['json', 'msg', 'flow', 'global'],
         });
 
         var onPromptChanged = function () {

package/src/nodes/lex.js

@@ -1,4 +1,4 @@
-var {appendVerb, v_resolve} = require('./libs')
+var {appendVerb, new_resolve} = require('./libs')
 
 module.exports = function(RED) {
  /** lex */
@@ -12,22 +12,21 @@ module.exports = function(RED) {
         accessKey = awsCreds.credentials.accessKey;
         secretAccessKey = awsCreds.credentials.secretAccessKey;
       }
-      var botId = v_resolve(config.bot, config.botType, this.context(), msg);
-      var botAlias = v_resolve(config.alias, config.aliasType, this.context(), msg);
-      var locale = v_resolve(config.locale, config.localeType, this.context(), msg) || 'en_US';
-      var val = v_resolve(config.inputTimeout, config.inputTimeoutType, this.context(), msg);
+      var eventHook = new_resolve(RED, config.eventHook, config.eventHookType, node, msg);
+      var actionHook = new_resolve(RED, config.actionHook, config.actionHookType, node, msg);
+      var botId = new_resolve(RED, config.bot, config.botType, node, msg);
+      var botAlias = new_resolve(RED, config.alais, config.aliasType, node, msg);
+      var locale = new_resolve(RED, config.locale, config.localeType, node, msg) || 'en_US';  
+      var val = new_resolve(RED, config.inputTimeout, config.inputTimeoutType, node, msg);
       var timeout = /^\d+$/.test(val) ? parseInt(val) : 0;
-      var eventHook = v_resolve(config.eventHook, config.eventHookType, this.context(), msg);
-      var actionHook = v_resolve(config.actionHook, config.actionHookType, this.context(), msg);
-      var metadata =  v_resolve(config.metadata, config.metadataType, this.context(), msg);
       var slots, intentName;
-
       if (config.specifyIntent) {
-        intentName =  v_resolve(config.intent, config.intentType, this.context(), msg);
+        intentName =  new_resolve(RED, config.intent, config.intentType, node, msg);
         if (intentName) {
-          slots =  v_resolve(config.slots, config.slotsType, this.context(), msg);
+          slots =  new_resolve(RED, config.slots, config.slotsType, node, msg);
         }
       }
+      var metadata =  new_resolve(RED, config.metadata, config.metadataType, node, msg);
 
       const obj = {
         verb: 'lex',

package/src/nodes/libs.js

@@ -19,6 +19,7 @@ exports.appendVerb = (msg, obj) => {
   
   /**
    * resolve a value that may be either a string or a property of the msg, flow, or global context
+   * Redundant code now replaced with new_resolve, leaving for now just in case
    */
   exports.v_resolve= (val, valType, context, msg, asJson) => {
     if (!val || !valType) return val;
@@ -44,6 +45,40 @@ exports.appendVerb = (msg, obj) => {
     return mustache.render('{{' + val + '}}', data);
   }
   
+  exports.new_resolve = (RED, val, valtype, node, msg) => {
+    if (!val || !valtype) return val;
+    switch (valtype) {
+      case 'str': 
+      case 'num': 
+      case 'env':  
+      case 'msg': 
+      case 'flow': 
+      case 'global':
+      case 'jsonata':
+        return RED.util.evaluateNodeProperty(val, valtype, node, msg);
+      case 'mustache': 
+        let data = dataobject(node.context(), msg);
+        return mustache.render(val, data);
+      case 'json':
+        return JSON.parse(val);
+    }
+  }
+  function dataobject(context, msg){
+    data = msg;
+    data.global = {};
+    data.flow = {};
+    g_keys = context.global.keys();
+    f_keys = context.flow.keys();
+    for (k in g_keys){
+      data.global[g_keys[k]] = context.global.get(g_keys[k]);
+    };
+    for (k in f_keys){
+      data.flow[f_keys[k]] = context.flow.get(f_keys[k]);
+    };
+    return data
+  }
+
+
   exports.v_text_resolve = (node, val, context, msg) => {
     const flow = {};
     const glob = {};
@@ -98,3 +133,4 @@ exports.appendVerb = (msg, obj) => {
     });
     return post(`Accounts/${accountSid}/Messages`, opts);
   }
+

package/src/nodes/listen.html

@@ -1,5 +1,12 @@
 <!-- Javascript -->
 <script type="text/javascript">
+  var mustacheType = {
+  value: 'mustache',
+  label: 'mustache',
+  hasvalue: true,
+  icon: 'resources/@jambonz/node-red-contrib-jambonz/icons/mustache.svg'
+}
+
 RED.nodes.registerType('listen',{
       category: 'jambonz',
       color: '#bbabaa',
@@ -58,19 +65,19 @@ RED.nodes.registerType('listen',{
       oneditprepare: function() {
         var node = this;
         $('#node-input-actionhook').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-actionhookType')
         });
         $('#node-input-url').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-urlType')
         });
         $('#node-input-authuser').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-authuserType')
         });
         $('#node-input-authpassword').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-authpasswordType')
         });
         $('#node-input-metadata').typedInput({
@@ -78,15 +85,15 @@ RED.nodes.registerType('listen',{
           typeField: $('#node-input-metadataType')
         });
         $('#node-input-transcriptionhook').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-transcriptionhookType')
         });
         $('#node-input-transcriptionhints').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-transcriptionhintsType')
         });
         $('#node-input-recognizeraltlang').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-recognizeraltlangType')
         });
         $('#node-input-diarizationmin').typedInput({

package/src/nodes/listen.js

@@ -1,4 +1,4 @@
-var {appendVerb, v_resolve} = require('./libs')
+var {appendVerb, new_resolve} = require('./libs')
 
 module.exports = function(RED) {
   function listen(config) {
@@ -7,8 +7,8 @@ module.exports = function(RED) {
     node.on('input', function(msg) {
       const obj = {
         verb: 'listen',
-        url: v_resolve(config.url, config.urlType, this.context(), msg),
-        actionHook: v_resolve(config.actionhook, config.actionhookType, this.context(), msg),
+        url: new_resolve(RED, config.url, config.urlType, node, msg),
+        actionHook: new_resolve(RED, config.actionhook, config.actionhookType, node, msg),
         finishOnKey: config.finishonkey,
         mixType: config.mixtype,
         playBeep: config.beep,
@@ -24,11 +24,11 @@ module.exports = function(RED) {
           diarization: config.diarization
         };
         if (recognizer.vendor === 'google') {
-          var diarizationMin = v_resolve(config.diarizationmin, config.diarizationminType, this.context(), msg);
-          var diarizationMax = v_resolve(config.diarizationmax, config.diarizationmaxType, this.context(), msg);
-          var hints = v_resolve(config.transcriptionhints, config.transcriptionhintsType, this.context(), msg);
-          var altlangs = v_resolve(config.recognizeraltlang, config.recognizeraltlangType, this.context(), msg);
-          var naics = v_resolve(config.naics, config.naicsType, this.context(), msg);
+          var diarizationMin = new_resolve(RED, config.diarizationmin, config.diarizationminType, node, msg);
+          var diarizationMax = new_resolve(RED, config.diarizationmax, config.diarizationmaxType, node, msg);
+          var hints = new_resolve(RED, config.transcriptionhints, config.transcriptionhintsType, node, msg);
+          var altlangs = new_resolve(RED, config.recognizeraltlang, config.recognizeraltlangType, node, msg);
+          var naics = new_resolve(RED, config.naics, config.naicsType, node, msg);
           Object.assign(recognizer, {
             profanityFilter: config.profanityfilter,
             hints: hints.length > 0 ?
@@ -49,8 +49,8 @@ module.exports = function(RED) {
           }
         }
         else if (recognizer.vendor === 'aws') {
-          var vocab = v_resolve(config.vocabularyname, config.vocabularynameType, this.context(), msg);
-          var vocabFilter = v_resolve(config.vocabularyfiltername, config.vocabularynameType, this.context(), msg);
+          var vocab = new_resolve(RED, config.vocabularyname, config.vocabularynameType, node, msg);
+          var vocabFilter = new_resolve(RED, config.vocabularyfiltername, config.vocabularyfilternameType, node, msg);
           Object.assign(recognizer, {
             vocabularyName: vocab,
             vocabularyFilterName: vocabFilter,
@@ -58,7 +58,7 @@ module.exports = function(RED) {
           });
         }
         obj.transcribe = {
-          transcriptionHook: v_resolve(config.transcriptionhook, config.transcriptionhookType, this.context(), msg),
+          transcriptionHook: new_resolve(RED, config.transcriptionhook, config.transcriptionhookType, node, msg),
           recognizer
         };
       }
@@ -66,7 +66,7 @@ module.exports = function(RED) {
       if (/^\d+$/.test(config.maxlength)) obj.maxLength = parseInt(config.maxLength);
       if (config.finishonkey.length) obj.finishOnKey = config.finishonkey;
 
-      var data = v_resolve(config.metadata, config.metadataType, this.context(), msg, true);
+      var data = new_resolve(RED, config.metadata, config.metadataType, node, msg);
       if (data) obj.metadata = data;
 
       appendVerb(msg, obj);

package/src/nodes/message.html

@@ -1,5 +1,11 @@
 <!-- Javascript -->
 <script type="text/javascript">
+  var mustacheType = {
+  value: 'mustache',
+  label: 'mustache',
+  hasvalue: true,
+  icon: 'resources/@jambonz/node-red-contrib-jambonz/icons/mustache.svg'
+}
   RED.nodes.registerType('message', {
     category: 'jambonz',
     color: '#bbabaa',
@@ -25,22 +31,22 @@
 
       $('#node-input-from').typedInput({
         default: $('#node-input-fromType').val(),
-        types: ['str','msg', 'flow', 'global', 'jsonata', 'env'],
+        types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
         typeField: $('#node-input-fromType')
       });
       $('#node-input-to').typedInput({
         default: $('#node-input-toType').val(),
-        types: ['str','msg', 'flow', 'global', 'jsonata', 'env'],
+        types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
         typeField: $('#node-input-toType')
       });
       $('#node-input-text').typedInput({
         default: $('#node-input-textType').val(),
-        types: ['str','msg', 'flow', 'global', 'jsonata', 'env'],
+        types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
         typeField: $('#node-input-textType')
       });
       $('#node-input-provider').typedInput({
         default: $('#node-input-providerType').val(),
-        types: ['str','msg', 'flow', 'global', 'jsonata', 'env'],
+        types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
         typeField: $('#node-input-providerType')
       });
     }

package/src/nodes/message.js

@@ -1,19 +1,14 @@
-var { appendVerb, v_resolve } = require("./libs");
+var { appendVerb,  new_resolve } = require("./libs");
 
 module.exports = function (RED) {
   function message(config) {
     RED.nodes.createNode(this, config);
     var node = this;
     node.on("input", function (msg, send, done) {
-      var from = v_resolve(config.from, config.fromType, this.context(), msg);
-      var to = v_resolve(config.to, config.toType, this.context(), msg);
-      var text = v_resolve(config.text, config.textType, this.context(), msg);
-      var provider = v_resolve(
-        config.provider,
-        config.providerType,
-        this.context(),
-        msg
-      );
+      var from = new_resolve(RED, config.from, config.fromType, node, msg);
+      var to =new_resolve(RED, config.to, config.toType, node, msg);
+      var text = new_resolve(RED, config.text, config.textType, node, msg);
+      var provider = new_resolve(RED, config.provider, config.providerType, node, msg);
       if ((!provider || 0 === provider.length) && msg.sms.provider) {
         provider = msg.sms.provider;
       }

package/src/nodes/pause.html

@@ -1,5 +1,12 @@
 <!-- Javascript -->
 <script type="text/javascript">
+  var mustacheType = {
+  value: 'mustache',
+  label: 'mustache',
+  hasvalue: true,
+  icon: 'resources/@jambonz/node-red-contrib-jambonz/icons/mustache.svg'
+}
+
   RED.nodes.registerType('pause',{
       category: 'jambonz',
       color: '#bbabaa',
@@ -15,7 +22,7 @@
       oneditprepare: function() {
         $('#node-input-len').typedInput({
           default: $('#node-input-lenType').val(),
-          types: ['num','msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['num','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-lenType')
         });
       }

package/src/nodes/pause.js

@@ -1,4 +1,4 @@
-var {appendVerb, v_resolve} = require('./libs')
+var {appendVerb, new_resolve} = require('./libs')
 
 module.exports = function(RED) {
     /** pause */
@@ -6,8 +6,7 @@ module.exports = function(RED) {
     RED.nodes.createNode(this, config);
     var node = this;
     node.on('input', function(msg) {
-      var val = v_resolve(config.len, config.lenType, this.context(), msg);
-      var length = /^\d+$/.test(val) ? parseInt(val) : parseFloat(val);
+      var length = new_resolve(RED, config.len, config.lenType, node, msg);
       appendVerb(msg, {
         verb: 'pause',
         length

package/src/nodes/play.html

@@ -1,5 +1,13 @@
 <!-- Javascript -->
 <script type="text/javascript">
+  
+  var mustacheType = {
+    value: 'mustache',
+    label: 'mustache',
+    hasvalue: true,
+    icon: 'resources/@jambonz/node-red-contrib-jambonz/icons/mustache.svg'
+  }
+
 RED.nodes.registerType('play',{
       category: 'jambonz',
       color: '#bbabaa',
@@ -17,7 +25,7 @@ RED.nodes.registerType('play',{
       oneditprepare: function() {
         $('#node-input-url').typedInput({
           default: $('#node-input-urlType').val(),
-          types: ['str','msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-urlType')
         });
       }

package/src/nodes/play.js

@@ -1,4 +1,4 @@
-var {appendVerb, v_resolve} = require('./libs')
+var {appendVerb,  new_resolve} = require('./libs')
 
 module.exports = function(RED) {
   function play(config) {
@@ -7,7 +7,7 @@ module.exports = function(RED) {
     node.on('input', function(msg) {
       appendVerb(msg,  {
         verb: 'play',
-        url: v_resolve(config.url, config.urlType, this.context(), msg),
+        url: new_resolve(RED, config.url, config.urlType, node, msg),
         earlyMedia: config.early,
         loop: config.loop
       });

package/src/nodes/rasa.html

@@ -1,5 +1,11 @@
 <!-- Javascript -->
 <script type="text/javascript">
+  var mustacheType = {
+  value: 'mustache',
+  label: 'mustache',
+  hasvalue: true,
+  icon: 'resources/@jambonz/node-red-contrib-jambonz/icons/mustache.svg'
+}
   RED.nodes.registerType('rasa',{
       category: 'jambonz',
       color: '#bbabaa',
@@ -22,19 +28,19 @@
       oneditprepare: () => {
         var node = this;
         $('#node-input-url').typedInput({
-            types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+            types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
             typeField: $('#node-input-urlType')
         });
         $('#node-input-prompt').typedInput({
-            types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+            types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
             typeField: $('#node-input-promptType')
         });
         $('#node-input-eventHook').typedInput({
-            types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+            types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
             typeField: $('#node-input-eventHookType')
         });
         $('#node-input-actionHook').typedInput({
-            types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+            types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
             typeField: $('#node-input-actionHookType')
         });
       }

package/src/nodes/rasa.js

@@ -1,4 +1,4 @@
-var {appendVerb} = require('./libs')
+var {appendVerb, new_resolve} = require('./libs')
 
 module.exports = function(RED) {
     function rasa(config) {
@@ -6,10 +6,10 @@ module.exports = function(RED) {
         var node = this;
         node.on('input', function(msg) {
           obj = {verb: 'rasa'}
-          obj.url = config.url
-          config.prompt != '' ? obj.prompt = config.prompt : null
-          config.eventHook != '' ? obj.eventHook = config.eventHook : null
-          config.actionHook != '' ? obj.actionHook = config.actionHook : null
+          obj.url = new_resolve(RED, config.url, config.urlType, node, msg);
+          obj.prompt = new_resolve(RED, config.prompt, config.promptType, node, msg);
+          obj.eventHook = new_resolve(RED, config.eventHook, config.eventHookType, node, msg);
+          obj.actionHook = new_resolve(RED, config.actionHook, config.actionHookType, node, msg);
           appendVerb(msg, obj);
           node.send(msg);
         });

package/src/nodes/redirect.html

@@ -1,5 +1,11 @@
 <!-- Javascript -->
 <script type="text/javascript">
+  var mustacheType = {
+  value: 'mustache',
+  label: 'mustache',
+  hasvalue: true,
+  icon: 'resources/@jambonz/node-red-contrib-jambonz/icons/mustache.svg'
+}
   RED.nodes.registerType('redirect', {
     category: 'jambonz',
     color: '#bbabaa',
@@ -16,7 +22,7 @@
     },
     oneditprepare: function() {
       $('#node-input-hook').typedInput({
-        types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+        types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
         typeField: $('#node-input-hookType')
       });
       }

package/src/nodes/redirect.js

@@ -1,4 +1,4 @@
-var {appendVerb, v_resolve} = require('./libs')
+var {appendVerb, new_resolve} = require('./libs')
 
 module.exports = function(RED) {
   /** redirect */
@@ -6,7 +6,7 @@ module.exports = function(RED) {
     RED.nodes.createNode(this, config);
     var node = this;
     node.on('input', function(msg, send, done) {
-      var actionHook = v_resolve(config.hook, config.hookType, this.context(), msg);
+      var actionHook = new_resolve(RED, config.hook, config.hookType, node, msg);
       appendVerb(msg, {
         verb: 'redirect',
         actionHook

package/src/nodes/say.html

@@ -32,7 +32,7 @@
       <input type="text" id="node-input-name" placeholder="Name">
   </div>
   <div class="form-row">
-    <label for="node-input-text"><i class="icon-tag"></i> Text</label>
+    <label for="node-input-text"><i class="icon-tag"></i> Text {{ }}</label>
     <textarea id="node-input-text" rows="4" placeholder="Text or SSML to speak" style="width:70%"></textarea>
   </div>
   <div class="form-row">

package/src/nodes/say.js

@@ -1,4 +1,4 @@
-var {appendVerb, v_text_resolve} = require('./libs')
+var {appendVerb, new_resolve} = require('./libs')
 
 module.exports = function(RED) {
   /** say */
@@ -10,7 +10,7 @@ module.exports = function(RED) {
     var node = this;
 
     node.on('input', function(msg) {
-      const text = v_text_resolve(node, this.text, this.context(), msg);
+      const text = new_resolve(RED, config.text, 'mustache', node, msg);
       var obj = {
         verb: 'say',
         text,

package/src/nodes/sip-decline.html

@@ -1,5 +1,11 @@
 <!-- Javascript -->
 <script type="text/javascript">
+  var mustacheType = {
+  value: 'mustache',
+  label: 'mustache',
+  hasvalue: true,
+  icon: 'resources/@jambonz/node-red-contrib-jambonz/icons/mustache.svg'
+  }
   RED.nodes.registerType('sip:decline',{
       category: 'jambonz',
       color: '#bbabaa',
@@ -17,12 +23,12 @@
       oneditprepare: function() {
         $('#node-input-status').typedInput({
           default: $('#node-input-statusType').val(),
-          types: ['num','msg', 'flow', 'global'],
+          types: ['num','msg', 'flow', 'global', 'jsonata', 'env', mustacheType], 
           typeField: $('#node-input-statusType')
         });
         $('#node-input-reason').typedInput({
           default: $('#node-input-reasonType').val(),
-          types: ['str','msg', 'flow', 'global'],
+          types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-reasonType')
         });
       }

package/src/nodes/sip-decline.js

@@ -1,4 +1,4 @@
-var {appendVerb, v_resolve} = require('./libs')
+var {appendVerb, new_resolve} = require('./libs')
 
 module.exports = function(RED) {
   /** sip:decline */
@@ -6,8 +6,8 @@ module.exports = function(RED) {
     RED.nodes.createNode(this, config);
     var node = this;
     node.on('input', function(msg) {
-      var status = v_resolve(config.status, config.statusType, this.context(), msg);
-      var reason = v_resolve(config.reason, config.reasonType, this.context(), msg);
+      var status = new_resolve(RED, config.status, config.statusType, node, msg);
+      var reason = new_resolve(RED, config.reason, config.reasonType, node, msg);
       appendVerb(msg, {
         verb: 'sip:decline',
         status: parseInt(status),