@jambonz/node-red-contrib-jambonz 2.3.10 → 2.4.1

package/src/nodes/dial.js

@@ -1,4 +1,4 @@
-var {appendVerb, v_resolve} = require('./libs')
+var {appendVerb, new_resolve} = require('./libs')
 
 module.exports = function(RED) {
   function dial(config) {
@@ -9,9 +9,9 @@ module.exports = function(RED) {
       node.log(`dial config: ${JSON.stringify(config)}, msg.call: ${JSON.stringify(msg.call)}`);
       var target = config.targets.map((t) => {
         const obj = Object.assign({}, t);
-        var dest = v_resolve(obj.dest, obj.varType, this.context(), msg);
-        var trunk = v_resolve(obj.trunk, obj.trunkType, this.context(), msg);
-        node.log(`dial: dest ${t.varType}:${t.dest} resolved to ${dest}`);
+        var dest = new_resolve(RED, config.dest, config.destType, node, msg)
+        var trunk = new_resolve(RED, config.trunk, config.trunkType, node, msg)
+        node.log(`dial: dest ${t.destType}:${t.dest} resolved to ${dest}`);
         switch (t.type) {
           case 'phone':
             obj.number = dest;
@@ -46,11 +46,11 @@ module.exports = function(RED) {
         answerOnBridge: config.answeronbridge,
         timeLimit: config.timelimit ? parseInt(config.timelimit) : null,
         timeout: config.timeout ? parseInt(config.timeout) : null,
-        callerId: v_resolve(config.callerid, config.calleridType, this.context(), msg),
-        actionHook: v_resolve(config.actionhook, config.actionhookType, this.context(), msg),
-        confirmHook: v_resolve(config.confirmhook, config.confirmhookType, this.context(), msg),
-        dialMusic: v_resolve(config.dialmusic, config.dialmusicType, this.context(), msg),
-        dtmfHook: v_resolve(config.dtmfhook, config.dtmfhookType, this.context(), msg)
+        callerId: new_resolve(RED, config.callerId, config.callerIdType, node, msg),
+        actionHook: new_resolve(RED, config.actionHook, config.actionHookType, node, msg),
+        confirmHook: new_resolve(RED, config.confirmHook, config.confirmHookType, node, msg), 
+        dialMusic: new_resolve(RED, config.dialMusic, config.dialMusicType, node, msg),
+        dtmfHook: new_resolve(RED, config.dtmfHook, config.dtmfHookType, node, msg),
       };
 
       // headers
@@ -63,7 +63,7 @@ module.exports = function(RED) {
       // nested listen
       if (config.listenurl && config.listenurl.length > 0) {
         data.listen = {
-          url: v_resolve(config.listenurl, config.listenurlType, this.context(), msg),
+          url: new_resolve(RED, config.listenurl, config.listenurlType, node, msg),
           mixType: 'stereo'
         };
       }
@@ -78,11 +78,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.hints, config.hintsType, node, msg)
+          var altlangs = new_resolve(RED, config.altlangs, config.altlangsType, node, msg)
+          var naics = new_resolve(RED, config.naics, config.naicsType, node, msg)
           Object.assign(recognizer, {
             profanityFilter: config.profanityfilter,
             hints: hints.length > 0 ?
@@ -103,8 +103,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,
@@ -112,12 +112,12 @@ module.exports = function(RED) {
           });
         }
         data.transcribe = {
-          transcriptionHook: v_resolve(config.transcriptionhook, config.transcriptionhookType, this.context(), msg),
+          transcriptionHook: new_resolve(RED, config.transcriptionHook, config.transcriptionHookType, node, msg),
           recognizer
         };
       }
       // dtmf capture
-      const dtmfCapture = v_resolve(config.dtmfcapture, config.dtmfcaptureType, this.context(), msg);
+      const dtmfCapture = new_resolve(RED, config.dtmfcapture, config.dtmfcaptureType, node, msg);
       if (dtmfCapture && dtmfCapture.length) {
         data.dtmfCapture = dtmfCapture.split(',').map((i) => i.trim());
       }

package/src/nodes/dialogflow.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('dialogflow',{
       category: 'jambonz',
       color: '#bbabaa',
@@ -50,39 +56,39 @@
         var node = this;
         $('#node-input-serviceAccountCredentials').typedInput({
           typeField: $('#node-input-serviceAccountCredentialsType'),
-          types: ['json', 'msg', 'flow', 'global', 'jsonata', 'env']
+          types: ['json', 'msg', 'flow', 'global', 'jsonata',  'env', mustacheType]
         });
         $('#node-input-project').typedInput({
           typeField: $('#node-input-projectType'),
-          types: ['str','msg', 'flow', 'global', 'jsonata', 'env']
+          types: ['str','msg', 'flow', 'global', 'jsonata',  'env', mustacheType]
         });
         $('#node-input-environment').typedInput({
           typeField: $('#node-input-environmentType'),
-          types: ['str','msg', 'flow', 'global', 'jsonata', 'env']
+          types: ['str','msg', 'flow', 'global', 'jsonata',  'env', mustacheType]
         });
         $('#node-input-welcomeEvent').typedInput({
           typeField: $('#node-input-welcomeEventType'),
-          types: ['str','msg', 'flow', 'global', 'jsonata', 'env']
+          types: ['str','msg', 'flow', 'global', 'jsonata',  'env', mustacheType]
         });
         $('#node-input-welcomeEventParams').typedInput({
           typeField: $('#node-input-welcomeEventParamsType'),
-          types: ['json', 'msg', 'flow', 'global', 'jsonata', 'env']
+          types: ['json', 'msg', 'flow', 'global', 'jsonata',  'env', mustacheType]
         });
         $('#node-input-eventHook').typedInput({
           typeField: $('#node-input-eventHookType'),
-          types: ['str','msg', 'flow', 'global', 'jsonata', 'env']
+          types: ['str','msg', 'flow', 'global', 'jsonata',  'env', mustacheType]
         });
         $('#node-input-actionHook').typedInput({
           typeField: $('#node-input-actionHookType'),
-          types: ['str','msg', 'flow', 'global', 'jsonata', 'env']
+          types: ['str','msg', 'flow', 'global', 'jsonata',  'env', mustacheType]
         });
         $('#node-input-inputTimeout').typedInput({
-          typeField: $('#node-input-inputTimeout'),
-          types: ['num','msg', 'flow', 'global', 'jsonata', 'env']
+          typeField: $('#node-input-inputTimeoutType'),
+          types: ['num','msg', 'flow', 'global', 'jsonata',  'env', mustacheType]
         });
         $('#node-input-noinputEvent').typedInput({
           typeField: $('#node-input-noinputEventType'),
-          types: ['str','msg', 'flow', 'global', 'jsonata', 'env']
+          types: ['str','msg', 'flow', 'global', 'jsonata',  'env', mustacheType]
         });
         var promptElem = $('#node-input-prompt');
         var ttsDiv = $('#tts-options');

package/src/nodes/dialogflow.js

@@ -1,26 +1,25 @@
-var {appendVerb, v_resolve} = require('./libs')
+var {appendVerb, new_resolve} = require('./libs')
 
 module.exports = function(RED) {
 function dialogflow(config) {
     RED.nodes.createNode(this, config);
     var node = this;
     node.on('input', function(msg) {
-      var val = v_resolve(config.inputTimeout, config.inputTimeoutType, this.context(), msg);
+      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 welcomeEvent = v_resolve(config.welcomeEvent, config.welcomeEventType, this.context(), msg);
-      var environment = v_resolve(config.environment, config.environmentType, 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 welcomeEvent = new_resolve(RED, config.welcomeEvent, config.welcomeEventType, node, msg);
+      var environment = new_resolve(RED, config.environment, config.environmentType, node, msg);
       var welcomeEventParams;
       if (welcomeEvent && welcomeEvent.length > 0) {
-        welcomeEventParams = v_resolve(config.welcomeEventParams, config.welcomeEventParamsType, this.context(), msg);
+        welcomeEventParams = new_resolve(RED, config.welcomeEventParams, config.welcomeEventParamsType, node, msg);
       }
-      var noInputEvent = v_resolve(config.noInputEvent, config.noInputEventType, this.context(), msg);
+      var noInputEvent = new_resolve(RED, config.noinputEvent, config.noinputEventType, node, msg);
       const obj = {
         verb: 'dialogflow',
-        credentials:  v_resolve(config.serviceAccountCredentials,
-          config.serviceAccountCredentialsType, this.context(), msg),
-        project:  v_resolve(config.project, config.projectType, this.context(), msg),
+        credentials:  new_resolve(RED, config.serviceAccountCredentials, config.serviceAccountCredentialsType, node, msg),
+        project:  new_resolve(RED, config.project, config.projectType, node, msg),
         lang:  config.recognizerlang,
         bargein: config.bargein
       };

package/src/nodes/dtmf.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('dtmf',{
           category: 'jambonz',
           color: '#bbabaa',
@@ -15,12 +21,12 @@
           oneditprepare: function() {
             $('#node-input-dtmf').typedInput({
               default: $('#node-input-dtmfType').val(),
-              types: ['str','msg', 'flow', 'global', 'jsonata', 'env'],
+              types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
               typeField: $('#node-input-dtmfType')
             })
             $('#node-input-duration').typedInput({
               default: $('#node-input-durationType').val(),
-              types: ['num','msg', 'flow', 'global', 'jsonata', 'env'],
+              types: ['num','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
               typeField: $('#node-input-durationType')
             })
           }

package/src/nodes/dtmf.js

@@ -1,4 +1,4 @@
-var {appendVerb} = require('./libs')
+var {appendVerb, new_resolve} = require('./libs')
 
 module.exports = function(RED) {
   function dtmf(config) {
@@ -7,8 +7,8 @@ module.exports = function(RED) {
     node.on('input', function(msg) {
       appendVerb(msg,  {
         verb: 'dtmf',
-        dtmf: config.dtmf,
-        duration: parseInt(config.duration)
+        dtmf: new_resolve(RED, config.dtmf, config.dtmfType, node, msg),
+        duration: new_resolve(RED, config.duration, config.durationType, node, msg),
       });
       node.send(msg);
     });

package/src/nodes/enqueue.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('enqueue',{
       category: 'jambonz',
       color: '#bbabaa',
@@ -22,19 +28,19 @@
       },
       oneditprepare: function() {
         $('#node-input-queue').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-queueType')
         });
         $('#node-input-priority').typedInput({
-          types: ['num', 'msg', 'flow', 'global'],
+          types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-priorityType')
         });
         $('#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-waitHook').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-waitHookType')
         });
       }

package/src/nodes/enqueue.js

@@ -1,4 +1,4 @@
-var {appendVerb, v_resolve} = require('./libs')
+var {appendVerb,  new_resolve} = require('./libs')
 
 module.exports = function(RED) {
   /** enqueue */
@@ -6,14 +6,12 @@ module.exports = function(RED) {
     RED.nodes.createNode(this, config);
     var node = this;
     node.on('input', function(msg, send, done) {
-      const priorityValue = v_resolve(config.priority, config.priorityType, this.context(), msg);
-
       appendVerb(msg, {
         verb: 'enqueue',
-        name:  v_resolve(config.queue, config.queueType, this.context(), msg),
-        priority:  (/^\d+$/.test(priorityValue)) ? parseInt(priorityValue) : null,
-        actionHook: v_resolve(config.actionHook, config.actionHookType, this.context(), msg),
-        waitHook: v_resolve(config.waitHook, config.waitHookType, this.context(), msg)
+        name:  new_resolve(RED, config.queue, config.queueType, node, msg),
+        priority:  new_resolve(RED, config.priority, config.priorityType, node, msg),
+        actionHook: new_resolve(RED, config.actionHook, config.actionHookType, node, msg),
+        waitHook: new_resolve(RED, config.waitHook, config.waitHookType, node, msg)
       });
       node.send(msg);
     });

package/src/nodes/gather.html

@@ -1,11 +1,18 @@
 <!-- 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('gather',{
       category: 'jambonz',
       color: '#bbabaa',
       defaults: {
         name: {value: ''},
         actionhook: {value: ''},
+        actionhooktype: {val: 'str'},
         finishonkey: {value: ''},
         dtmfinput: {value: 0},
         speechinput: {value: 1},
@@ -57,21 +64,25 @@
         var node = this;
         prepareTtsControls(node);
         prepareSttControls(node);
-
+        
+        $('#node-input-actionhook').typedInput({
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
+          typeField: $('#node-input-actionhookType')
+        });
         $('#node-input-playurl').typedInput({
-          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-playurlType')
         });
         $('#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-naics').typedInput({
-          types: ['num', 'msg', 'flow', 'global'],
+          types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-naicsType')
         });
 
@@ -122,6 +133,7 @@
   <div class="form-row">
     <label for="node-input-actionhook"><i class="icon-tag"></i> Action hook</label>
     <input type="text" id="node-input-actionhook" placeholder="webhook with results of gather">
+    <input type="hidden" id="node-input-actionhookType">
   </div>
   <fieldset>
     <legend>Prompt</legend>

package/src/nodes/gather.js

@@ -1,4 +1,4 @@
-var {appendVerb, v_resolve, v_text_resolve} = require('./libs')
+var {appendVerb,  v_text_resolve, new_resolve} = require('./libs')
 
 module.exports = function(RED) {
   /** gather */
@@ -11,7 +11,7 @@ module.exports = function(RED) {
       node.log(`config: ${JSON.stringify(config)}`);
 
       var obj = {verb: 'gather', input: []};
-      if (config.actionhook) obj.actionHook = config.actionhook;
+      if (config.actionhook) obj.actionHook = new_resolve(RED, config.actionHook, config.actionHookType, node, msg)
 
       // input
       if (config.speechinput) {
@@ -21,9 +21,9 @@ module.exports = function(RED) {
           language: config.recognizerlang
         };
         if (recognizer.vendor === 'google') {
-          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 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 ?
@@ -36,8 +36,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,
@@ -66,7 +66,7 @@ module.exports = function(RED) {
           });
         }
       }
-      else obj.play = {url: v_resolve(config.playurl, config.playurlType, this.context(), msg)};
+      else obj.play = {url: new_resolve(RED, config.playurl, config.playurlType, node, msg)};
 
       node.log(`gather: ${JSON.stringify(obj)}`);
 

package/src/nodes/get_alerts.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('get_alerts',{
       category: 'jambonz',
       color: '#aebfb9',
@@ -21,15 +27,15 @@ RED.nodes.registerType('get_alerts',{
       oneditprepare: () => {
         var node = this;
         $('#node-input-page').typedInput({
-            types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env'],
+            types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
             typeField: $('#node-input-pageType')
         });
         $('#node-input-count').typedInput({
-            types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env'],
+            types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
             typeField: $('#node-input-countType')
         });
         $('#node-input-days').typedInput({
-            types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env'],
+            types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
             typeField: $('#node-input-daysType')
         });
       }

package/src/nodes/get_alerts.js

@@ -1,5 +1,5 @@
 const bent = require('bent');
-var {v_resolve} = require('./libs');
+var {new_resolve} = require('./libs');
 
 module.exports = function(RED) {
     function get_alerts(config) {
@@ -9,9 +9,9 @@ module.exports = function(RED) {
         const {accountSid, apiToken} = server.credentials;
         node.on('input', async(msg, send, done) => {
             const data = {
-                page: v_resolve(config.page, config.pageType, this.context(), msg),
-                count: v_resolve(config.count, config.countType, this.context(), msg),
-                days: v_resolve(config.days, config.daysType, this.context(), msg),
+                page: new_resolve(RED, config.page, config.pageType, node, msg),
+                count: new_resolve(RED, config.count, config.countType, node, msg),
+                days: new_resolve(RED, config.days, config.daysType, node, msg),
             }
             Object.keys(data).forEach((k) => data[k] == null || data[k] == '' && delete data[k]);
             const params = new URLSearchParams(data).toString()

package/src/nodes/get_calls.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('get_calls',{
       category: 'jambonz',
       color: '#aebfb9',
@@ -22,19 +28,19 @@
       label: function() { return this.name || 'Get Calls';},
       oneditprepare: () => {
         $('#node-input-direction').typedInput({
-          types: ['str', 'msg', 'flow', 'global'],
+          types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-directionType')
         });
         $('#node-input-from').typedInput({
-          types: ['str', 'msg', 'flow', 'global'],
+          types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-fromType')
         });
         $('#node-input-to').typedInput({
-          types: ['str', 'msg', 'flow', 'global'],
+          types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-toType')
         });
         $('#node-input-callStatus').typedInput({
-          types: ['str', 'msg', 'flow', 'global'],
+          types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-callStatusType')
         });
       }

package/src/nodes/get_calls.js

@@ -1,5 +1,5 @@
 const bent = require("bent");
-var { v_resolve } = require("./libs");
+var { new_resolve} = require("./libs");
 
 module.exports = function (RED) {
   function get_calls(config) {
@@ -9,15 +9,10 @@ module.exports = function (RED) {
     const { accountSid, apiToken } = server.credentials;
     node.on("input", async (msg, send, done) => {
       const data = {
-        direction: v_resolve(
-          config.direction,
-          config.directionType,
-          this.context(),
-          msg
-        ),
-        from: v_resolve(config.from, config.fromType, this.context(), msg),
-        to: v_resolve(config.to, config.toType, this.context(), msg),
-        callStatus: v_resolve(config.callStatus, config.callStatusType, this.context(), msg),
+        direction: new_resolve(RED, config.direction, config.directionType, node, msg),
+        from: new_resolve(RED, config.from, config.fromType, node, msg),
+        to: new_resolve(RED, config.to, config.toType, node, msg),
+        callStatus: new_resolve(RED, config.callStatus, config.callStatusType, node, msg),
       };
       Object.keys(data).forEach(
         (k) => data[k] == null || (data[k] == '' && delete data[k])

package/src/nodes/get_recent_calls.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('get_recent_calls',{
       category: 'jambonz',
       color: '#aebfb9',
@@ -24,23 +31,23 @@
       label: function() { return this.name || 'Get Recent Calls';},
       oneditprepare: () => {
         $('#node-input-page').typedInput({
-            types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env'],
+            types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
             typeField: $('#node-input-pageType')
         });
         $('#node-input-count').typedInput({
-            types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env'],
+            types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
             typeField: $('#node-input-countType')
         });
         $('#node-input-days').typedInput({
-            types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env'],
+            types: ['num', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
             typeField: $('#node-input-daysType')
         });
         $('#node-input-direction').typedInput({
-          types: ['str', 'msg', 'flow', 'global'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-directionType')
         });
         $('#node-input-trunk').typedInput({
-          types: ['str', 'msg', 'flow', 'global'],
+          types: ['str', 'msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-trunkType')
         });
       }

package/src/nodes/get_recent_calls.js

@@ -1,5 +1,5 @@
 const bent = require('bent');
-var {v_resolve} = require('./libs');
+var {new_resolve} = require('./libs');
 
 module.exports = function(RED) {
     function get_recent_calls(config) {
@@ -9,11 +9,11 @@ module.exports = function(RED) {
         const {accountSid, apiToken} = server.credentials;
         node.on('input', async(msg, send, done) => {
             const data = {
-                direction: v_resolve(config.direction, config.directionType, this.context(), msg),
-                trunk: v_resolve(config.trunk, config.trunkType, this.context(), msg),
-                page: v_resolve(config.page, config.pageType, this.context(), msg),
-                count: v_resolve(config.count, config.countType, this.context(), msg),
-                days: v_resolve(config.days, config.daysType, this.context(), msg),
+                direction: new_resolve(RED, config.direction, config.directionType, node, msg),
+                trunk: new_resolve(RED, config.trunk, config.trunkType, node, msg),
+                page: new_resolve(RED, config.page, config.pageType, node, msg),
+                count: new_resolve(RED, config.count, config.countType, node, msg),
+                days: new_resolve(RED, config.days, config.daysType, node, msg),
             }
             Object.keys(data).forEach((k) => data[k] == null || data[k] == '' && delete data[k]);
             const params = new URLSearchParams(data).toString();

package/src/nodes/lcc.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('lcc',{
       category: 'jambonz',
       color: '#aebfb9',
@@ -54,27 +61,27 @@
 
         $('#node-input-callSid').typedInput({
           default: $('#node-input-callSidType').val(),
-          types: ['str','msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-callSidType')
         });
         $('#node-input-callHook').typedInput({
           default: $('#node-input-callHookType').val(),
-          types: ['str','msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-callHookType')
         });
         $('#node-input-waitHook').typedInput({
           default: $('#node-input-waitHookType').val(),
-          types: ['str','msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-waitHookType')
         });
         $('#node-input-siprecServerURL').typedInput({
           default: $('#node-input-siprecServerURLType').val(),
-          types: ['str','msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-siprecServerURLType')
         });
         $('#node-input-recordingID').typedInput({
           default: $('#node-input-recordingIDType').val(),
-          types: ['str','msg', 'flow', 'global', 'jsonata', 'env'],
+          types: ['str','msg', 'flow', 'global', 'jsonata', 'env', mustacheType],
           typeField: $('#node-input-recordingIDType')
         });