botium-core 1.13.18 → 1.14.0

package/src/scripting/logichook/LogicHookUtils.js

@@ -1,11 +1,9 @@
-const { NodeVM } = require('vm2')
+const util = require('util')
 const path = require('path')
 const fs = require('fs')
 const isClass = require('is-class')
 const debug = require('debug')('botium-core-asserterUtils')
 
-const { BotiumError } = require('../BotiumError')
-
 const { DEFAULT_ASSERTERS, DEFAULT_LOGIC_HOOKS, DEFAULT_USER_INPUTS } = require('./LogicHookConsts')
 
 DEFAULT_ASSERTERS.forEach((asserter) => {
@@ -129,19 +127,7 @@ module.exports = class LogicHookUtils {
       }
     }
 
-    const _checkUnsafe = () => {
-      if (!this.caps[Capabilities.SECURITY_ALLOW_UNSAFE]) {
-        throw new BotiumError(
-          'Security Error. Using unsafe component is not allowed',
-          {
-            type: 'security',
-            subtype: 'allow unsafe',
-            source: path.basename(__filename),
-            cause: { src: !!src, ref, args, hookType }
-          }
-        )
-      }
-    }
+    const allowUnsafe = !!this.caps[Capabilities.SECURITY_ALLOW_UNSAFE]
 
     if (!src) {
       const packageName = `botium-${hookType}-${ref}`
@@ -154,10 +140,10 @@ module.exports = class LogicHookUtils {
         } else if (isClass(CheckClass.PluginClass)) {
           return new CheckClass.PluginClass({ ref, ...this.buildScriptContext }, this.caps, args)
         } else {
-          throw new Error(`${packageName} class or function or PluginClass field expected`)
+          throw new Error('Either class or function or PluginClass field expected')
         }
       } catch (err) {
-        throw new Error(`Failed to fetch hook ${ref} ${hookType} from guessed package ${packageName} - ${err.message}`)
+        throw new Error(`Logic Hook specification ${ref} ${hookType} (${packageName}) invalid: ${err.message}`)
       }
     }
 
@@ -166,14 +152,14 @@ module.exports = class LogicHookUtils {
         const CheckClass = src
         return new CheckClass({ ref, ...this.buildScriptContext }, this.caps, args)
       } catch (err) {
-        throw new Error(`Failed to load package ${ref} from provided class - ${err.message}`)
+        throw new Error(`Logic Hook specification ${ref} from class invalid: ${err.message}`)
       }
     }
     if (_.isFunction(src)) {
       try {
         return src({ ref, ...this.buildScriptContext }, this.caps, args)
       } catch (err) {
-        throw new Error(`Failed to load package ${ref} from provided function - ${err.message}`)
+        throw new Error(`Logic Hook specification ${ref} from function invalid: ${err.message}`)
       }
     }
     if (_.isObject(src) && !_.isString(src)) {
@@ -183,26 +169,15 @@ module.exports = class LogicHookUtils {
             const script = src[key]
             if (_.isFunction(script)) {
               return script(args)
-            } else if (_.isString(script)) {
-              try {
-                const vm = new NodeVM({
-                  eval: false,
-                  require: false,
-                  sandbox: args
-                })
-                return vm.run(script)
-              } catch (err) {
-                throw new Error(`Script ${key} is not valid - ${err.message || err}`)
-              }
             } else {
-              throw new Error(`Script "${key}" is not valid - only functions and javascript code accepted`)
+              throw new Error(`Script ${key} is not valid - only functions accepted`)
             }
           }
           return result
         }, {})
         return hookObject
       } catch (err) {
-        throw new Error(`Failed to load package ${ref} ${hookType} from provided src function - ${err.message}`)
+        throw new Error(`Logic Hook specification ${ref} ${hookType} from provided src (${util.inspect(src)}) invalid: ${err.message}`)
       }
     }
 
@@ -215,8 +190,8 @@ module.exports = class LogicHookUtils {
       }]
       if (src.indexOf('/') >= 0) {
         tryLoads.push({
-          tryLoadPackageName: src.substr(0, src.lastIndexOf('/')),
-          tryLoadAsserterByName: src.substr(src.lastIndexOf('/') + 1)
+          tryLoadPackageName: src.substring(0, src.lastIndexOf('/')),
+          tryLoadAsserterByName: src.substring(src.lastIndexOf('/') + 1)
         })
       }
 
@@ -243,29 +218,34 @@ module.exports = class LogicHookUtils {
         } else if (_.isFunction(CheckClass.PluginClass)) {
           return CheckClass.PluginClass({ ref, ...this.buildScriptContext }, this.caps, args)
         } else {
-          throw new Error(`${src} class or function expected`)
+          throw new Error('Expected class or function')
         }
       }
 
       for (const tryLoad of tryLoads) {
-        const tryLoadFile = path.resolve(process.cwd(), tryLoad.tryLoadPackageName)
-        if (fs.existsSync(tryLoadFile)) {
-          _checkUnsafe()
+        if (this.caps.SAFEDIR) {
+          const tryLoadFile = path.resolve(this.caps.SAFEDIR, tryLoad.tryLoadPackageName)
+          if (tryLoadFile.startsWith(path.resolve(this.caps.SAFEDIR))) {
+            if (fs.existsSync(tryLoadFile)) {
+              try {
+                return tryLoadFromSource(tryLoadFile, tryLoad.tryLoadAsserterByName)
+              } catch (err) {
+                loadErr.push(`Logic Hook specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `)
+              }
+            }
+          }
+        }
+        if (allowUnsafe || tryLoad.tryLoadPackageName.startsWith('botium-')) {
           try {
-            return tryLoadFromSource(tryLoadFile, tryLoad.tryLoadAsserterByName)
+            return tryLoadFromSource(tryLoad.tryLoadPackageName, tryLoad.tryLoadAsserterByName)
           } catch (err) {
-            loadErr.push(`Failed to fetch ${ref} ${hookType} from ${src} - ${err.message} `)
+            loadErr.push(`Logic Hook specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `)
           }
         }
-        try {
-          return tryLoadFromSource(tryLoad.tryLoadPackageName, tryLoad.tryLoadAsserterByName)
-        } catch (err) {
-          loadErr.push(`Failed to fetch ${ref} ${hookType} from ${src} - ${err.message} `)
-        }
       }
 
       loadErr.forEach(debug)
     }
-    throw new Error(`Failed to fetch ${ref} ${hookType}, no idea how to load ...`)
+    throw new Error(`Logic Hook specification ${ref} ${hookType} from "${util.inspect(src)}" invalid : no loader available`)
   }
 }

package/src/scripting/logichook/asserter/ButtonsAsserter.js

@@ -18,19 +18,19 @@ module.exports = class ButtonsAsserter {
     }
     const buttonsNotFound = []
     const buttonsFound = []
-    const parsePayload = (payload) => {
+    const stringifyPayload = (payload) => {
       if (_.isNil(payload)) {
-        return undefined
+        return ''
       }
       try {
-        return JSON.parse(payload)
+        return JSON.stringify(JSON.parse(payload))
       } catch (e) {
-        return payload
+        return JSON.stringify(payload)
       }
     }
     for (let i = 0; i < (args || []).length; i++) {
       const matchByText = allButtons.some(b => this.context.Match(b.text, normalizeText(args[i], !!this.caps[SCRIPTING_NORMALIZE_TEXT])))
-      const matchByPayload = allButtons.some(b => _.isEqual(parsePayload(b.payload), parsePayload(args[i])))
+      const matchByPayload = allButtons.some(b => this.context.Match(stringifyPayload(b.payload), normalizeText(args[i], !!this.caps[SCRIPTING_NORMALIZE_TEXT])))
       if (matchByText || matchByPayload) {
         buttonsFound.push(args[i])
       } else {

package/src/scripting/logichook/logichooks/ConditionalBusinessHoursLogicHook.js

@@ -0,0 +1,56 @@
+const util = require('util')
+const moment = require('moment-timezone')
+const debug = require('debug')('botium-core-ConditionalTimeBasedLogicHook')
+
+module.exports = class ConditionalBusinessHoursLogicHook {
+  constructor (context, caps, globalArgs) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  _isBetween ({ now, start, end, days, timeZone }) {
+    if ((!start || !end) && (!days || days.length === 0)) {
+      throw new Error('ConditionalBusinessHoursLogicHook: Either start and end time or days array needs to be specified in params')
+    }
+    now.tz(timeZone)
+    if (days && days.length > 0 && !days.includes(now.format('dddd'))) {
+      return false
+    }
+
+    if (!start && !end && days && days.length > 0 && days.includes(now.format('dddd'))) {
+      return true
+    }
+
+    const momentStartTime = moment(start, 'HH:mm')
+    const startTime = now.clone().set({ hour: momentStartTime.hour(), minute: momentStartTime.minute() })
+    startTime.tz(timeZone)
+    const momentEndTime = moment(end, 'HH:mm')
+    const endTime = now.clone().set({ hour: momentEndTime.hour(), minute: momentEndTime.minute() })
+    endTime.tz(timeZone)
+    if (startTime.isSameOrAfter(endTime)) {
+      if (now.isSameOrAfter(startTime)) {
+        endTime.add(1, 'days')
+      } else {
+        startTime.add(-1, 'days')
+      }
+    }
+    return now.isBetween(startTime, endTime, 'minutes', '[]')
+  }
+
+  onBotPrepare ({ convo, convoStep, args }) {
+    const conditionGroupId = args[1]
+    let params
+    try {
+      params = JSON.parse(args[0])
+    } catch (e) {
+      throw new Error(`ConditionalBusinessHoursLogicHook: No parsable JSON object found in params: ${e}`)
+    }
+    convoStep.conditional = {
+      conditionGroupId
+    }
+    params.now = moment()
+    convoStep.conditional.skip = !this._isBetween(params)
+    debug(`ConditionalBusinessHoursLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+  }
+}

package/src/scripting/logichook/logichooks/ConditionalCapabilityValueBasedLogicHook.js

@@ -0,0 +1,37 @@
+const util = require('util')
+const jp = require('jsonpath')
+const _ = require('lodash')
+const debug = require('debug')('botium-core-ConditionalCapabilityValueBasedLogicHook')
+
+module.exports = class ConditionalCapabilityValueBasedLogicHook {
+  constructor (context, caps, globalArgs) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  _isCapabilityValueEqual ({ capabilityName, jsonPath, value }) {
+    if (jsonPath) {
+      const capabilityObject = _.isObject(this.caps[capabilityName]) ? this.caps[capabilityName] : JSON.parse(this.caps[capabilityName])
+      const values = jp.query(capabilityObject, jsonPath)
+      return !!(values && values.length > 0 && values.includes(value))
+    } else {
+      return this.caps[capabilityName] === value
+    }
+  }
+
+  onBotPrepare ({ convo, convoStep, args }) {
+    const conditionGroupId = args[1]
+    let params
+    try {
+      params = JSON.parse(args[0])
+    } catch (e) {
+      throw new Error(`ConditionalCapabilityValueBasedLogicHook: No parsable JSON object found in params: ${e}`)
+    }
+    convoStep.conditional = {
+      conditionGroupId
+    }
+    convoStep.conditional.skip = !this._isCapabilityValueEqual(params)
+    debug(`ConditionalCapabilityValueBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+  }
+}

package/src/scripting/logichook/logichooks/ConditionalJsonPathBasedLogicHook.js

@@ -0,0 +1,31 @@
+const util = require('util')
+const jp = require('jsonpath')
+const debug = require('debug')('botium-core-ConditionalJsonPathBasedLogicHook')
+
+module.exports = class ConditionalJsonPathBasedLogicHook {
+  constructor (context, caps, globalArgs) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  onBotPrepare ({ convo, convoStep, args, botMsg }) {
+    const conditionGroupId = args[1]
+    let params
+    try {
+      params = JSON.parse(args[0])
+    } catch (e) {
+      throw new Error(`ConditionalJsonPathBasedLogicHook: No parsable JSON object found in params: ${e}`)
+    }
+    convoStep.conditional = {
+      conditionGroupId
+    }
+    let skip = true
+    if (params.jsonPath) {
+      const values = jp.query(botMsg, params.jsonPath)
+      skip = !(values && values.length > 0 && values.includes(params.value))
+    }
+    convoStep.conditional.skip = skip
+    debug(`ConditionalJsonPathBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+  }
+}

package/src/scripting/logichook/logichooks/ConditionalTimeBasedLogicHook.js

@@ -0,0 +1,46 @@
+const util = require('util')
+const moment = require('moment-timezone')
+const debug = require('debug')('botium-core-ConditionalTimeBasedLogicHook')
+
+module.exports = class ConditionalTimeBasedLogicHook {
+  constructor (context, caps, globalArgs) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  _isBetween ({ now, start, end, timeZone }) {
+    now.tz(timeZone)
+    const momentStartTime = moment(start, 'HH:mm')
+    const startTime = now.clone().set({ hour: momentStartTime.hour(), minute: momentStartTime.minute() })
+    startTime.tz(timeZone)
+    const momentEndTime = moment(end, 'HH:mm')
+    const endTime = now.clone().set({ hour: momentEndTime.hour(), minute: momentEndTime.minute() })
+    endTime.tz(timeZone)
+
+    if (startTime.isSameOrAfter(endTime)) {
+      if (now.isSameOrAfter(startTime)) {
+        endTime.add(1, 'days')
+      } else {
+        startTime.add(-1, 'days')
+      }
+    }
+    return now.isBetween(startTime, endTime, 'minutes', '[]')
+  }
+
+  onBotPrepare ({ convo, convoStep, args }) {
+    const conditionGroupId = args[1]
+    let params
+    try {
+      params = JSON.parse(args[0])
+    } catch (e) {
+      throw new Error(`ConditionalTimeBasedLogicHook: No parsable JSON object found in params: ${e}`)
+    }
+    convoStep.conditional = {
+      conditionGroupId
+    }
+    params.now = moment()
+    convoStep.conditional.skip = !this._isBetween(params)
+    debug(`ConditionalTimeBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+  }
+}

package/test/compiler/precompilerscript.spec.js

@@ -33,13 +33,13 @@ const afterCustom = async (thisParam) => {
 
 describe('compiler.precompiler.script', function () {
   it('should execute non-standard json', async function () {
-    await beforeCustom(this, `
+    await beforeCustom(this, ({ scriptData }) => {
       const utterances = {}
       for (const entry of scriptData) {
         utterances[entry.intent] = entry.sentences
       }
-      module.exports = {utterances}
-    `)
+      return { utterances }
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -54,15 +54,15 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should filter by extension, accepted', async function () {
-    await beforeCustom(this, `
-    if (filename.endsWith('.json')) {
+    await beforeCustom(this, ({ filename, scriptData }) => {
+      if (filename.endsWith('.json')) {
         const utterances = {}
         for (const entry of scriptData) {
           utterances[entry.intent] = entry.sentences
         }
-        module.exports = {utterances}
+        return { utterances }
       }
-    `)
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -71,15 +71,15 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should filter by extension, rejected', async function () {
-    await beforeCustom(this, `
-    if (filename.endsWith('.xxx')) {
+    await beforeCustom(this, ({ filename, scriptData }) => {
+      if (filename.endsWith('.xxx')) {
         const utterances = {}
         for (const entry of scriptData) {
           utterances[entry.intent] = entry.sentences
         }
-        module.exports = {utterances}
+        return { utterances }
       }
-    `)
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -88,15 +88,15 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should filter by content, accepted', async function () {
-    await beforeCustom(this, `
+    await beforeCustom(this, ({ scriptData }) => {
       if (scriptData) {
         const utterances = {}
         for (const entry of scriptData) {
           utterances[entry.intent] = entry.sentences
         }
-        module.exports = {utterances}
+        return { utterances }
       }
-    `)
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -105,15 +105,15 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should filter by content, rejected', async function () {
-    await beforeCustom(this, `
+    await beforeCustom(this, ({ scriptData }) => {
       if (scriptData.utterances) {
         const utterances = {}
         for (const entry of scriptData.utterances) {
           utterances[entry.intent] = entry.sentences
         }
-        module.exports = {utterances}
+        return { utterances }
       }
-  `)
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -122,13 +122,13 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should change extension', async function () {
-    await beforeCustom(this, `
+    await beforeCustom(this, ({ filename, scriptData }) => {
       const utterances = {}
       for (const entry of scriptData) {
         utterances[entry.intent] = entry.sentences
       }
-      module.exports = { scriptBuffer:{utterances}, filename: filename + ".json" }
-  `)
+      return { scriptBuffer: { utterances }, filename: filename + '.json' }
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json.txt')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -137,13 +137,13 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should not read anything without extension change', async function () {
-    await beforeCustom(this, `
+    await beforeCustom(this, ({ scriptData }) => {
       const utterances = {}
       for (const entry of scriptData) {
         utterances[entry.intent] = entry.sentences
       }
-      module.exports = { scriptBuffer:{utterances} }
-  `)
+      return { scriptBuffer: { utterances } }
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json.txt')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -152,9 +152,7 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should be able to precompile text to text', async function () {
-    await beforeCustom(this, `
-      module.exports = scriptData.replace("Hi!", "Hi Bot!")
-  `)
+    await beforeCustom(this, ({ scriptData }) => scriptData.replace('Hi!', 'Hi Bot!'))
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script_text_to_text.convo.txt')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()

package/test/connectors/pluginconnectorcontainer.spec.js

@@ -0,0 +1,60 @@
+const assert = require('chai').assert
+const BotDriver = require('../../').BotDriver
+const Capabilities = require('../../').Capabilities
+
+const echoConnectorWithMetadata = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const botMsg = {
+        sender: 'bot',
+        sourceData: msg.sourceData,
+        messageText: `Response of ${msg.messageText}`
+      }
+      queueBotSays(botMsg)
+    },
+    GetMetaData () {
+      return Promise.resolve('Sample response from GetMetaData')
+    }
+  }
+}
+const echoConnectorWithoutMetadata = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const botMsg = {
+        sender: 'bot',
+        sourceData: msg.sourceData,
+        messageText: `Response of ${msg.messageText}`
+      }
+      queueBotSays(botMsg)
+    }
+  }
+}
+
+describe('compiler.precompiler.json', function () {
+  beforeEach(async function () {
+    this.init = async (withGetMetaData) => {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'connector.basecontainer',
+        [Capabilities.CONTAINERMODE]: withGetMetaData ? echoConnectorWithMetadata : echoConnectorWithoutMetadata
+      }
+      const driver = new BotDriver(myCaps)
+      this.compiler = driver.BuildCompiler()
+      this.container = await driver.Build()
+    }
+  })
+  afterEach(async function () {
+    this.container && await this.container.Clean()
+  })
+
+  it('should get metadata if its available', async function () {
+    await this.init(true)
+    const result = await this.container.GetMetaData()
+    assert.equal(result, 'Sample response from GetMetaData')
+  })
+
+  it('should get undefined if metadata is not available', async function () {
+    await this.init(false)
+    const result = await this.container.GetMetaData()
+    assert.equal(result, undefined)
+  })
+})