@tiledesk/tiledesk-tybot-connector 0.1.21 → 0.1.23

package/test/when_open_directive_test.js

@@ -0,0 +1,167 @@
+var assert = require('assert');
+const { ExtUtil } = require('../ExtUtil');
+const { DirectivesChatbotPlug } = require('../tiledeskChatbotPlugs/DirectivesChatbotPlug');
+const { DirWhenOpen } = require('../tiledeskChatbotPlugs/directives/DirWhenOpen');
+const supportRequest = require('./support_request.js').request;
+
+describe('Directive DirWhenOpen', function () {
+
+    it('test DirWhenOpen (only one directive) checkOpen=true, matching isopen=true', async () => {
+        let directives = [
+            {
+                "name": "whenopen",
+                "parameter": "\\_tdintent start"
+            }
+        ];
+
+        class MockTdClient {
+            openNow(callback) {
+                callback(null, { isopen: true });
+            }
+        };
+        current_index = 0;
+        when_directive = directives[current_index]
+        let dir = new DirWhenOpen({
+            tdclient: new MockTdClient()
+        });
+        dir.execute(when_directive, directives, current_index, () => {
+            assert(directives.length == 2);
+            assert(directives[1].name === "intent");
+            assert(directives[1].parameter === "start");
+        });
+    });
+
+    it('test DirWhenOpen (first directive) checkOpen=true, !matching because => isopen=false', async () => {
+        let directives = [
+            {
+                "name": "whenopen",
+                "parameter": "\\_tdintent start"
+            },
+            {
+                "name": "dir1"
+            },
+            {
+                "name": "dir3"
+            }
+        ];
+
+        class MockTdClient {
+            openNow(callback) {
+                callback(null, { isopen: false }); // closed
+            }
+        };
+        current_index = 0;
+        when_directive = directives[current_index]
+        let dir = new DirWhenOpen({
+            tdclient: new MockTdClient(),
+            checkOpen: true // checking open
+        });
+        dir.execute(when_directive, directives, current_index, () => {
+            assert(directives.length == 3); // keeps the same length
+            assert(directives[1].name === "dir1"); // no directives are added
+            assert(directives[1].parameter == null);
+        });
+    });
+
+    it('test DirWhenOpen (first directive) checkOpen=false, !matching because => isopen=true', async () => {
+        let directives = [
+            {
+                "name": "whenopen",
+                "parameter": "\\_tdintent start"
+            },
+            {
+                "name": "dir1"
+            },
+            {
+                "name": "dir3"
+            }
+        ];
+
+        class MockTdClient {
+            openNow(callback) {
+                callback(null, { isopen: true }); // closed
+            }
+        };
+        current_index = 0;
+        when_directive = directives[current_index]
+        let dir = new DirWhenOpen({
+            tdclient: new MockTdClient(),
+            checkOpen: false // checking open
+        });
+        dir.execute(when_directive, directives, current_index, () => {
+            assert(directives.length == 3); // keeps the same length
+            assert(directives[1].name === "dir1"); // no directives are added
+            assert(directives[1].parameter == null);
+        });
+    });
+
+    it('test DirWhenOpen (middle directive) checkOpen=true, matching isopen=true', async () => {
+        let directives = [
+            {
+                "name": "dir1"
+            },
+            {
+                "name": "whenopen",
+                "parameter": "\\_tdintent start"
+            },
+            {
+                "name": "dir3"
+            }
+        ];
+
+        class MockTdClient {
+            openNow(callback) {
+                callback(null, { isopen: true });
+            }
+        };
+        current_index = 1;
+        when_directive = directives[current_index]
+        let dir = new DirWhenOpen({
+            tdclient: new MockTdClient()
+        });
+        dir.execute(when_directive, directives, current_index, () => {
+            assert(directives.length == 4);
+            assert(directives[2].name === "intent");
+            assert(directives[2].parameter === "start");
+            // done();
+        });
+    });
+
+    it('test DirWhenOpen (last directive) checkOpen=false (closed), matching isopen=false', () => {
+        let directives = [
+            {
+                "name": "dir1"
+            },
+            {
+                "name": "dir3"
+            },
+            {
+                "name": "whenopen",
+                "parameter": "\\_tdfakedirective --m \"...\""
+            }
+        ];
+
+        class MockTdClient {
+            openNow(callback) {
+                callback(null, { isopen: false }); // closed
+            }
+        };
+        current_index = 2;
+        when_directive = directives[current_index]
+        let dir = new DirWhenOpen({
+            tdclient: new MockTdClient(),
+            checkOpen: false, // checks closed
+            log: false
+        });
+        dir.execute(when_directive, directives, current_index, () => {
+            assert(directives.length === 4);
+            assert(directives[3].name === "fakedirective");
+            assert(directives[3].parameter === "--m \"...\"");
+        });
+
+    });
+
+});
+
+
+

package/tiledeskChatbotPlugs/CHANGELOG.md

@@ -1,5 +1,7 @@
 # Tiledesk Plugs
 
+### 0.1.9 DirClose added
+
 ### 0.1.8 online - minor fixes
 
 ### 0.1.7 added \_tdDeflectToAgent

package/tiledeskChatbotPlugs/DirectivesChatbotPlug.js

@@ -8,7 +8,13 @@ const { DirWait } = require('./directives/DirWait');
 const { DirReplaceBot } = require('./directives/DirReplaceBot');
 const { DirLockIntent } = require('./directives/DirLockIntent');
 const { DirUnlockIntent } = require('./directives/DirUnlockIntent');
+const { DirDepartment } = require('./directives/DirDepartment');
+const { DirIntent } = require('./directives/DirIntent');
+const { DirWhenOpen } = require('./directives/DirWhenOpen');
+const { DirDisableInputText } = require('./directives/DirDisableInputText');
+const { DirClose } = require('./directives/DirClose');
 const { Directives } = require('./directives/Directives');
+// const { ExtApi } = require('../ExtApi.js');
 
 class DirectivesChatbotPlug {
 
@@ -21,6 +27,7 @@ class DirectivesChatbotPlug {
   constructor(config) {
     this.supportRequest = config.supportRequest;
     this.API_URL = config.TILEDESK_API_ENDPOINT;
+    this.TILEBOT_ENDPOINT = config.TILEBOT_ENDPOINT;
     this.token = config.token;
     this.log = config.log;
     this.HELP_CENTER_API_ENDPOINT = config.HELP_CENTER_API_ENDPOINT;
@@ -61,39 +68,8 @@ class DirectivesChatbotPlug {
 
   }
 
-
-
-  moveToDepartment(tdclient, requestId, depName, callback) {
-    tdclient.getAllDepartments((err, deps) => {
-      console.log("deps:", deps, err);
-      if (err) {
-        console.error("getAllDepartments() error:", err);
-        callback(err);
-        return;
-      }
-      let dep = null;
-      for (i = 0; i < deps.length; i++) {
-        d = deps[i];
-        if (d.name.toLowerCase() === depName.toLowerCase()) {
-          dep = d;
-          break;
-        }
-      }
-      if (dep) {
-        tdclient.updateRequestDepartment(requestId, dep._id, null, (err) => {
-          if (err) {
-            console.error("An error:", err);
-            callback(err);
-          }
-          else {
-            callback();
-          }
-        });
-      }
-    });
-  }
-
-  processDirectives(theend) {
+  processDirectives(message, theend) {
+    if (this.log) { console.log("Directives on message:", message); }
     const directives = this.directives;
     if (!directives || directives.length === 0) {
       if (this.log) { console.log("No directives to process."); }
@@ -103,6 +79,7 @@ class DirectivesChatbotPlug {
     const supportRequest = this.supportRequest;
     const token = this.token;
     const API_URL = this.API_URL;
+    const TILEBOT_ENDPOINT = this.TILEBOT_ENDPOINT;
 
     const requestId = supportRequest.request_id
     const depId = supportRequest.department._id;
@@ -118,7 +95,7 @@ class DirectivesChatbotPlug {
       log: false
     });
 
-    let i = -1;
+    let curr_directive_index = -1;
     if (this.log) { console.log("processing directives:", directives); }
     function process(directive) {
       if (directive) {
@@ -137,9 +114,8 @@ class DirectivesChatbotPlug {
         if (directive.parameter) {
           dep_name = directive.parameter;
         }
-        console.log("department:", dep_name);
-        moveToDepartment(tdclient, requestId, dep_name, () => {
-          console.log("moved to department:", dep_name);
+        const departmentDir = new DirDepartment({tdclient: tdclient, log: false});
+        departmentDir.execute(requestId, dep_name, () => {
           process(nextDirective());
         });
       }
@@ -154,29 +130,68 @@ class DirectivesChatbotPlug {
               subtype: "info"
             }
           };
-          console.log("Message:", message)
           tdclient.sendSupportMessage(requestId, message, () => {
             process(nextDirective());
           });
         }
       }
+      else if (directive_name === Directives.INTENT) {
+        const intentDir = new DirIntent(
+          {
+            API_ENDPOINT: API_URL,
+            TILEBOT_ENDPOINT:TILEBOT_ENDPOINT,
+            log: false
+          }
+        );
+        intentDir.execute(directive, message, projectId, requestId, token, () => {
+          process(nextDirective());
+        });
+      }
       else if (directive_name === Directives.MESSAGE) {
-        const messageDir = new DirMessage({API_ENDPOINT: API_URL});
+        const messageDir = new DirMessage(
+          {
+            API_ENDPOINT: API_URL,
+            TILEBOT_ENDPOINT:TILEBOT_ENDPOINT,
+            log: true
+          }
+        );
         messageDir.execute(directive, projectId, requestId, token, () => {
           process(nextDirective());
         });
       }
+      else if (directive_name === Directives.WHEN_OPEN) {
+        const whenOpenDir = new DirWhenOpen(
+          {
+            tdclient: tdclient // matches open hours
+          });
+        whenOpenDir.execute(directive, directives, curr_directive_index, () => {
+          process(nextDirective());
+        });
+      }
+      else if (directive_name === Directives.WHEN_CLOSED) {
+        const whenOpenDir = new DirWhenOpen(
+          {
+            tdclient: tdclient,
+            checkOpen: false // matches closed hours
+          });
+        whenOpenDir.execute(directive, directives, curr_directive_index, () => {
+          process(nextDirective());
+        });
+      }
       else if (directive_name === Directives.AGENT) {
-        tdclient.log = false;
         const agentDir = new DirMoveToAgent(tdclient);
         directive.whenOnlineOnly = false;
         agentDir.execute(directive, requestId, depId, () => {
           process(nextDirective());
         });
       }
+      else if (directive_name === Directives.CLOSE) {
+        const closeDir = new DirClose({tdclient: tdclient});
+        closeDir.execute(directive, requestId, () => {
+          process(nextDirective());
+        });
+      }
       else if (directive_name === Directives.WHEN_ONLINE_MOVE_TO_AGENT) {
-        // TODO remove this directive and
-        // improve: \agent -whenonline
         const agentDir = new DirMoveToAgent(tdclient);
         directive.whenOnlineOnly = true;
         agentDir.execute(directive, requestId, depId, () => {
@@ -189,7 +204,6 @@ class DirectivesChatbotPlug {
         });
       }
       else if (directive_name === Directives.REPLACE_BOT) {
-        console.log("REPLACE_BOT, requestId:", requestId);
         new DirReplaceBot(tdclient).execute(directive, requestId, () => {
           process(nextDirective());
         });
@@ -217,9 +231,9 @@ class DirectivesChatbotPlug {
     process(nextDirective());
 
     function nextDirective() {
-      i += 1;
-      if (i < directives.length) {
-        let nextd = directives[i];
+      curr_directive_index += 1;
+      if (curr_directive_index < directives.length) {
+        let nextd = directives[curr_directive_index];
         return nextd;
       }
       else {
@@ -270,6 +284,12 @@ class DirectivesChatbotPlug {
           process(nextDirective());
         });
       }
+      else if (directive_name === Directives.DISABLE_INPUT_TEXT) {
+        const disableInputTextDir = new DirDisableInputText();
+        disableInputTextDir.execute(directive, pipeline, () => {
+          process(nextDirective());
+        });
+      }
       else if (directive_name === Directives.DEFLECT_TO_HELP_CENTER) {
         const helpDir = new DirDeflectToHelpCenter({HELP_CENTER_API_ENDPOINT: this.HELP_CENTER_API_ENDPOINT, projectId: projectId});
         helpDir.execute(directive, pipeline, 3, () => {

package/tiledeskChatbotPlugs/directives/DirClose.js

@@ -0,0 +1,25 @@
+
+class DirClose {
+
+    constructor(config) {
+        if (!config.tdclient) {
+            throw new Error('config.tdclient (TiledeskClient) object is mandatory.');
+        }
+        this.tdclient = config.tdclient;
+    }
+    
+    execute(directive, requestId, callback) {
+        this.tdclient.closeRequest(requestId, (err) => {
+            if (err) {
+                console.error("Error in 'close directive':", err);
+            }
+            else {
+                //console.log("Successfully moved to agent during online hours");
+            }
+            callback();
+        });
+    }
+
+  }
+  
+  module.exports = { DirClose };

package/tiledeskChatbotPlugs/directives/DirDeflectToHelpCenter.js

@@ -44,7 +44,7 @@ class DirDeflectToHelpCenter {
         APIKEY: "__",
         APIURL: this.helpcenter_api_endpoint,
         projectId: this.projectId,
-        log: false
+        log: true
       });
       if (!workspace_id) {
         try {
@@ -52,10 +52,10 @@ class DirDeflectToHelpCenter {
           const workspaces = await helpcenter.allWorkspaces();
           if (workspaces.length > 0) {
             workspace_id = workspaces[0]._id;
-            //console.log("First Workspace selected", workspaces[0]);
+            console.log("First Workspace selected", workspaces[0]);
           }
           else {
-            //console.log("No Workspace found");
+            console.log("No Workspace found");
             completion();
           }
         }
@@ -64,12 +64,12 @@ class DirDeflectToHelpCenter {
           completion();
         }
       }
-      
+      console.log("searching on workspace_id:", workspace_id);
       try {
         const results = await helpcenter.search(workspace_id, original_text, maxresults);
         if (results && results.length > 0) {
-          //console.log("Successfully got results", results);
-          //console.log("Sending REPL", hc_reply);
+          console.log("Successfully got results", results);
+          console.log("Sending REPL", hc_reply);
           pipeline.message.text = hc_reply;
           results.forEach(content => {
             if (content.url.charAt(content.url.length -1) != "/") {

package/tiledeskChatbotPlugs/directives/DirDepartment.js

@@ -0,0 +1,52 @@
+
+class DirDepartment {
+
+  constructor(config) {
+    if (!config.tdclient) {
+      throw new Error('tdclient (TiledeskClient) object is mandatory.');
+    }
+    this.tdclient = config.tdclient;
+    this.log = config.log;
+  }
+
+  moveToDepartment(requestId, depName, callback) {
+    this.tdclient.getAllDepartments((err, deps) => {
+      if (this.log) {console.log("deps:", deps, err);}
+      if (err) {
+        console.error("getAllDepartments() error:", err);
+        callback(err);
+        return;
+      }
+      let dep = null;
+      let i;
+      for (i = 0; i < deps.length; i++) {
+        let d = deps[i];
+        if (d.name.toLowerCase() === depName.toLowerCase()) {
+          dep = d;
+          break;
+        }
+      }
+      if (dep) {
+        this.tdclient.updateRequestDepartment(requestId, dep._id, null, (err) => {
+          if (err) {
+            console.error("An error:", err);
+            callback(err);
+          }
+          else {
+            callback();
+          }
+        });
+      }
+    });
+  }
+  
+  execute(requestId, dep_name, callback) {
+    if (this.log) {console.log("DirDepartment:", dep_name);}
+    this.moveToDepartment(requestId, dep_name, () => {
+      callback();
+    });
+  }
+
+}
+
+module.exports = { DirDepartment };

package/tiledeskChatbotPlugs/directives/DirDisableInputText.js

@@ -0,0 +1,45 @@
+const ms = require('minimist-string');
+
+class DirDisableInputText {
+
+  constructor() {
+  }
+
+  execute(directive, pipeline, callback) {
+    // console.log("disable input text...pipeline");
+    let message = pipeline.message
+    if (!message.attributes) {
+      message.attributes = {}
+    }
+    message.attributes.disableInputMessage = true;
+    if (directive.parameter) {
+      const options = this.parseParams(directive.parameter);
+      // console.log("Options", options)
+      directive.options = options;
+      if (options.label) {
+        // console.log("options.label", options.label)
+        message.attributes.inputMessagePlaceholder = options.label;
+      }
+    }
+    callback();
+  }
+
+  parseParams(directive_parameter) {
+    let label = null;
+    const params = ms(directive_parameter);
+    // console.log("params:", params);
+    if (params.l) {
+      // console.log("_param l", params.l);
+      label = params.l;
+    }
+    if (params.label) {
+      // console.log("_param label", params.label);
+      label = params.label;
+    }
+    return {
+      label: label
+    }
+  }
+}
+
+module.exports = { DirDisableInputText };

package/tiledeskChatbotPlugs/directives/DirIntent.js

@@ -0,0 +1,50 @@
+const { ExtApi } = require('../../ExtApi.js');
+
+class DirIntent {
+
+  constructor(settings) {
+    if (!settings.API_ENDPOINT) {
+      throw new Error("settings.API_ENDPOINT is mandatory!");
+    }
+    this.API_ENDPOINT = settings.API_ENDPOINT;
+    this.TILEBOT_ENDPOINT = settings.TILEBOT_ENDPOINT;
+  }
+
+  execute(directive, message, projectId, requestId, token, callback) {
+    if (directive.parameter) {
+      let intent_name = directive.parameter.trim();
+      let message_to_bot = {
+        sender: "system22", // bot doesn't reply to himself
+        text: "/" + intent_name,
+        request: {
+          request_id: requestId
+        },
+        id_project: projectId
+      };
+      // send message to /ext/botId
+      const req_body = {
+        payload: message_to_bot,
+        token: token
+      }
+      let extEndpoint = `${this.API_ENDPOINT}/modules/tilebot`;
+      if (this.TILEBOT_ENDPOINT) {
+        extEndpoint = `${this.TILEBOT_ENDPOINT}`;
+      }
+      const extapi = new ExtApi({
+        ENDPOINT: extEndpoint,
+        log: true
+      });
+      console.log("(sending to bot) incoming message:", message);
+      console.log("(sending to bot) the req_body:", req_body);
+      extapi.sendMessageToBot(req_body, message.attributes.intent_info.botId, token, () => {
+        console.log("sendMessageToBot() req_body sent:", req_body);
+        callback();
+      });
+    }
+    else {
+      callback();
+    }
+  }
+}
+
+module.exports = { DirIntent };

package/tiledeskChatbotPlugs/directives/DirMessage.js

@@ -7,6 +7,7 @@ class DirMessage {
       throw new Error("settings.API_ENDPOINT is mandatory!");
     }
     this.API_ENDPOINT = settings.API_ENDPOINT;
+    this.TILEBOT_ENDPOINT = settings.TILEBOT_ENDPOINT;
   }
 
   execute(directive, projectId, requestId, token, callback) {
@@ -20,11 +21,11 @@ class DirMessage {
           subtype: "info"
         }
       }
-      //console.log("Message:", message);
+      if (this.log) {console.log("Message to extEndpoint:", message)};
       let extEndpoint = `${this.API_ENDPOINT}/modules/tilebot`;
-      //if (process.env.TYBOT_ENDPOINT) {
-      //  extEndpoint = `${process.env.TYBOT_ENDPOINT}`;
-      //}
+      if (this.TILEBOT_ENDPOINT) {
+        extEndpoint = `${this.TILEBOT_ENDPOINT}`;
+      }
       const apiext = new ExtApi({
         ENDPOINT: extEndpoint,
         log: true