@tiledesk/tiledesk-tybot-connector 0.1.13 → 0.1.16

package/CHANGELOG.md

@@ -1,13 +1,25 @@
 # Tiledesk tybotRoute
 
-**npm @tiledesk/tiledesk-tybot-connector@0.1.13**
+**npm @tiledesk/tiledesk-tybot-connector@0.1.16**
 
 available on:
  ▶️ https://www.npmjs.com/package/@tiledesk/tiledesk-tybot-connector
 
+### 0.1.16
+- added Redis support to share some parameters (message.requestId, message.projectId) with Apps
+
+### 0.1.15
+- refactored with the models/TiledeskChatbot class
+- added triggeredByMessageId property to the bot reply
+- added "tdMessageId" parameter to be used during processing
+
+### 0.1.14 online
+- more replaceAll moved to replace(//)
+- console.log clean
+
 ### 0.1.13 online
 - replaceAll replaced by replace(//)
-- TEMP: const depId = supportRequest.department._id;
+- TEMP: const depId = supportRequest.department._id
 
 ### 0.1.12 online - TEMP: const depId = supportRequest.department._id;
 

package/ExtApi.js

@@ -38,7 +38,6 @@ class ExtApi {
     const jwt_token = this.fixToken(token);
     const url = `${this.ENDPOINT}/ext/${projectId}/requests/${requestId}/messages`;
     if (this.log) {console.log("sendSupportMessageExt URL", url);}
-    console.log("sendSupportMessageExt:", url);
     const HTTPREQUEST = {
       url: url,
       headers: {
@@ -51,8 +50,9 @@ class ExtApi {
     this.myrequest(
       HTTPREQUEST,
       function(err, resbody) {
-        console.log("sendSupportMessageExt resbody:", resbody);
+        //console.log("sendSupportMessageExt resbody:", resbody);
         if (err) {
+          //console.error("sendSupportMessageExt error:", err)
           if (callback) {
             callback(err);
           }
@@ -104,18 +104,6 @@ class ExtApi {
       }
     });
   }
-/*
-  static async execPipelineExt(static_bot_answer, directivesPlug) {
-    const messagePipeline = new MessagePipeline(static_bot_answer, null);
-    //const webhookurl = bot.webhook_url;
-    //messagePipeline.addPlug(new WebhookChatbotPlug(message.request, webhookurl, token));
-    messagePipeline.addPlug(directivesPlug);
-    messagePipeline.addPlug(new SplitsChatbotPlug(this.log));
-    messagePipeline.addPlug(new MarkbotChatbotPlug(this.log));
-    const bot_answer = await messagePipeline.exec();
-    if (this.log) {console.log("End pipeline ext, bot_answer:", JSON.stringify(bot_answer));}
-    return bot_answer;
-  }*/
 }
 
 module.exports = { ExtApi };

package/ExtUtil.js

@@ -3,7 +3,8 @@ const { MessagePipeline } = require('./tiledeskChatbotPlugs/MessagePipeline');
 const { DirectivesChatbotPlug } = require('./tiledeskChatbotPlugs/DirectivesChatbotPlug');
 const { SplitsChatbotPlug } = require('./tiledeskChatbotPlugs/SplitsChatbotPlug');
 const { MarkbotChatbotPlug } = require('./tiledeskChatbotPlugs/MarkbotChatbotPlug');
-const { WebhookChatbotPlug } = require('./tiledeskChatbotPlugs/WebhookChatbotPlug');
+const { FillParamsChatbotPlug } = require('./tiledeskChatbotPlugs/FillParamsChatbotPlug');
+//const { WebhookChatbotPlug } = require('./tiledeskChatbotPlugs/WebhookChatbotPlug');
 
 // PROD
 /*const { MessagePipeline } =  require('@tiledesk/tiledesk-chatbot-plugs/MessagePipeline');
@@ -14,13 +15,15 @@ const { WebhookChatbotPlug } = require('@tiledesk/tiledesk-chatbot-plugs/Webhook
 
 class ExtUtil {
 
-  static async execPipelineExt(static_bot_answer, directivesPlug) {
+  static async execPipelineExt(request, static_bot_answer, directivesPlug, tdcache, log) {
     const messagePipeline = new MessagePipeline(static_bot_answer, null);
     //const webhookurl = bot.webhook_url;
     //messagePipeline.addPlug(new WebhookChatbotPlug(message.request, webhookurl, token));
+    messagePipeline.addPlug(new FillParamsChatbotPlug(request, tdcache, log)); // in original message
     messagePipeline.addPlug(directivesPlug);
-    messagePipeline.addPlug(new SplitsChatbotPlug(this.log));
-    messagePipeline.addPlug(new MarkbotChatbotPlug(this.log));
+    messagePipeline.addPlug(new SplitsChatbotPlug(log));
+    messagePipeline.addPlug(new MarkbotChatbotPlug(log));
+    messagePipeline.addPlug(new FillParamsChatbotPlug(request, tdcache, log)); // in splits
     const bot_answer = await messagePipeline.exec();
     if (this.log) {console.log("End pipeline ext, bot_answer:", JSON.stringify(bot_answer));}
     return bot_answer;

package/TdCache.js

@@ -0,0 +1,170 @@
+const redis = require('redis');
+
+class TdCache {
+
+    constructor(config) {
+        this.redis_host = config.host;
+        this.redis_port = config.port;
+        this.redis_password = config.password;
+        this.client = null;
+    }
+
+    async connect(callback) {
+        // client = redis.createClient();
+        return new Promise( async (resolve, reject) => {
+            this.client = redis.createClient(
+                {
+                    host: this.redis_host,
+                    port: this.redis_port,
+                    password: this.redis_password
+                });
+            this.client.on('error', err => {
+                console.log('Redis connection error', err);
+                reject(err);
+                if (callback) {
+                    callback(err);
+                }
+            });
+            // this.client.on('connect', function() {
+            //     console.log('Redis Connected!');
+            // });
+            this.client.on('ready',function() {
+                resolve();
+                if (callback) {
+                    callback();
+                }
+                //console.log("Redis is ready.");
+            });
+        });
+    }
+
+    async set(key, value, options) {
+      //console.log("setting key value", key, value)
+      return new Promise( async (resolve, reject) => {
+        if (options && options.EX) {
+          //console.log("expires:", options.EX)
+          try {
+            await this.client.set(
+              key,
+              value,
+              'EX', options.EX);
+          }
+          catch(error) {
+            reject(error)
+          }
+        }
+        else {
+          try {
+            //console.log("setting here...key", key, value)
+            await this.client.set(
+              key,
+              value);
+          }
+          catch(error) {
+            console.error("Error", error);
+            reject(error)
+          }
+        }
+        if (options && options.callback) {
+            options.callback();
+        }
+        //console.log("resolving...", key);
+        return resolve();
+      });
+    }
+
+    async hset(dict_key, key, value, options) {
+      //console.log("hsetting dict_key key value", dict_key, key, value)
+      return new Promise( async (resolve, reject) => {
+        if (options && options.EX) {
+          //console.log("expires:", options.EX)
+          try {
+            await this.client.hset(
+              dict_key,
+              key,
+              value,
+              'EX', options.EX);
+          }
+          catch(error) {
+            reject(error)
+          }
+        }
+        else {
+          try {
+            //console.log("setting here...key", key, value)
+            await this.client.hset(
+              dict_key,
+              key,
+              value);
+          }
+          catch(error) {
+            console.error("Error", error);
+            reject(error)
+          }
+        }
+        if (options && options.callback) {
+            options.callback();
+        }
+        return resolve();
+      });
+    }
+    
+    async setJSON(key, value, options) {
+      const _string = JSON.stringify(value);
+      return await this.set(key, _string, options);
+    }
+    
+    async get(key, callback) {
+      //console.log("getting key", key)
+      return new Promise( async (resolve, reject) => {
+        this.client.get(key, (err, value) => {
+          if (err) {
+            reject(err);
+          }
+          else {
+            if (callback) {
+              callback(value);
+          }
+          return resolve(value);
+          }
+        });
+      });
+    }
+
+    async hgetall(dict_key, callback) {
+      //console.log("hgetting dics", dict_key);
+      return new Promise( async (resolve, reject) => {
+        this.client.hgetall(dict_key, (err, value) => {
+          if (err) {
+            reject(err);
+            if (callback) {
+              callback(err, null);
+            }
+          }
+          else {
+            if (callback) {
+              callback(null, value);
+            }
+            resolve(value);
+          }
+        });
+      });
+    }
+    
+    async getJSON(key, callback) {
+      const value = await this.get(key);
+      return JSON.parse(value);
+    }
+    
+    async del(key, callback) {
+      return new Promise( async (resolve, reject) => {
+        await this.client.del(key);
+        if (callback) {
+            callback();
+        }
+        return resolve();
+      })
+    }
+}
+
+module.exports = { TdCache };