@tiledesk/tiledesk-server 2.28.1 → 2.29.0

package/routes/faq_kb.js

@@ -19,6 +19,10 @@ var roleChecker = require('../middleware/has-role');
 const roleConstants = require('../models/roleConstants');
 const errorCodes = require('../errorCodes');
 const faq_kb = require('../models/faq_kb');
+const chatbotController = require('../controllers/chatbot.controller');
+const intentsController = require('../controllers/intents.controller');
+const AppError = require('../utils/AppError');
+const asyncHandler = require('../utils/asyncHandler');
 
 let chatbot_templates_api_url = process.env.CHATBOT_TEMPLATES_API_URL
 
@@ -261,57 +265,100 @@ router.put('/:faq_kbid/publish', roleChecker.hasRole('admin'), async (req, res)
   }
 
   const api_url = process.env.API_URL || configGlobal.apiUrl;
-  winston.debug("fork --> base_url: " + api_url); // check if correct
+  winston.debug("fork --> base_url: " + api_url);
 
-  let current_project_id = req.projectid;
-  winston.debug("current project id: " + current_project_id);
-
-  let token = req.headers.authorization;
-
-  let cs = req.app.get('chatbot_service')
+  const cs = req.app.get('chatbot_service');
 
   try {
-    //  fork(id_faq_kb, api_url, token, project_id)
-    let forked = await cs.fork(chatbot_id, api_url, token, current_project_id, { forPublish: true });
-    // winston.debug("forked: ", forked)
-
-    let forkedChatBotId = forked.bot_id;
-    winston.debug("forkedChatBotId: " + forkedChatBotId);
+    const published = await cs.publish({
+      id_faq_kb,
+      chatbot_id,
+      api_url,
+      token: req.headers.authorization,
+      project_id: req.projectid,
+      user_id: req.user.id,
+      release_note,
+      req
+    });
 
-    let updatedForkedChabot = await Faq_kb.findByIdAndUpdate(forkedChatBotId, { $unset: { slug: 1 }, trashed: true, root_id: id_faq_kb, release_note: release_note, publishedBy: req.user.id, publishedAt: new Date().getTime() }, { new: true, upsert: true }).exec();
-    //let updatedForkedChabot = await Faq_kb.findByIdAndUpdate(forkedChatBotId, { $unset: { slug: 1 }, trashed: true, root_id: id_faq_kb, publishedBy: req.user.id, publishedAt: new Date().getTime() }, { new: true }).exec();
-    winston.debug("updatedForkedChabot: ", updatedForkedChabot);
-    botEvent.emit('faqbot.update', updatedForkedChabot);
+    return res.status(200).send({ message: "Chatbot published successfully", bot_id: published.bot_id });
+  } catch (e) {
+    winston.error("Error Unable publish chatbot: ", e);
+    return res.status(500).send({ success: false, message: "Unable publish chatbot" });
+  }
+});
 
-    const port = process.env.PORT || '3000';
-    let TILEBOT_ENDPOINT = process.env.API_ENDPOINT ? process.env.API_ENDPOINT + "/modules/tilebot/ext/" : ("http://localhost:" + port + "/modules/tilebot/ext/");
+router.put('/:faq_kbid/publish/multi', roleChecker.hasRole('admin'), asyncHandler(async (req, res) => {
 
-    if (process.env.TILEBOT_ENDPOINT) {
-      TILEBOT_ENDPOINT = process.env.TILEBOT_ENDPOINT + "/ext/";
-    }
-    winston.info("[RequestService] TILEBOT_ENDPOINT: " + TILEBOT_ENDPOINT);
+  const id_project = req.projectid;
+  const parent_id = req.params.faq_kbid;
+  const chatbots = req.body.chatbots;
+  const isValidChatbot = (chatbot) => chatbot && typeof chatbot === 'object' && !Array.isArray(chatbot) && typeof chatbot.id === 'string' && chatbot.id.trim();
 
-    let updatedOriginalChabot = await Faq_kb.findByIdAndUpdate(id_faq_kb, { url: TILEBOT_ENDPOINT + forkedChatBotId }, { new: true, upsert: true }).exec();
-    winston.debug("updatedOriginalChabot: ", updatedOriginalChabot);
+  if (!Array.isArray(chatbots) || chatbots.length === 0 || chatbots.some((chatbot) => !isValidChatbot(chatbot))) {
+    return res.status(400).send({ success: false, message: "chatbots must be a non-empty array of objects with an id" });
+  }
 
-    cs.setModified(id_faq_kb, false);
+  await chatbotController.getChatbot(parent_id, id_project);
+  await chatbotController.assertAreSubagents(
+    id_project,
+    parent_id,
+    chatbots.map((chatbot) => chatbot.id)
+  );
 
-    botEvent.emit('faqbot.update', updatedOriginalChabot);
+  const api_url = process.env.API_URL || configGlobal.apiUrl;
+  const token = req.headers.authorization;
+  const user_id = req.user.id;
+  const release_note = req.body.release_note || "No comment";
+  const cs = req.app.get('chatbot_service');
+  const results = [];
+
+  for (const chatbot of chatbots) {
+    const id_faq_kb = chatbot.id;
+    try {
+      const published = await cs.publish({
+        id_faq_kb,
+        chatbot_id: id_faq_kb,
+        api_url,
+        token,
+        project_id: id_project,
+        user_id,
+        release_note: chatbot.release_note || release_note,
+        req
+      });
+      results.push({ id: id_faq_kb, success: true, bot_id: published.bot_id });
+    } catch (err) {
+      const error = err?.response?.data?.message || err?.response?.data?.error || err?.message || "Publish failed";
+      winston.error("Error publishing chatbot " + id_faq_kb + ": ", err);
+      results.push({ id: id_faq_kb, success: false, error });
+    }
+  }
 
-    botEvent.emit('faqbot.publish', {
-      req: req,
-      chatbot: updatedOriginalChabot,
-      publishedBotId: forkedChatBotId,
-      release_note: release_note
+  const failed = results.filter((result) => !result.success);
+  if (failed.length > 0) {
+    return res.status(500).send({
+      success: false,
+      message: "Some chatbots failed to publish",
+      results
     });
-
-    return res.status(200).send({ message: "Chatbot published successfully", bot_id: forkedChatBotId });
-
-  } catch (e) {
-    winston.error("Error Unable publish chatbot: ", e);
-    return res.status(500).send({ success: false, message: "Unable publish chatbot" });
   }
-});
+
+  return res.status(200).send({
+    success: true,
+    message: "Chatbots published successfully",
+    results
+  });
+}));
+
+router.put('/:faq_kbid/restore/:publish_id', roleChecker.hasRole('admin'), asyncHandler(async (req, res) => {
+  const chatbot = await chatbotController.restoreFromPublished(
+    req.params.faq_kbid,
+    req.params.publish_id,
+    req.projectid,
+    req.user.id
+  );
+  return res.status(200).send(chatbot);
+}));
 
 router.put('/:faq_kbid', roleChecker.hasRoleOrTypes('admin', ['bot', 'subscription']), function (req, res) {
 
@@ -459,29 +506,69 @@ router.patch('/:faq_kbid/attributes', roleChecker.hasRoleOrTypes('admin', ['bot'
 
 });
 
-router.delete('/:faq_kbid', roleChecker.hasRole('admin'), function (req, res) {
+router.delete('/:faq_kbid', roleChecker.hasRole('admin'), asyncHandler(async function (req, res) {
 
   winston.debug(req.body);
 
   const chatbot_id = req.params.faq_kbid;
   const id_project = req.projectid;
 
-  Faq_kb.findOneAndDelete({ _id: chatbot_id, id_project: id_project }, function (err, faq_kb) {
-    if (err) {
-      return res.status(500).send({ success: false, msg: 'Error deleting object.' });
+  let chatbot;
+  try {
+    chatbot = await Faq_kb.findOne({ _id: chatbot_id, id_project: id_project });
+  } catch (err) {
+    winston.error("Error getting chatbot: ", err);
+    return res.status(500).send({ success: false, msg: 'Error getting chatbot.' });
+  }
+
+  if (!chatbot) {
+    return res.status(404).send({
+      success: false,
+      msg: "Chatbot not found with id " + chatbot_id + " for project " + id_project
+    });
+  }
+
+  if (chatbot.subtype === 'subagent') {
+    let referencingFaq;
+    try {
+      referencingFaq = await chatbotController.findSubagentCaller(chatbot, id_project);
+    } catch (err) {
+      winston.error("Error checking subagent references: ", err);
+      return res.status(500).send({ success: false, msg: 'Error checking subagent references.' });
     }
 
-    if (!faq_kb) {
-      return res.status(404).send({ success: false, msg: "Chatbot not found with id " + chatbot_id + " for project " + id_project });
+    if (referencingFaq) {
+      return res.status(409).send({
+        success: false,
+        msg: "Cannot delete subagent because it is still referenced by another chatbot",
+        error_code: errorCodes.CHATBOT.ERRORS.SUBAGENT_IN_USE,
+        referenced_by: {
+          id_faq_kb: referencingFaq.id_faq_kb,
+          intent_display_name: referencingFaq.intent_display_name
+        }
+      });
     }
-    /**
-     * WARNING: faq_kb is the operation result, not the faq_kb object. The event subscriber will not receive the object as expected.
-     */
-    botEvent.emit('faqbot.delete', faq_kb);
-    botEvent.emit('faqbot.deleted', { req, chatbot: faq_kb });
-    res.status(200).send({ success: true, message: "Chatbot with id " + req.params.faq_kbid + " deleted successfully" })
-  });
-});
+  }
+
+  let deletedFaqKb;
+  try {
+    deletedFaqKb = await Faq_kb.findOneAndDelete({ _id: chatbot_id, id_project: id_project });
+  } catch (err) {
+    winston.error("Error deleting chatbot: ", err);
+    return res.status(500).send({ success: false, msg: 'Error deleting object.' });
+  }
+
+  if (!deletedFaqKb) {
+    return res.status(404).send({ success: false, msg: "Chatbot not found with id " + chatbot_id + " for project " + id_project });
+  }
+
+  /**
+   * WARNING: faq_kb is the operation result, not the faq_kb object. The event subscriber will not receive the object as expected.
+   */
+  botEvent.emit('faqbot.delete', deletedFaqKb);
+  botEvent.emit('faqbot.deleted', { req, chatbot: deletedFaqKb });
+  return res.status(200).send({ success: true, message: "Chatbot with id " + req.params.faq_kbid + " deleted successfully" });
+}));
 
 router.get('/:faq_kbid', roleChecker.hasRoleOrTypes('admin', ['bot', 'subscription']), function (req, res) {
 
@@ -549,6 +636,26 @@ router.get('/:faq_kbid/published', roleChecker.hasRoleOrTypes('admin', ['bot', '
 
 })
 
+router.get('/:faq_kbid/subagents', roleChecker.hasRoleOrTypes('admin', ['bot', 'subscription']), async function (req, res) {
+
+  const id_project = req.projectid;
+  const chatbot_id = req.params.faq_kbid;
+
+  let subagents;
+  try {
+    subagents = await Faq_kb.find({
+      id_project: id_project,
+      parent_id: chatbot_id,
+      trashed: { $in: [null, false] }
+    }).sort({ createdAt: -1 }).lean().exec();
+    return res.status(200).send(subagents);
+  } catch (err) {
+    winston.error("Error finding subagents: ", err);
+    return res.status(500).send({ success: false, error: "Error finding subagents from root " + chatbot_id });
+  }
+
+})
+
 router.get('/:faq_kbid/jwt', roleChecker.hasRoleOrTypes('admin', ['bot', 'subscription']), function (req, res) {
 
   winston.debug(req.query);
@@ -613,7 +720,7 @@ router.get('/', roleChecker.hasRoleOrTypes('agent', ['bot', 'subscription']), fu
    * if filter only for 'trashed = false', 
    * the bots created before the implementation of the 'trashed' property are not returned 
    */
-  let query = { id_project: id_project, trashed: { $in: [null, false] } };
+  let query = { id_project: id_project, subtype: { $ne: "subagent" }, trashed: { $in: [null, false] } };
 
   if (restricted_mode === true) {
     query.agents_available = {
@@ -656,97 +763,151 @@ router.get('/', roleChecker.hasRoleOrTypes('agent', ['bot', 'subscription']), fu
   })
 });
 
-router.post('/fork/:id_faq_kb', roleChecker.hasRole('admin'), async (req, res) => {
-
-  let id_faq_kb = req.params.id_faq_kb;
-  winston.debug('id_faq_kb: ' + id_faq_kb);
-
+// DEPRECATED: create shell via createBot, then import intents/subagents into it
+// router.post('/fork/:id_faq_kb', roleChecker.hasRole('admin'), async (req, res) => {
+//
+//   let id_faq_kb = req.params.id_faq_kb;
+//   winston.debug('id_faq_kb: ' + id_faq_kb);
+//
+//   const api_url = process.env.API_URL || configGlobal.apiUrl;
+//   winston.debug("fork --> base_url: " + api_url); // check if correct
+//
+//   let current_project_id = req.projectid;
+//   winston.debug("current project id: " + current_project_id);
+//
+//   let landing_project_id = req.query.projectid;
+//   winston.debug("landing project id " + landing_project_id)
+//
+//   let public = req.query.public;
+//   winston.debug("public " + public);
+//
+//   let globals = req.query.globals;
+//   winston.debug("export globals " + globals);
+//
+//   let token = req.headers.authorization;
+//
+//   let cs = req.app.get('chatbot_service')
+//   let chatbot;
+//   try {
+//     chatbot = await cs.getBotById(id_faq_kb, public, api_url, chatbot_templates_api_url, token, current_project_id, globals);
+//   } catch (err) {
+//     return res.status(500).send({ success: false, error: "Unable to get chatbot to be forked"});
+//   }
+//
+//   if (!chatbot) {
+//     return res.status(500).send({ success: false, message: "Unable to get chatbot to be forked" });
+//   }
+//
+//   if (!globals) {
+//     if (chatbot.attributes) {
+//       delete chatbot.attributes.globals
+//     }
+//   }
+//
+//   delete chatbot.modified;
+//
+//   chatbot.template = "empty";
+//
+//   let savedChatbot
+//   try {
+//     savedChatbot = await cs.createBot(api_url, token, chatbot, landing_project_id);
+//     winston.debug("savedChatbot: ", savedChatbot)
+//   } catch(err) {
+//     winston.error("Error creating new chatbot: ", err);
+//     return res.status(500).send({ success: false, message: "An error occurred during chatbot creation"});
+//   }
+//
+//   if (!savedChatbot) {
+//     return res.status(500).send({ success: false, message: "Unable to create new chatbot" });
+//   }
+//
+//   let import_result
+//   try {
+//     // Imports parent intents and linked subagents (with their intents) into the new parent.
+//     import_result = await cs.importFaqs(api_url, savedChatbot._id, token, chatbot, landing_project_id);
+//     winston.debug("imported: ", import_result);
+//   } catch(err) {
+//     winston.error("Error importing chatbot content on fork: ", err);
+//     return res.status(500).send({ success: false, message: "Error importing chatbot content (intents/subagents)"});
+//   }
+//
+//   if (import_result?.success == false) {
+//     return res.status(500).send({ success: false, message: "Unable to import chatbot content in the new chatbot" });
+//   }
+//
+//   return res.status(200).send({ message: "Chatbot forked successfully", bot_id: savedChatbot._id });
+//
+// })
+
+// Export source chatbot, then import with create=true (parent + intents + linked subagents)
+router.post('/fork/:id_faq_kb', roleChecker.hasRole('admin'), asyncHandler(async (req, res) => {
+
+  const id_faq_kb = req.params.id_faq_kb;
   const api_url = process.env.API_URL || configGlobal.apiUrl;
-  winston.debug("fork --> base_url: " + api_url); // check if correct
-
-  let current_project_id = req.projectid;
+  const current_project_id = req.projectid;
+  const landing_project_id = req.query.projectid;
+  const public = req.query.public;
+  const globals = req.query.globals;
+  const token = req.headers.authorization;
+  const user_id = req.user.id;
+
+  winston.debug('fork id_faq_kb: ' + id_faq_kb);
+  winston.debug("fork --> base_url: " + api_url);
   winston.debug("current project id: " + current_project_id);
-
-  let landing_project_id = req.query.projectid;
-  winston.debug("landing project id " + landing_project_id)
-
-  let public = req.query.public;
+  winston.debug("landing project id " + landing_project_id);
   winston.debug("public " + public);
-
-  let globals = req.query.globals;
   winston.debug("export globals " + globals);
 
-  let token = req.headers.authorization;
-
-  let cs = req.app.get('chatbot_service')
+  const cs = req.app.get('chatbot_service');
   let chatbot;
   try {
     chatbot = await cs.getBotById(id_faq_kb, public, api_url, chatbot_templates_api_url, token, current_project_id, globals);
   } catch (err) {
-    return res.status(500).send({ success: false, error: "Unable to get chatbot to be forked"});
+    return res.status(500).send({ success: false, error: "Unable to get chatbot to be forked" });
   }
 
   if (!chatbot) {
     return res.status(500).send({ success: false, message: "Unable to get chatbot to be forked" });
   }
 
-  if (!globals) {
-    if (chatbot.attributes) {
-      delete chatbot.attributes.globals
-    }
+  if (!globals && chatbot.attributes) {
+    delete chatbot.attributes.globals;
   }
-  
-  delete chatbot.modified;
 
-  chatbot.template = "empty";
-  
-  let savedChatbot
-  try {
-    savedChatbot = await cs.createBot(api_url, token, chatbot, landing_project_id);
-    winston.debug("savedChatbot: ", savedChatbot)
-  } catch(err) {
-    winston.error("Error creating new chatbot: ", err);
-    return res.status(500).send({ success: false, message: "An error occurred during chatbot creation"});
-  }
-
-  if (!savedChatbot) {
-    return res.status(500).send({ success: false, message: "Unable to create new chatbot" });
-  }
-  
-  let import_result
-  try {
-    import_result = await cs.importFaqs(api_url, savedChatbot._id, token, chatbot, landing_project_id);
-    winston.debug("imported: ", import_result);
-  } catch(err) {
-    winston.error("Error importing intents on new chatbot: ", err);
-    return res.status(500).send({ success: false, message: "Error importing intents in the chatbot"});
-  }
+  delete chatbot.modified;
 
-  if (import_result?.success == false) {
-    return res.status(500).send({ success: false, message: "Unable to import intents in the new chatbot" });
-  }
+  // Publish passes skipSubagents so actions keep the development subagent id.
+  // A plain fork still clones subagents into the copy.
+  const skipSubagents = req.query.skipSubagents === 'true';
+
+  const savedChatbot = await chatbotController.import(
+    chatbot,
+    landing_project_id,
+    null,
+    true,
+    false,
+    false,
+    user_id,
+    skipSubagents
+  );
 
   if (req.query.for_publish !== 'true') {
     botEvent.emit('faqbot.created', { req, chatbot: savedChatbot, id_project: landing_project_id });
   }
 
   return res.status(200).send({ message: "Chatbot forked successfully", bot_id: savedChatbot._id });
+}))
 
-})
+router.post('/importjson/:id_faq_kb', roleChecker.hasRole('admin'), upload.single('uploadFile'), asyncHandler(async (req, res) => {
 
-router.post('/importjson/:id_faq_kb', roleChecker.hasRole('admin'), upload.single('uploadFile'), async (req, res) => {
-
-  let chatbot_id = req.params.id_faq_kb;
-  let id_project = req.projectid;
-
-  winston.debug('import on id_faq_kb: ' + chatbot_id);
-
-  winston.debug('import with option create: ' + req.query.create);
-  winston.debug('import with option replace: ' + req.query.replace);
-  winston.debug('import with option overwrite: ' + req.query.overwrite);
+  const chatbot_id = req.params.id_faq_kb;
+  const id_project = req.projectid;
+  const create = req.query.create === 'true';
+  const replace = req.query.replace === 'true';
+  const overwrite = req.query.overwrite === 'true';
+  const user_id = req.user.id;
 
-  let json_string;
-  let json;
+  let json, json_string;
   if (req.file) {
     json_string = req.file.buffer.toString('utf-8');
     json = JSON.parse(json_string);
@@ -754,313 +915,372 @@ router.post('/importjson/:id_faq_kb', roleChecker.hasRole('admin'), upload.singl
     json = req.body;
   }
 
-  winston.debug("json source " + json_string)
-
-  // ****************************
-  // **** CREATE TRUE option ****
-  // ****************************
-  if (req.query.create === 'true') {
-    // if (json.subtype && (json.subtype === 'webhook' || json.subtype === 'copilot')) {
-    //   json.template = 'empty';
-    // }
-    json.template = 'empty';
-    let savedChatbot = await faqService.create(req.projectid, req.user.id, json)
-      .catch((err) => {
-        winston.error("Error creating new chatbot")
-        return res.status(400).send({ succes: false, message: "Error creatings new chatbot", error: err })
-      })
-
-    // Edit attributes.rules
-    let attributes = json.attributes;
-    if (attributes &&
-      attributes.rules &&
-      attributes.rules.length > 0) {
-
-      await attributes.rules.forEach((rule) => {
-        if (rule.do &&
-          rule.do[0] &&
-          rule.do[0].message &&
-          rule.do[0].message.participants &&
-          rule.do[0].message.participants[0]) {
-          rule.do[0].message.participants[0] = "bot_" + savedChatbot._id
-          winston.debug("attributes rule new participant: ", rule.do[0].message.participants[0])
-        }
-      })
-    }
-
-    let chatbot_edited = { attributes: attributes };
-
-    let updatedChatbot = await Faq_kb.findByIdAndUpdate(savedChatbot._id, chatbot_edited, { new: true }).catch((err) => {
-      winston.error("Error updating chatbot attributes: ", err);
-      winston.debug("Skip Error updating chatbot attributes: ", err);
-      // return res.status(400).send({ success: false, message: "Error updating chatbot attributes", error: err })
-    })
-
-    botEvent.emit('faqbot.create', savedChatbot);
-    botEvent.emit('faqbot.created', { req, chatbot: savedChatbot });
-
-    if (json.intents) {
-
-      json.intents.forEach(async (intent) => {
-
-        let new_faq = {
-          id_faq_kb: savedChatbot._id,
-          id_project: req.projectid,
-          createdBy: req.user.id,
-          intent_display_name: intent.intent_display_name,
-          intent_id: intent.intent_id,
-          question: intent.question,
-          answer: intent.answer,
-          reply: intent.reply,
-          form: intent.form,
-          enabled: intent.enabled,
-          webhook_enabled: intent.webhook_enabled,
-          language: intent.language,
-          actions: intent.actions,
-          attributes: intent.attributes
-        }
-
-        let faq = await Faq.create(new_faq).catch((err) => {
-          if (err.code == 11000) { // should never happen
-            winston.error("Duplicate intent_display_name.");
-            winston.debug("Skip duplicated intent_display_name"); // Don't stop the flow
-          } else {
-            winston.error("Error saving new faq: ", err)
-          }
-        })
-
-        if (faq) {
-          winston.debug("new intent created")
-          faqBotEvent.emit('faq.create', faq);
-        }
-      })
-    }
-
-    if (updatedChatbot) {
-      return res.status(200).send(updatedChatbot)
-    } else {
-      return res.status(200).send(savedChatbot)
-    }
-  }
-  // *****************************
-  // **** CREATE FALSE option ****
-  // *****************************
-  else {
-
-    if (!chatbot_id) {
-      return res.status(400).send({ success: false, message: "With replace or overwrite option a id_faq_kb must be provided" })
-    }
-
-    let chatbot = await Faq_kb.findOne({ _id: chatbot_id, id_project: id_project }).catch((err) => {
-      winston.error("Error finding chatbot with id " + chatbot_id);
-      return res.status(404).send({ success: false, message: "Error finding chatbot with id " + chatbot_id, error: err });
-    })
-
-    if (!chatbot) {
-      winston.error("Chatbot not found with id " + chatbot_id + " for project " + id_project);
-      return res.status(404).send({ success: false, message: "Chatbot not found with id " + chatbot_id + " for project " + id_project });
-    }
-
-    if (json.webhook_enabled) {
-      chatbot.webhook_enabled = json.webhook_enabled;
-    }
-    if (json.webhook_url) {
-      chatbot.webhook_url = json.webhook_url;
-    }
-    if (json.language) {
-      chatbot.language = json.language;
-    }
-    if (json.name) {
-      chatbot.name = json.name;
-    }
-    if (json.description) {
-      chatbot.description = json.description;
-    }
-
-    if (json.attributes) {
-      let attributes = json.attributes;
-      if (attributes.rules &&
-        attributes.rules.length > 0) {
-        await attributes.rules.forEach((rule) => {
-          if (rule.do &&
-            rule.do[0] &&
-            rule.do[0].message &&
-            rule.do[0].message.participants &&
-            rule.do[0].message.participants[0]) {
-            rule.do[0].message.participants[0] = "bot_" + chatbot._id
-            winston.debug("attributes rule new participant: " + rule.do[0].message.participants[0])
-          }
-        })
-        chatbot.attributes = json.attributes;
-      }
-    }
-
-    let updatedChatbot = await Faq_kb.findByIdAndUpdate(chatbot._id, chatbot, { new: true }).catch((err) => {
-      winston.error("Error updating chatbot");
-      return res.status(400).send({ success: false, message: "Error updating chatbot", error: err })
-    })
-
-    botEvent.emit('faqbot.update', updatedChatbot);
-
-    // *****************************
-    // **** REPLACE TRUE option ****
-    // *****************************
-    if (req.query.replace === 'true') {
-      let result = await Faq.deleteMany({ id_faq_kb: chatbot._id }).catch((err) => {
-        winston.error("Unable to delete all existing faqs with id_faq_kb " + chatbot._id);
-      })
-
-      winston.verbose("All faq for chatbot " + chatbot._id + " deleted successfully")
-      winston.debug("DeleteMany faqs result ", result);
-    }
-
-    if (json.intents) {
-      await json.intents.forEach(async (intent) => {
-
-        let new_faq = {
-          id_faq_kb: updatedChatbot._id,
-          id_project: req.projectid,
-          createdBy: req.user.id,
-          intent_display_name: intent.intent_display_name,
-          intent_id: intent.intent_id,
-          question: intent.question,
-          answer: intent.answer,
-          reply: intent.reply,
-          form: intent.form,
-          enabled: intent.enabled,
-          webhook_enabled: intent.webhook_enabled,
-          language: intent.language,
-          actions: intent.actions,
-          attributes: intent.attributes
-        }
-
-        // *******************************
-        // **** OVERWRITE TRUE option ****
-        // *******************************
-        if (req.query.overwrite == "true") {
-
-          let savingResult = await Faq.findOneAndUpdate({ id_faq_kb: chatbot._id, intent_display_name: intent.intent_display_name }, new_faq, { new: true, upsert: true, rawResult: true }).catch((err) => {
-            winston.error("Unable to create faq: ", err);
-          })
-
-          if (savingResult) {
-            if (savingResult.lastErrorObject.updatedExisting === true) {
-              winston.verbose("updated existing intent")
-              faqBotEvent.emit('faq.update', savingResult.value);
-            } else {
-              winston.verbose("new intent created")
-              faqBotEvent.emit('faq.create', savingResult.value);
-            }
-          }
-
-          // ********************************
-          // **** OVERWRITE FALSE option ****
-          // ********************************
-        } else {
-
-          let faq = await Faq.create(new_faq).catch((err) => {
-            if (err.code == 11000) {
-              winston.error("Duplicate intent_display_name.");
-              winston.verbose("Skip duplicated intent_display_name");
-            } else {
-              winston.error("Error creating new intent: ", err);
-            }
-          })
-
-          if (faq) {
-            winston.debug("new intent created: ", faq)
-            faqBotEvent.emit('faq.create', faq);
-          }
-        }
-      })
-    }
-
-    if (updatedChatbot) {
-      return res.send(updatedChatbot);
-    } else {
-      return res.send(chatbot);
-    }
+  const chatbot = await chatbotController.import(json, id_project, chatbot_id, create, replace, overwrite, user_id);
+  if (create) {
+    botEvent.emit('faqbot.created', { req, chatbot });
   }
-})
-
-router.get('/exportjson/:id_faq_kb', roleChecker.hasRole('admin'), (req, res) => {
-
-  winston.debug("exporting bot...")
+  return res.status(200).send(chatbot);
+}))
+
+// router.post('/importjson/:id_faq_kb', roleChecker.hasRole('admin'), upload.single('uploadFile'), async (req, res) => {
+
+//   let chatbot_id = req.params.id_faq_kb;
+//   let id_project = req.projectid;
+
+//   winston.debug('import on id_faq_kb: ' + chatbot_id);
+
+//   winston.debug('import with option create: ' + req.query.create);
+//   winston.debug('import with option replace: ' + req.query.replace);
+//   winston.debug('import with option overwrite: ' + req.query.overwrite);
+
+//   let json_string;
+//   let json;
+//   if (req.file) {
+//     json_string = req.file.buffer.toString('utf-8');
+//     json = JSON.parse(json_string);
+//   } else {
+//     json = req.body;
+//   }
+
+//   winston.debug("json source " + json_string)
+
+//   // ****************************
+//   // **** CREATE TRUE option ****
+//   // ****************************
+//   if (req.query.create === 'true') {
+//     // if (json.subtype && (json.subtype === 'webhook' || json.subtype === 'copilot')) {
+//     //   json.template = 'empty';
+//     // }
+//     json.template = 'empty';
+//     let savedChatbot = await faqService.create(req.projectid, req.user.id, json)
+//       .catch((err) => {
+//         winston.error("Error creating new chatbot")
+//         return res.status(400).send({ succes: false, message: "Error creatings new chatbot", error: err })
+//       })
+
+//     // Edit attributes.rules
+//     let attributes = json.attributes;
+//     if (attributes &&
+//       attributes.rules &&
+//       attributes.rules.length > 0) {
+
+//       await attributes.rules.forEach((rule) => {
+//         if (rule.do &&
+//           rule.do[0] &&
+//           rule.do[0].message &&
+//           rule.do[0].message.participants &&
+//           rule.do[0].message.participants[0]) {
+//           rule.do[0].message.participants[0] = "bot_" + savedChatbot._id
+//           winston.debug("attributes rule new participant: ", rule.do[0].message.participants[0])
+//         }
+//       })
+//     }
+
+//     let chatbot_edited = { attributes: attributes };
+
+//     let updatedChatbot = await Faq_kb.findByIdAndUpdate(savedChatbot._id, chatbot_edited, { new: true }).catch((err) => {
+//       winston.error("Error updating chatbot attributes: ", err);
+//       winston.debug("Skip Error updating chatbot attributes: ", err);
+//       // return res.status(400).send({ success: false, message: "Error updating chatbot attributes", error: err })
+//     })
+
+//     botEvent.emit('faqbot.create', savedChatbot);
+
+//     if (json.intents) {
+
+//       json.intents.forEach(async (intent) => {
+
+//         let new_faq = {
+//           id_faq_kb: savedChatbot._id,
+//           id_project: req.projectid,
+//           createdBy: req.user.id,
+//           intent_display_name: intent.intent_display_name,
+//           intent_id: intent.intent_id,
+//           question: intent.question,
+//           answer: intent.answer,
+//           reply: intent.reply,
+//           form: intent.form,
+//           enabled: intent.enabled,
+//           webhook_enabled: intent.webhook_enabled,
+//           language: intent.language,
+//           actions: intent.actions,
+//           attributes: intent.attributes
+//         }
+
+//         let faq = await Faq.create(new_faq).catch((err) => {
+//           if (err.code == 11000) { // should never happen
+//             winston.error("Duplicate intent_display_name.");
+//             winston.debug("Skip duplicated intent_display_name"); // Don't stop the flow
+//           } else {
+//             winston.error("Error saving new faq: ", err)
+//           }
+//         })
+
+//         if (faq) {
+//           winston.debug("new intent created")
+//           faqBotEvent.emit('faq.create', faq);
+//         }
+//       })
+//     }
+
+//     if (updatedChatbot) {
+//       return res.status(200).send(updatedChatbot)
+//     } else {
+//       return res.status(200).send(savedChatbot)
+//     }
+//   }
+//   // *****************************
+//   // **** CREATE FALSE option ****
+//   // *****************************
+//   else {
+
+//     if (!chatbot_id) {
+//       return res.status(400).send({ success: false, message: "With replace or overwrite option a id_faq_kb must be provided" })
+//     }
+
+//     let chatbot = await Faq_kb.findOne({ _id: chatbot_id, id_project: id_project }).catch((err) => {
+//       winston.error("Error finding chatbot with id " + chatbot_id);
+//       return res.status(404).send({ success: false, message: "Error finding chatbot with id " + chatbot_id, error: err });
+//     })
+
+//     if (!chatbot) {
+//       winston.error("Chatbot not found with id " + chatbot_id + " for project " + id_project);
+//       return res.status(404).send({ success: false, message: "Chatbot not found with id " + chatbot_id + " for project " + id_project });
+//     }
+
+//     if (json.webhook_enabled) {
+//       chatbot.webhook_enabled = json.webhook_enabled;
+//     }
+//     if (json.webhook_url) {
+//       chatbot.webhook_url = json.webhook_url;
+//     }
+//     if (json.language) {
+//       chatbot.language = json.language;
+//     }
+//     if (json.name) {
+//       chatbot.name = json.name;
+//     }
+//     if (json.description) {
+//       chatbot.description = json.description;
+//     }
+
+//     if (json.attributes) {
+//       let attributes = json.attributes;
+//       if (attributes.rules &&
+//         attributes.rules.length > 0) {
+//         await attributes.rules.forEach((rule) => {
+//           if (rule.do &&
+//             rule.do[0] &&
+//             rule.do[0].message &&
+//             rule.do[0].message.participants &&
+//             rule.do[0].message.participants[0]) {
+//             rule.do[0].message.participants[0] = "bot_" + chatbot._id
+//             winston.debug("attributes rule new participant: " + rule.do[0].message.participants[0])
+//           }
+//         })
+//         chatbot.attributes = json.attributes;
+//       }
+//     }
+
+//     let updatedChatbot = await Faq_kb.findByIdAndUpdate(chatbot._id, chatbot, { new: true }).catch((err) => {
+//       winston.error("Error updating chatbot");
+//       return res.status(400).send({ success: false, message: "Error updating chatbot", error: err })
+//     })
+
+//     botEvent.emit('faqbot.update', updatedChatbot);
+
+//     // *****************************
+//     // **** REPLACE TRUE option ****
+//     // *****************************
+//     if (req.query.replace === 'true') {
+//       let result = await Faq.deleteMany({ id_faq_kb: chatbot._id }).catch((err) => {
+//         winston.error("Unable to delete all existing faqs with id_faq_kb " + chatbot._id);
+//       })
+
+//       winston.verbose("All faq for chatbot " + chatbot._id + " deleted successfully")
+//       winston.debug("DeleteMany faqs result ", result);
+//     }
+
+//     if (json.intents) {
+//       await json.intents.forEach(async (intent) => {
+
+//         let new_faq = {
+//           id_faq_kb: updatedChatbot._id,
+//           id_project: req.projectid,
+//           createdBy: req.user.id,
+//           intent_display_name: intent.intent_display_name,
+//           intent_id: intent.intent_id,
+//           question: intent.question,
+//           answer: intent.answer,
+//           reply: intent.reply,
+//           form: intent.form,
+//           enabled: intent.enabled,
+//           webhook_enabled: intent.webhook_enabled,
+//           language: intent.language,
+//           actions: intent.actions,
+//           attributes: intent.attributes
+//         }
+
+//         // *******************************
+//         // **** OVERWRITE TRUE option ****
+//         // *******************************
+//         if (req.query.overwrite == "true") {
+
+//           let savingResult = await Faq.findOneAndUpdate({ id_faq_kb: chatbot._id, intent_display_name: intent.intent_display_name }, new_faq, { new: true, upsert: true, rawResult: true }).catch((err) => {
+//             winston.error("Unable to create faq: ", err);
+//           })
+
+//           if (savingResult) {
+//             if (savingResult.lastErrorObject.updatedExisting === true) {
+//               winston.verbose("updated existing intent")
+//               faqBotEvent.emit('faq.update', savingResult.value);
+//             } else {
+//               winston.verbose("new intent created")
+//               faqBotEvent.emit('faq.create', savingResult.value);
+//             }
+//           }
+
+//           // ********************************
+//           // **** OVERWRITE FALSE option ****
+//           // ********************************
+//         } else {
+
+//           let faq = await Faq.create(new_faq).catch((err) => {
+//             if (err.code == 11000) {
+//               winston.error("Duplicate intent_display_name.");
+//               winston.verbose("Skip duplicated intent_display_name");
+//             } else {
+//               winston.error("Error creating new intent: ", err);
+//             }
+//           })
+
+//           if (faq) {
+//             winston.debug("new intent created: ", faq)
+//             faqBotEvent.emit('faq.create', faq);
+//           }
+//         }
+//       })
+//     }
+
+//     if (updatedChatbot) {
+//       return res.send(updatedChatbot);
+//     } else {
+//       return res.send(chatbot);
+//     }
+//   }
+// })
+
+router.get('/exportjson/:id_faq_kb', roleChecker.hasRole('admin'), asyncHandler(async (req, res) => {
 
   const chatbot_id = req.params.id_faq_kb;
   const id_project = req.projectid;
+  const exportGlobals = req.query.globals === 'true';
+  const intentsOnly = req.query.intentsOnly === 'true';
 
-  Faq_kb.findOne({ _id: chatbot_id }, (err, faq_kb) => {
-    if (err) {
-      winston.error('GET FAQ-KB ERROR ', err)
-      return res.status(500).send({ success: false, msg: 'Error getting bot.' });
-    }
-    
-    if (!faq_kb) {
-      return res.status(404).send({ success: false, msg: "Chatbot not found with id " + chatbot_id });
-    }
-
-    const isPublic = faq_kb.public === true;
-    const isOwner = faq_kb.id_project === id_project;
+  const chatbot = await chatbotController.getChatbotById(chatbot_id);
 
-    if (!isPublic && !isOwner) {
-      return res.status(403).send({
-        success: false,
-        msg: "Chatbot not found with id " + chatbot_id + " for project " + id_project
-      });
-    }
+  if (!chatbotController.canAccess(chatbot, id_project)) {
+    throw new AppError(403, `Unauthorized to access chatbot with id ${chatbot_id} for project ${id_project}`);
+  }
 
-    winston.debug('FAQ-KB: ', faq_kb)
+  let intents = await intentsController.getIntents(chatbot_id);
 
-    faqService.getAll(chatbot_id).then((faqs) => {
+  if (!exportGlobals) {
+    winston.verbose("Delete globals from attributes")
+    delete chatbot.attributes?.globals;
+  }
 
-      // delete from exclude map intent_id
-      const intents = faqs.map(({ _id, id_project, topic, status, chatbot_id, createdBy, createdAt, updatedAt, __v, ...keepAttrs }) => keepAttrs)
+  let subagents = await chatbotController.findSubagents(chatbot_id, id_project);
+  await Promise.all(subagents.map(async (subagent) => {
+    subagent.intents = await intentsController.getIntents(subagent._id);
+  }));
 
-      if (!req.query.globals) {
-        winston.verbose("Delete globals from attributes!")
-        if (faq_kb.attributes) {
-          delete faq_kb.attributes.globals;
-        }
-      }
+  let exportData = chatbotController.export(chatbot, intents, intentsOnly, subagents);
+  let filename = intentsOnly ? "intents.json" : "bot.json";
+  res.set({ "Content-Disposition": `attachment; filename="${filename}"` });
+  return res.send(exportData);
 
-      let json = {
-        webhook_enabled: faq_kb.webhook_enabled,
-        webhook_url: faq_kb.webhook_url,
-        language: faq_kb.language,
-        name: faq_kb.name,
-        slug: faq_kb.slug,
-        type: faq_kb.type,
-        subtype: faq_kb.subtype,
-        description: faq_kb.description,
-        attributes: faq_kb.attributes,
-        intents: intents
-      }
+}))
 
-      if (req.query.intentsOnly == 'true') {
-        let intents_obj = {
-          intents: intents
-        }
-        let intents_string = JSON.stringify(intents_obj);
-        res.set({ "Content-Disposition": "attachment; filename=\"intents.json\"" });
-        return res.send(intents_string);
+// DEPRECATED
+// router.get('/exportjson/:id_faq_kb', roleChecker.hasRole('admin'), (req, res) => {
 
-      } else {
+//   winston.debug("exporting bot...")
 
-        // if (req.query.file == "false") {
-        //   return res.status(200).send(json);
-        // }
-        let json_string = JSON.stringify(json);
-        res.set({ "Content-Disposition": "attachment; filename=\"bot.json\"" });
-        return res.send(json_string);
-      }
+//   const chatbot_id = req.params.id_faq_kb;
+//   const id_project = req.projectid;
 
-    }).catch((err) => {
-      winston.error('GET FAQ ERROR: ', err)
-      return res.status(500).send({ success: false, msg: 'Error getting faqs.' });
-    })
-  })
-})
+//   Faq_kb.findOne({ _id: chatbot_id }, (err, faq_kb) => {
+//     if (err) {
+//       winston.error('GET FAQ-KB ERROR ', err)
+//       return res.status(500).send({ success: false, msg: 'Error getting bot.' });
+//     }
+    
+//     if (!faq_kb) {
+//       return res.status(404).send({ success: false, msg: "Chatbot not found with id " + chatbot_id });
+//     }
+
+//     const isPublic = faq_kb.public === true;
+//     const isOwner = faq_kb.id_project === id_project;
+
+//     if (!isPublic && !isOwner) {
+//       return res.status(403).send({
+//         success: false,
+//         msg: "Chatbot not found with id " + chatbot_id + " for project " + id_project
+//       });
+//     }
+
+//     winston.debug('FAQ-KB: ', faq_kb)
+
+//     faqService.getAll(chatbot_id).then((faqs) => {
+
+//       // delete from exclude map intent_id
+//       const intents = faqs.map(({ _id, id_project, topic, status, chatbot_id, createdBy, createdAt, updatedAt, __v, ...keepAttrs }) => keepAttrs)
+
+//       if (!req.query.globals) {
+//         winston.verbose("Delete globals from attributes!")
+//         if (faq_kb.attributes) {
+//           delete faq_kb.attributes.globals;
+//         }
+//       }
+
+//       let json = {
+//         webhook_enabled: faq_kb.webhook_enabled,
+//         webhook_url: faq_kb.webhook_url,
+//         language: faq_kb.language,
+//         name: faq_kb.name,
+//         slug: faq_kb.slug,
+//         type: faq_kb.type,
+//         subtype: faq_kb.subtype,
+//         description: faq_kb.description,
+//         attributes: faq_kb.attributes,
+//         intents: intents
+//       }
+
+//       if (req.query.intentsOnly == 'true') {
+//         let intents_obj = {
+//           intents: intents
+//         }
+//         let intents_string = JSON.stringify(intents_obj);
+//         res.set({ "Content-Disposition": "attachment; filename=\"intents.json\"" });
+//         return res.send(intents_string);
+
+//       } else {
+
+//         // if (req.query.file == "false") {
+//         //   return res.status(200).send(json);
+//         // }
+//         let json_string = JSON.stringify(json);
+//         res.set({ "Content-Disposition": "attachment; filename=\"bot.json\"" });
+//         return res.send(json_string);
+//       }
+
+//     }).catch((err) => {
+//       winston.error('GET FAQ ERROR: ', err)
+//       return res.status(500).send({ success: false, msg: 'Error getting faqs.' });
+//     })
+//   })
+// })
 
 router.post('/:faq_kbid/training', roleChecker.hasRole('admin'), function (req, res) {