@tiledesk/tiledesk-server 2.10.87 → 2.10.89

package/routes/webhook.js

@@ -11,6 +11,8 @@ const httpUtil = require('../utils/httpUtil');
 var jwt = require('jsonwebtoken');
 const Faq_kb = require('../models/faq_kb');
 const webhookService = require('../services/webhookService');
+const errorCodes = require('../errorCodes');
+var ObjectId = require('mongoose').Types.ObjectId;
 
 const port = process.env.PORT || '3000';
 let TILEBOT_ENDPOINT = "http://localhost:" + port + "/modules/tilebot/";;
@@ -186,6 +188,8 @@ router.all('/:webhook_id', async (req, res) => {
   let payload = req.body;
   payload.webhook_http_method = req.method;
   let params = req.query;
+  let dev = params.dev;
+  delete params.dev;
   if (params) {
     payload.webhook_query_params = params;
   }
@@ -200,41 +204,66 @@ router.all('/:webhook_id', async (req, res) => {
     return res.status(404).send({ success: false, error: "Webhook not found with id " + webhook_id });
   }
 
-  webhookService.run(webhook, payload).then((response) => {
+  if (!webhook.enabled) {
+    winston.verbose("Webhook " + webhook_id + " is currently turned off")
+    return res.status(422).send({ success: false, error: "Webhook " + webhook_id + " is currently turned off"})
+  }
+
+  payload.request_id = "automation-request-" + webhook.id_project + "-" + new ObjectId() + "-" + webhook_id;
+
+  // To delete - Start
+  // This endpoint will be used only for production webhooks, so is no longer
+  // necessary to pass dev and redis_client to webhookService.run().
+  let redis_client = req.app.get('redis_client');
+  // and substitute currect run with the following one
+  //webhookService.run(webhook, payload)
+  // To delete - End
+  webhookService.run(webhook, payload, dev, redis_client).then((response) => {
     return res.status(200).send(response);
   }).catch((err) => {
-    let status = err.status || 500;
-    return res.status(status).send(err.data);
+    if (err.code === errorCodes.WEBHOOK.ERRORS.NO_PRELOADED_DEV_REQUEST) {
+      return res.status(422).send({ success: false, message: "Development webhook is currently turned off", code: err.code })
+    } else {
+      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 })
-  // }
+router.all('/:webhook_id/dev', async (req, res) => {
 
-  // let token = await generateChatbotToken(chatbot);
+  let webhook_id = req.params.webhook_id;
+  let payload = req.body;
+  payload.webhook_http_method = req.method;
+  let params = req.query;
+  delete params.dev;
+  if (params) {
+    payload.webhook_query_params = params;
+  }
 
-  // let url = TILEBOT_ENDPOINT + 'block/' + webhook.id_project + "/" + webhook.chatbot_id + "/" + webhook.block_id;
-  // winston.info("Webhook chatbot URL: ", url);
+  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 });
+  })
 
-  // payload.async = webhook.async;
-  // payload.token = token;
+  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 });
+  }
 
-  // if (process.env.NODE_ENV === 'test') {
-  //   return res.status(200).send({ success: true, message: "Webhook disabled in test mode"})
-  // }
+  let redis_client = req.app.get('redis_client');
+  webhookService.run(webhook, payload, true, redis_client).then((response) => {
+    return res.status(200).send(response);
+  }).catch((err) => {
+    if (err.code === errorCodes.WEBHOOK.ERRORS.NO_PRELOADED_DEV_REQUEST) {
+      return res.status(422).send({ success: false, message: "Development webhook is currently turned off", code: err.code })
+    } else {
+      let status = err.status || 500;
+      return res.status(status).send(err.data);
+    }
+  })
   
-  // 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) {

package/routes/webhooks.js

@@ -5,7 +5,7 @@ const { Webhook } = require('../models/webhook');
 const httpUtil = require('../utils/httpUtil');
 const { customAlphabet } = require('nanoid');
 const nanoid = customAlphabet('abcdefghijklmnopqrstuvwxyz0123456789', 32);
-
+var ObjectId = require('mongoose').Types.ObjectId;
 // const port = process.env.PORT || '3000';
 // let TILEBOT_ENDPOINT = "http://localhost:" + port + "/modules/tilebot/ext/";;
 // if (process.env.TILEBOT_ENDPOINT) {
@@ -13,8 +13,20 @@ const nanoid = customAlphabet('abcdefghijklmnopqrstuvwxyz0123456789', 32);
 // }
 // winston.debug("TILEBOT_ENDPOINT: " + TILEBOT_ENDPOINT);
 
+router.get('/', async (req, res) => {
+  
+  let id_project = req.projectid;
+
+  let webhooks = await Webhook.find({ id_project: id_project }).catch((err) => {
+    winston.error("Error finding webhooks: ", err);
+    return res.status(500).send({ success: false, error: "Error findin webhooks with for project " + id_project });
+  })
 
-router.get('/:chatbot_id/', async (req, res) => {
+  res.status(200).send(webhooks);
+
+})
+
+router.get('/:chatbot_id', async (req, res) => {
   
   let id_project = req.projectid;
   let chatbot_id = req.params.chatbot_id;
@@ -33,6 +45,24 @@ router.get('/:chatbot_id/', async (req, res) => {
 
 })
 
+router.get('/id/:webhook_id', async (req, res) => {
+
+  let id_project = req.projectid;
+  let webhook_id = req.params.webhook_id;
+
+  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: "Error findin webhook with id " + webhook_id });
+  })
+
+  if (!webhook) {
+    winston.verbose("Webhook not found with id " + webhook_id);
+    return res.status(404).send({ success: false, error: "Webhook not found with id " + webhook_id });
+  }
+
+  res.status(200).send(webhook);
+})
+
 
 router.post('/', async (req, res) => {
 
@@ -40,6 +70,7 @@ router.post('/', async (req, res) => {
 
   let webhook = new Webhook({
     id_project: id_project,
+    name: "webhook-" + this.webhook_id,
     chatbot_id: req.body.chatbot_id || req.body.id_faq_kb,
     block_id: req.body.block_id,
     copilot: req.body.copilot,
@@ -61,6 +92,42 @@ router.post('/', async (req, res) => {
 
 })
 
+router.post('/preload/:webhook_id', async (req, res) => {
+
+  let id_project = req.projectid;
+  let webhook_id = req.params.webhook_id;
+  let request_id = "automation-request-" + id_project + "-" + new ObjectId() + "-" + webhook_id;
+  let redis_client = req.app.get('redis_client');
+
+  try {
+    let key = "logs:webhook:" + id_project + ":" + webhook_id;
+    let value = JSON.stringify({ request_id: request_id });
+    redis_client.set(key, value, { EX: 900 });
+    res.status(200).send({ success: true, message: "Webhook preloaded successfully", request_id: request_id });
+  } catch(err) {
+    winston.error("Error adding key in cache ", err);
+    res.status(500).send({ success: false, message: "Unable to start development webhook" })
+  }
+
+})
+
+router.delete('/preload/:webhook_id', async (req, res) => {
+  
+  let id_project = req.projectid;
+  let webhook_id = req.params.webhook_id;
+  let key = "logs:webhook:" + id_project + ":" + webhook_id;
+  let redis_client = req.app.get('redis_client');
+  
+  try {
+    await redis_client.del(key);
+    res.status(200).send({ success: true, message: "Development webhook stopped" })
+  } catch(err) {
+    winston.error("Error deleting key from cache ", err);
+    res.status(500).send({ success: false, message: "Unable to stop development webhook" })
+  }
+
+})
+
 // router.post('/webhook_id', async (req, res) => {
 
 //   let id_project = req.projectid;
@@ -127,6 +194,10 @@ router.put("/:chatbot_id", async (req, res) => {
     update.copilot = req.body.copilot;
   }
 
+  if (req.body.hasOwnProperty('enabled')) {
+    update.enabled = req.body.enabled;
+  }
+
   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 });
@@ -140,6 +211,39 @@ router.put("/:chatbot_id", async (req, res) => {
   res.status(200).send(updatedWebhook);
 })
 
+router.put('/update/:webhook_id', async (req, res) => {
+  
+  let id_project = req.projectid;
+  let webhook_id = req.params.webhook_id;
+
+  let update = {};
+
+  if (req.body.hasOwnProperty("async")) {
+    update.async = req.body.async;
+  }
+
+  if (req.body.hasOwnProperty("copilot")) {
+    update.copilot = req.body.copilot;
+  }
+
+  if (req.body.hasOwnProperty('enabled')) {
+    update.enabled = req.body.enabled;
+  }
+
+  let updatedWebhook = await Webhook.findOneAndUpdate({ id_project: id_project, webhook_id: webhook_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 with id " + webhook_id);
+    return res.status(404).send({ success: false, error: "Webhook not found with id " + webhook_id });
+  }
+
+  res.status(200).send(updatedWebhook);
+
+})
+
 router.delete("/:chatbot_id", async (req, res) => {
 
   let id_project = req.projectid;
@@ -153,5 +257,18 @@ router.delete("/:chatbot_id", async (req, res) => {
   res.status(200).send({ success: true, message: "Webhook for chatbot " + chatbot_id +  " deleted successfully" });
 })
 
+router.delete("/delete/:webhook_id", async (req, res) => {
+
+  let id_project = req.projectid;
+  let webhook_id = req.params.webhook_id;
+
+  await Webhook.deleteOne({ id_project: id_project, webhook_id: webhook_id }).catch((err) => {
+    winston.error("Error deleting webhook ", err);
+    return res.status(500).send({ success: false, error: "Error deleting webhook with id " + webhook_id });
+  })
+
+  res.status(200).send({ success: true, message: "Webhook " + webhook_id +  " deleted successfully" });
+})
+
 
 module.exports = router;

package/services/chatbotService.js

@@ -1,15 +1,13 @@
 const axios = require("axios").default;
 const winston = require('../config/winston');
-var Faq_kb = require("../models/faq_kb");
+let Faq_kb = require("../models/faq_kb");
 
 class ChatbotService {
 
-  constructor() {
-    
-  }
+  constructor() {}
 
   async fork(id_faq_kb, api_url, token, project_id) {
-    winston.debug("[CHATBOT SERVICE] fork");
+    winston.debug("(ChatbotService) fork");
 
     return await axios({
       url: api_url + '/' + project_id + '/faq_kb/fork/'+id_faq_kb+"?projectid="+project_id+"&public=false&globals=true",
@@ -20,10 +18,10 @@ class ChatbotService {
       // data: chatbot,
       method: 'POST'
     }).then((resbody) => {
-      winston.debug("(CHATBOT SERVICE) fork resbody: ", resbody.data);
+      winston.debug("(ChatbotService) fork resbody: ", resbody.data);
       return resbody.data;
     }).catch((err) => {
-      winston.error("(CHATBOT SERVICE) fork error " + err);
+      winston.error("(ChatbotService) fork error " + err);
       return err;
     })
 
@@ -31,7 +29,7 @@ class ChatbotService {
 
   async getBotById(id_faq_kb, published, api_url, chatbot_templates_api_url, token, project_id, globals) {
 
-    winston.debug("[CHATBOT SERVICE] getBotById");
+    winston.debug("(ChatbotService) getBotById");
 
     // private bot
     if (published == "false") {
@@ -44,11 +42,11 @@ class ChatbotService {
         },
         method: 'GET'
       }).then((resbody) => {
-        winston.debug("(CHATBOT SERVICE) forking private chatbot " + resbody.data.name)
+        winston.debug("(ChatbotService) forking private chatbot " + resbody.data.name)
         let chatbot = resbody.data;
         return chatbot;
       }).catch((err) => {
-        winston.error('(CHATBOT SERVICE) FAQ_KB EXPORTJSON ERROR ' + err);
+        winston.error('(ChatbotService) FAQ_KB EXPORTJSON ERROR ' + err);
         return err;
       })
 
@@ -62,11 +60,11 @@ class ChatbotService {
         },
         method: 'GET'
       }).then((resbody) => {
-        winston.debug("(CHATBOT SERVICE) forking public chatbot " + resbody.data.name);
+        winston.debug("(ChatbotService) forking public chatbot " + resbody.data.name);
         let chatbot = resbody.data;
         return chatbot
       }).catch((err) => {
-        winston.error('(CHATBOT SERVICE) FAQ_KB CHATBOT TEMPLATES ERROR ' + err);
+        winston.error('(ChatbotService) FAQ_KB CHATBOT TEMPLATES ERROR ' + err);
         return err;
       })
     }
@@ -75,7 +73,7 @@ class ChatbotService {
 
   async createBot(api_url, token, chatbot, project_id) {
 
-    winston.debug("(CHATBOT SERVICE) createBot");
+    winston.debug("(ChatbotService) createBot");
 
     return await axios({
       url: api_url + '/' + project_id + '/faq_kb/',
@@ -86,10 +84,10 @@ class ChatbotService {
       data: chatbot,
       method: 'POST'
     }).then((resbody) => {
-      winston.debug("(CHATBOT SERVICE) createBot resbody: ", resbody.data);
+      winston.debug("(ChatbotService) createBot resbody: ", resbody.data);
       return resbody.data;
     }).catch((err) => {
-      winston.error("(CHATBOT SERVICE) CREATE NEW CHATBOT ERROR " + err);
+      winston.error("(ChatbotService) CREATE NEW CHATBOT ERROR " + err);
       return err;
     })
 
@@ -97,7 +95,7 @@ class ChatbotService {
 
   async importFaqs(api_url, id_faq_kb, token, chatbot, project_id) {
   
-    winston.debug("[CHATBOT SERVICE] importFaqs");
+    winston.debug("(ChatbotService) importFaqs");
 
     return await axios({
       url: api_url + '/' + project_id + '/faq_kb/importjson/' + id_faq_kb + "?intentsOnly=true",
@@ -108,14 +106,22 @@ class ChatbotService {
       data: chatbot,
       method: 'POST'
     }).then((resbody) => {
-      winston.debug("(CHATBOT SERVICE) importFaqs resbody: ", resbody.data);
+      winston.debug("(ChatbotService) importFaqs resbody: ", resbody.data);
       return resbody.data;
     }).catch((err) => {
-      winston.error("(CHATBOT SERVICE) IMPORT FAQS ERROR " + err);
+      winston.error("(ChatbotService) IMPORT FAQS ERROR " + err);
       return err;
     })
   }
 
+  async setModified(chatbot_id, modified) {
+    return Faq_kb.findByIdAndUpdate(chatbot_id, { modified: modified }).then((faqKb) => {
+        winston.debug("(ChatbotService) set chatbot to modified response: ", faqKb);
+        return true;
+      }).catch((err) => {
+        return Promise.reject(err);
+      });
+  }
 }
 
 module.exports = { ChatbotService }