@tiledesk/tiledesk-server 2.10.66 → 2.10.68

package/CHANGELOG.md

@@ -5,6 +5,15 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
+# 2.10.68
+- Updated tybot-connector to 0.4.2
+
+# 2.10.67
+- Added route for webhooks
+- Added endpoint to run webhook
+- Added chatbot subtypes
+- Updated tybot-connector to 0.4.0
+
 # 2.10.66
 - Updated QuoteService with new plans
 

package/app.js

@@ -144,6 +144,8 @@ var email = require('./routes/email');
 var property = require('./routes/property');
 var segment = require('./routes/segment');
 var webhook = require('./routes/webhook');
+var webhooks = require('./routes/webhooks');
+var copilot = require('./routes/copilot');
 
 var bootDataLoader = require('./services/bootDataLoader');
 var settingDataLoader = require('./services/settingDataLoader');
@@ -612,7 +614,8 @@ app.use('/:projectid/kb', [passport.authenticate(['basic', 'jwt'], { session: fa
 
 app.use('/:projectid/logs', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], logs);
 
-
+app.use('/:projectid/webhooks', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], webhooks);
+app.use('/:projectid/copilot', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('agent')], copilot);
 
 
 if (pubModulesManager) {

package/models/chatbotTypes.js

@@ -0,0 +1,6 @@
+module.exports = {
+    CHATBOT: 'chatbot',
+    WEBHOOK: 'webhook',
+    COPILOT: 'copilot',
+    VOICE: 'voice'
+}

package/models/faq_kb.js

@@ -43,6 +43,13 @@ var Faq_kbSchema = new Schema({
     default: 'internal',
     index: true
   },
+  subtype: {
+    type: String,
+    default: function() {
+      return this.type === 'tilebot' ? 'chatbot' : undefined;
+    },
+    index: true
+  },
   // external: {
   //   type: Boolean,
   //   default: false

package/models/webhook.js

@@ -0,0 +1,46 @@
+const mongoose = require('mongoose');
+const { customAlphabet } = require('nanoid');
+const nanoid = customAlphabet('abcdefghijklmnopqrstuvwxyz0123456789', 32);
+
+const WebhookSchema = mongoose.Schema({
+  webhook_id: {
+    type: String,
+    default: () => nanoid(),
+    unique: true,
+    required: true
+  },
+  id_project: {
+    type: String,
+    required: true
+  },
+  chatbot_id: {
+    type: String,
+    required: true
+  },
+  block_id: {
+    type: String,
+    required: true,
+  },
+  async: {
+    type: Boolean,
+    required: true,
+    default: true
+  },
+  copilot: {
+    type: Boolean,
+    required: false
+  }
+}, {
+  timestamps: true
+})
+
+WebhookSchema.index({ id_project: 1, chatbot_id: 1}, { unique: true })
+
+const Webhook = mongoose.model("Webhook", WebhookSchema);
+
+if (process.env.MONGOOSE_SYNCINDEX) {
+  Webhook.syncIndexes();
+  winston.verbose("Webhook syncIndexes");
+}
+
+module.exports = { Webhook };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.10.66",
+  "version": "2.10.68",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",
@@ -47,7 +47,7 @@
     "@tiledesk/tiledesk-messenger-connector": "^0.1.23",
     "@tiledesk/tiledesk-rasa-connector": "^1.0.10",
     "@tiledesk/tiledesk-telegram-connector": "^0.1.14",
-    "@tiledesk/tiledesk-tybot-connector": "^0.3.4",
+    "@tiledesk/tiledesk-tybot-connector": "^0.4.2",
     "@tiledesk/tiledesk-whatsapp-connector": "^0.1.81",
     "@tiledesk/tiledesk-whatsapp-jobworker": "^0.0.11",
     "@tiledesk/tiledesk-sms-connector": "^0.1.11",

package/pubmodules/trigger/start.js

@@ -5,6 +5,7 @@ var projectEvent = require('../../event/projectEvent');
 var winston = require('../../config/winston');
 
 var rulesTrigger = require('./rulesTrigger');
+const chatbotTypeConstants = require('../../models/chatbotTypes');
 
 
 function saveTrigger(trigger) {
@@ -20,7 +21,7 @@ projectEvent.on('project.create', async (project) => {
 
 
         
-        var botIdentity = await faqService.create("Bot", undefined, project._id, "system", "identity", "An identity bot");
+        var botIdentity = await faqService.create("Bot", undefined, project._id, "system", "identity", chatbotTypeConstants.CHATBOT, "An identity bot");
         var botIdentityId = "bot_"+botIdentity.id;
         winston.debug("botIdentityId:"+botIdentityId);
 

package/routes/copilot.js

@@ -0,0 +1,80 @@
+let express = require('express');
+let router = express.Router();
+let winston = require('../config/winston');
+const { Webhook } = require('../models/webhook');
+const webhookService = require('../services/webhookService');
+
+router.get('/', async (req, res) => {
+
+    let id_project = req.projectid;
+    let payload = req.body;
+    let params = req.query;
+    let request_id = req.query.request_id;
+    if (!request_id) {
+        return res.status(400).send({ success: false, error: "Missing query params request_id" })
+    }
+    payload.request_id = request_id;
+    payload.webhook_query_params = params;
+
+    let webhooks = await Webhook.find({ id_project: id_project, copilot: true }).catch((err) => {
+        winston.error("Error finding copilot webhooks: ", err);
+        return res.status(500).send({ success: false, error: err });
+    })
+
+    let promises = webhooks.map((w) => 
+        webhookService.run(w, payload)
+            .then((response) => {
+                return response;
+            }).catch((err) => {
+                winston.error("Error running webhook: ", err);
+                return;
+            })
+    )
+
+    Promise.all(promises).then((result) => {
+        return res.status(200).send(result);
+    }).catch((err) => {
+        // Should never executed - check it
+        return res.status(500).send({ success: false, error: err });
+    })
+
+})
+
+router.post('/', async (req, res) => {
+
+    let id_project = req.projectid;
+    let payload = req.body;
+    let params = req.query;
+    let request_id = req.query.request_id;
+    if (!request_id) {
+        return res.status(400).send({ success: false, error: "Missing query params request_id" })
+    }
+    payload.request_id = request_id;
+    payload.webhook_query_params = params;
+
+    let webhooks = await Webhook.find({ id_project: id_project, copilot: true }).catch((err) => {
+        winston.error("Error finding copilot webhooks: ", err);
+        return res.status(500).send({ success: false, error: err });
+    })
+
+    let promises = webhooks.map((w) => 
+        webhookService.run(w, payload)
+            .then((response) => {
+                return response;
+            }).catch((err) => {
+                winston.error("Error running webhook: ", err);
+                return;
+            })
+    )
+
+    Promise.all(promises).then((result) => {
+        return res.status(200).send(result);
+    }).catch((err) => {
+        // Should never executed - check it
+        return res.status(500).send({ success: false, error: err });
+    })
+
+})
+
+
+module.exports = router;

package/routes/faq_kb.js

@@ -50,7 +50,7 @@ router.post('/', roleChecker.hasRole('admin'), async function (req, res) {
     //return res.status(403).send({ success: false, error: "Maximum number of chatbots reached for the current plan", plan_limit: chatbots_limit })
   }
 
-  faqService.create(req.body.name, req.body.url, req.projectid, req.user.id, req.body.type, req.body.description, req.body.webhook_url, req.body.webhook_enabled, req.body.language, req.body.template, req.body.mainCategory, req.body.intentsEngine, req.body.attributes).then(function (savedFaq_kb) {
+  faqService.create(req.body.name, req.body.url, req.projectid, req.user.id, req.body.type, req.body.subtype,  req.body.description, req.body.webhook_url, req.body.webhook_enabled, req.body.language, req.body.template, req.body.mainCategory, req.body.intentsEngine, req.body.attributes).then(function (savedFaq_kb) {
     res.json(savedFaq_kb);
   });
 
@@ -683,7 +683,7 @@ router.post('/importjson/:id_faq_kb', roleChecker.hasRole('admin'), upload.singl
   // **** CREATE TRUE option ****
   // ****************************
   if (req.query.create === 'true') {
-    let savedChatbot = await faqService.create(json.name, undefined, req.projectid, req.user.id, "tilebot", json.description, json.webhook_url, json.webhook_enabled, json.language, undefined, undefined, undefined, json.attributes)
+    let savedChatbot = await faqService.create(json.name, undefined, req.projectid, req.user.id, "tilebot", json.subtype, json.description, json.webhook_url, json.webhook_enabled, json.language, undefined, undefined, undefined, json.attributes)
       .catch((err) => {
           winston.error("Error creating new chatbot")
           return res.status(400).send({ succes: false, message: "Error creatings new chatbot", error: err })
@@ -932,6 +932,7 @@ router.get('/exportjson/:id_faq_kb', roleChecker.hasRole('admin'), (req, res) =>
           language: faq_kb.language,
           name: faq_kb.name,
           type: faq_kb.type,
+          subtype: faq_kb.subtype,
           description: faq_kb.description,
           attributes: faq_kb.attributes,
           intents: intents

package/routes/webhook.js

@@ -1,10 +1,23 @@
 var express = require('express');
 var router = express.Router();
+const uuidv4 = require('uuid/v4');
 var { KB, Namespace } = require('../models/kb_setting');
 var winston = require('../config/winston');
 const JobManager = require('../utils/jobs-worker-queue-manager/JobManagerV2');
 const { Scheduler } = require('../services/Scheduler');
 const { AiReindexService } = require('../services/aiReindexService');
+const { Webhook } = require('../models/webhook');
+const httpUtil = require('../utils/httpUtil');
+var jwt = require('jsonwebtoken');
+const Faq_kb = require('../models/faq_kb');
+const webhookService = require('../services/webhookService');
+
+const port = process.env.PORT || '3000';
+let TILEBOT_ENDPOINT = "http://localhost:" + port + "/modules/tilebot/";;
+if (process.env.TILEBOT_ENDPOINT) {
+    TILEBOT_ENDPOINT = process.env.TILEBOT_ENDPOINT + "/"
+}
+winston.debug("TILEBOT_ENDPOINT: " + TILEBOT_ENDPOINT);
 
 const KB_WEBHOOK_TOKEN = process.env.KB_WEBHOOK_TOKEN || 'kbcustomtoken';
 const AMQP_MANAGER_URL = process.env.AMQP_MANAGER_URL;
@@ -167,6 +180,63 @@ router.post('/kb/status', async (req, res) => {
 
 })
 
+router.all('/:webhook_id', async (req, res) => {
+
+  let webhook_id = req.params.webhook_id;
+  let payload = req.body;
+  payload.webhook_http_method = req.method;
+  let params = req.query;
+  if (params) {
+    payload.webhook_query_params = params;
+  }
+
+  let webhook = await Webhook.findOne({ webhook_id: webhook_id }).catch((err) => {
+    winston.error("Error finding webhook: ", err);
+    return res.status(500).send({ success: false, error: err });
+  })
+
+  if (!webhook) {
+    winston.warn("Webhook not found with id " + webhook_id);
+    return res.status(404).send({ success: false, error: "Webhook not found with id " + webhook_id });
+  }
+
+  webhookService.run(webhook, payload).then((response) => {
+    return res.status(200).send(response);
+  }).catch((err) => {
+    let status = err.status || 500;
+    return res.status(status).send(err.data);
+  })
+  
+  // let chatbot = await Faq_kb.findById(webhook.chatbot_id).select("+secret").catch((err) => {
+  //   winston.error("Error finding chatbot ", err);
+  //   return res.status(500).send({ success: false, error: "Error finding chatbot with id " + webhook.chatbot_id})
+  // })
+
+  // if (!chatbot) {
+  //   winston.verbose("Chatbot not found with id " + webhook.chatbot_id);
+  //   return res.status(404).send({ success: false, error: "Chatbot not found with id " + webhook.chatbot_id })
+  // }
+
+  // let token = await generateChatbotToken(chatbot);
+
+  // let url = TILEBOT_ENDPOINT + 'block/' + webhook.id_project + "/" + webhook.chatbot_id + "/" + webhook.block_id;
+  // winston.info("Webhook chatbot URL: ", url);
+
+  // payload.async = webhook.async;
+  // payload.token = token;
+
+  // if (process.env.NODE_ENV === 'test') {
+  //   return res.status(200).send({ success: true, message: "Webhook disabled in test mode"})
+  // }
+  
+  // let response = await httpUtil.post(url, payload).catch((err) => {
+  //   winston.error("Error calling webhook on post: ", err);
+  //   return res.status(500).send({ success: false, error: err });
+  // })
+
+  // res.status(200).send(response.data);
+})
+
 async function scheduleScrape(resources) {
 
   let scheduler = new Scheduler({ jobManager: jobManager });
@@ -185,4 +255,19 @@ async function scheduleScrape(resources) {
   return true;
 }
 
+async function generateChatbotToken(chatbot) {
+  let signOptions = {
+    issuer: 'https://tiledesk.com',
+    subject: 'bot',
+    audience: 'https://tiledesk.com/bots/' + chatbot._id,
+    jwtid: uuidv4()
+  };
+
+  let botPayload = chatbot.toObject();
+  let botSecret = botPayload.secret;
+
+  var bot_token = jwt.sign(botPayload, botSecret, signOptions);
+  return bot_token;
+}
+
 module.exports = router;

package/routes/webhooks.js

@@ -0,0 +1,156 @@
+var express = require('express');
+var router = express.Router();
+var winston = require('../config/winston');
+const { Webhook } = require('../models/webhook');
+const httpUtil = require('../utils/httpUtil');
+const { customAlphabet } = require('nanoid');
+const nanoid = customAlphabet('abcdefghijklmnopqrstuvwxyz0123456789', 32);
+
+// const port = process.env.PORT || '3000';
+// let TILEBOT_ENDPOINT = "http://localhost:" + port + "/modules/tilebot/ext/";;
+// if (process.env.TILEBOT_ENDPOINT) {
+//     TILEBOT_ENDPOINT = process.env.TILEBOT_ENDPOINT + "/ext/"
+// }
+// winston.debug("TILEBOT_ENDPOINT: " + TILEBOT_ENDPOINT);
+
+
+router.get('/:chatbot_id/', async (req, res) => {
+  
+  let id_project = req.projectid;
+  let chatbot_id = req.params.chatbot_id;
+
+  let webhook = await Webhook.findOne({ id_project: id_project, chatbot_id: chatbot_id }).catch((err) => {
+    winston.error("Error finding webhook: ", err);
+    return res.status(500).send({ success: false, error: "Error findin webhook with for chatbot " + chatbot_id });
+  })
+
+  if (!webhook) {
+    winston.verbose("Webhook not found for chatbot " + chatbot_id);
+    return res.status(404).send({ success: false, error: "Webhook not found for chatbot " + chatbot_id });
+  }
+
+  res.status(200).send(webhook);
+
+})
+
+
+router.post('/', async (req, res) => {
+
+  let id_project = req.projectid;
+
+  let webhook = new Webhook({
+    id_project: id_project,
+    chatbot_id: req.body.chatbot_id || req.body.id_faq_kb,
+    block_id: req.body.block_id,
+    async: req.body.async
+  })
+
+  webhook.save((err, savedWebhook) => {
+    if (err) {
+      if (err.code === 11000) {
+        winston.verbose("Webhook already exists for chatbot " + chatbot_id);
+        return res.status(403).send({ success: false, message: "Webhook already exists for chatbot " + chatbot_id });
+      } 
+      winston.error("Error saving new webhook ", err);
+      return res.status(500).send({ success: false, error: err });
+    }
+
+    res.status(200).send(savedWebhook);
+  })
+
+})
+
+// router.post('/webhook_id', async (req, res) => {
+
+//   let id_project = req.projectid;
+//   let webhook_id = req.params.webhook_id;
+//   let payload = req.body;
+
+//   let webhook = await Webhook.findOne({ id_project: id_project, webhook_id: webhook_id }).catch((err) => {
+//     winston.error("Error finding webhook: ", err);
+//     return res.status(500).send({ success: false, error: err });
+//   })
+
+//   if (!webhook) {
+//     winston.warn("Webhook not found with id " + webhook_id);
+//     return res.status(404).send({ success: false, error: "Webhook not found with id " + webhook_id });
+//   }
+
+//   let url = TILEBOT_ENDPOINT + 'block/' + id_project + "/" + webhook.chatbot_id + "/" + webhook.block_id;
+
+//   payload.async = webhook.async;
+  
+//   let response = httpUtil.post(url, payload).catch((err) => {
+//     winston.error("Error calling webhook on post: ", err);
+//     return res.status(500).send({ success: false, error: err });
+//   })
+
+//   res.status(200).send(response);
+
+// })
+
+router.put("/:chatbot_id/regenerate", async (req, res) => {
+  
+  let id_project = req.projectid;
+  let chatbot_id = req.params.chatbot_id;
+
+  let update = {
+    webhook_id: nanoid()
+  }
+
+  let updatedWebhook = await Webhook.findOneAndUpdate({ id_project: id_project, chatbot_id: chatbot_id }, update, { new: true }).catch((err) => {
+    winston.error("Error updating webhook ", err);
+    return res.status(500).send({ success: false, error: "Error updating webhook for chatbot " + chatbot_id });
+  })
+
+  if (!updatedWebhook) {
+    winston.verbose("Webhook not found for chatbot " + chatbot_id);
+    return res.status(404).send({ success: false, error: "Webhook not found for chatbot " + chatbot_id });
+  }
+
+  res.status(200).send(updatedWebhook);
+})
+
+router.put("/:chatbot_id", async (req, res) => {
+
+  let id_project = req.projectid;
+  let chatbot_id = req.params.chatbot_id;
+
+  let update = {};
+
+  if (req.body.hasOwnProperty("async")) {
+    update.async = req.body.async;
+  }
+
+  if (req.body.hasOwnProperty("copilot")) {
+    update.copilot = req.body.copilot;
+  }
+
+  let updatedWebhook = await Webhook.findOneAndUpdate({ id_project: id_project, chatbot_id: chatbot_id }, update, { new: true }).catch((err) => {
+    winston.error("Error updating webhook ", err);
+    return res.status(500).send({ success: false, error: "Error updating webhook for chatbot " + chatbot_id });
+  })
+
+  if (!updatedWebhook) {
+    winston.verbose("Webhook not found for chatbot " + chatbot_id);
+    return res.status(404).send({ success: false, error: "Webhook not found for chatbot " + chatbot_id });
+  }
+
+  res.status(200).send(updatedWebhook);
+})
+
+router.delete("/:chatbot_id", async (req, res) => {
+
+  let id_project = req.projectid;
+  let chatbot_id = req.params.chatbot_id;
+
+  await Webhook.deleteOne({ id_project: id_project, chatbot_id: chatbot_id }).catch((err) => {
+    winston.error("Error deleting webhook ", err);
+    return res.status(500).send({ success: false, error: "Error deleting webhook for chatbot " + chatbot_id });
+  })
+
+  res.status(200).send({ success: true, message: "Webhook for chatbot " + chatbot_id +  " deleted successfully" });
+})
+
+
+module.exports = router;

package/services/QuoteManager.js

@@ -207,7 +207,6 @@ class QuoteManager {
      * Get current quote for a single type (tokens or request or ...)
      */
     async getCurrentQuote(project, object, type) {
-
         this.project = project;
         let key = await this.generateKey(object, type);
         winston.verbose("[QuoteManager] getCurrentQuote key: " + key);