@tiledesk/tiledesk-server 2.28.2 → 3.0.0

package/services/chatbotService.js

@@ -1,5 +1,6 @@
 const axios = require("axios").default;
 const winston = require('../config/winston');
+const botEvent = require('../event/botEvent');
 let Faq_kb = require("../models/faq_kb");
 
 class ChatbotService {
@@ -9,11 +10,20 @@ class ChatbotService {
   async fork(id_faq_kb, api_url, token, project_id, options) {
     winston.debug("(ChatbotService) fork");
 
+    // `true` is the older skip-subagents flag; publish passes `{ skipSubagents, forPublish }`.
+    const skipSubagents = options === true || (options && options.skipSubagents === true);
     const forPublish = options && options.forPublish === true;
-    const forPublishQuery = forPublish ? '&for_publish=true' : '';
+
+    let url = api_url + '/' + project_id + '/faq_kb/fork/' + id_faq_kb + '?projectid=' + project_id + '&public=false&globals=true';
+    if (skipSubagents) {
+      url += '&skipSubagents=true';
+    }
+    if (forPublish) {
+      url += '&for_publish=true';
+    }
 
     return await axios({
-      url: api_url + '/' + project_id + '/faq_kb/fork/' + id_faq_kb + '?projectid=' + project_id + '&public=false&globals=true' + forPublishQuery,
+      url: url,
       headers: {
         'Content-Type': 'application/json',
         'Authorization': token
@@ -45,8 +55,11 @@ class ChatbotService {
         },
         method: 'GET'
       }).then((resbody) => {
-        winston.debug("(ChatbotService) forking private chatbot " + resbody.data.name)
         let chatbot = resbody.data;
+        if (typeof chatbot === 'string') {
+          chatbot = JSON.parse(chatbot);
+        }
+        winston.debug("(ChatbotService) forking private chatbot " + chatbot.name)
         return chatbot;
       }).catch((err) => {
         winston.error('(ChatbotService) FAQ_KB EXPORTJSON ERROR ' + err);
@@ -63,8 +76,11 @@ class ChatbotService {
         },
         method: 'GET'
       }).then((resbody) => {
-        winston.debug("(ChatbotService) forking public chatbot " + resbody.data.name);
         let chatbot = resbody.data;
+        if (typeof chatbot === 'string') {
+          chatbot = JSON.parse(chatbot);
+        }
+        winston.debug("(ChatbotService) forking public chatbot " + chatbot.name);
         return chatbot
       }).catch((err) => {
         winston.error('(ChatbotService) FAQ_KB CHATBOT TEMPLATES ERROR ' + err);
@@ -100,8 +116,10 @@ class ChatbotService {
   
     winston.debug("(ChatbotService) importFaqs");
 
+    // Full import into the newly created parent: intents + nested subagents.
+    // Subagents are parent-scoped and get parent_id remapped by chatbotController.import.
     return await axios({
-      url: api_url + '/' + project_id + '/faq_kb/importjson/' + id_faq_kb + "?intentsOnly=true",
+      url: api_url + '/' + project_id + '/faq_kb/importjson/' + id_faq_kb,
       headers: {
         'Content-Type': 'application/json',
         'Authorization': token
@@ -125,6 +143,67 @@ class ChatbotService {
         return Promise.reject(err);
       });
   }
+
+  _tilebotEndpoint() {
+    const port = process.env.PORT || '3000';
+    let endpoint = process.env.API_ENDPOINT
+      ? process.env.API_ENDPOINT + "/modules/tilebot/ext/"
+      : ("http://localhost:" + port + "/modules/tilebot/ext/");
+
+    if (process.env.TILEBOT_ENDPOINT) {
+      endpoint = process.env.TILEBOT_ENDPOINT + "/ext/";
+    }
+    return endpoint;
+  }
+
+  async publish({ id_faq_kb, chatbot_id, api_url, token, project_id, user_id, release_note, req }) {
+    const sourceId = chatbot_id || id_faq_kb;
+    winston.debug("(ChatbotService) publish id_faq_kb: " + id_faq_kb + " source: " + sourceId);
+
+    // Keep callsubagent.botId on the development subagent. Its url points at the published snapshot.
+    // for_publish skips FAQ_KB_CREATE on the trashed snapshot; FAQ_KB_PUBLISH is emitted below.
+    const forked = await this.fork(sourceId, api_url, token, project_id, { skipSubagents: true, forPublish: true });
+    const forkedChatBotId = forked.bot_id;
+    winston.debug("(ChatbotService) publish forkedChatBotId: " + forkedChatBotId);
+
+    const updatedForkedChatbot = await Faq_kb.findByIdAndUpdate(
+      forkedChatBotId,
+      {
+        $unset: { slug: 1 },
+        trashed: true,
+        root_id: id_faq_kb,
+        release_note: release_note,
+        publishedBy: user_id,
+        publishedAt: new Date().getTime()
+      },
+      { new: true, upsert: true }
+    ).exec();
+    winston.debug("(ChatbotService) publish updatedForkedChatbot: ", updatedForkedChatbot);
+    botEvent.emit('faqbot.update', updatedForkedChatbot);
+
+    const tilebotEndpoint = this._tilebotEndpoint();
+    winston.debug("(ChatbotService) TILEBOT_ENDPOINT: " + tilebotEndpoint);
+
+    const updatedOriginalChatbot = await Faq_kb.findByIdAndUpdate(
+      id_faq_kb,
+      { url: tilebotEndpoint + forkedChatBotId },
+      { new: true, upsert: true }
+    ).exec();
+    winston.debug("(ChatbotService) publish updatedOriginalChatbot: ", updatedOriginalChatbot);
+
+    await this.setModified(id_faq_kb, false);
+    botEvent.emit('faqbot.update', updatedOriginalChatbot);
+    botEvent.emit('faqbot.publish', {
+      req,
+      chatbot: updatedOriginalChatbot,
+      publishedBotId: forkedChatBotId,
+      release_note
+    });
+
+    return { bot_id: forkedChatBotId };
+  }
+
 }
 
+
 module.exports = { ChatbotService }

package/services/faqService.js

@@ -5,66 +5,179 @@ const botEvent = require('../event/botEvent');
 const chatbotTypes = require("../models/chatbotTypes");
 const chatbotTemplates = require("../models/chatbotTemplates");
 const templates = require('../template/chatbot');
+const subagentNotes = require('../template/chatbot/subagent_notes');
+const v3FlowService = require('./v3FlowService');
 
 class FaqService {
 
-  create(id_project, id_user, data) {
+  // create(id_project, id_user, data) {
 
-    return new Promise((resolve, reject) => {
+  //   return new Promise((resolve, reject) => {
 
-      var newFaq_kb = new Faq_kb({
-        name: data.name,
-        slug: data.slug,
-        description: data.description,
-        url: data.url,
-        id_project: id_project,
-        webhook_url: data.webhook_url,
-        webhook_enabled: data.webhook_enabled,
-        type: data.type,
-        subtype: data.subtype,
-        language: data.language,
-        public: false,
-        certified: false,
-        mainCategory: data.mainCategory,
-        intentsEngine: data.intentsEngine,
-        trashed: false,
-        createdBy: id_user,
-        updatedBy: id_user,
-        attributes: data.attributes
-      });
+  //     if (data.type === "subagent" && !data.parent_id) {
+  //       return reject('Parent ID is required for subagent');
+  //     }
 
-      newFaq_kb.save((err, savedFaq_kb) => {
+  //     var newFaq_kb = new Faq_kb({
+  //       name: data.name,
+  //       slug: data.slug,
+  //       description: data.description,
+  //       url: data.url,
+  //       id_project: id_project,
+  //       webhook_url: data.webhook_url,
+  //       webhook_enabled: data.webhook_enabled,
+  //       type: data.type,
+  //       subtype: data.subtype,
+  //       language: data.language,
+  //       public: false,
+  //       certified: false,
+  //       mainCategory: data.mainCategory,
+  //       intentsEngine: data.intentsEngine,
+  //       trashed: false,
+  //       createdBy: id_user,
+  //       updatedBy: id_user,
+  //       attributes: data.attributes,
+  //       parent_id: data.parent_id
+  //     });
 
-        if (err) {
-          winston.error('(FaqService) error saving new chatbot ', err)
-          return reject('Error saving object.');
-        }
+  //     newFaq_kb.save((err, savedFaq_kb) => {
 
-        winston.debug('(FaqService) saved chatbot ', savedFaq_kb.toObject())
-        botEvent.emit('faqbot.create', savedFaq_kb);
+  //       if (err) {
+  //         winston.error('(FaqService) error saving new chatbot ', err)
+  //         return reject('Error saving object.');
+  //       }
 
-        winston.debug('type ' + data.type)
+  //       winston.debug('(FaqService) saved chatbot ', savedFaq_kb.toObject())
+  //       botEvent.emit('faqbot.create', savedFaq_kb);
 
-        if (data.type === "internal" || data.type === "tilebot") {
+  //       winston.debug('type ' + data.type)
 
-          let template = this.#resolveTemplate(data.subtype, data.template);
-          winston.debug('template ' + template);
+  //       if (data.type === "internal" || data.type === "tilebot") {
 
-          let options = {};
-          if (data.namespace_id) {
-            options.namespace_id = data.namespace_id;
-          }
+  //         let template = this.#resolveTemplate(data.subtype, data.template);
+  //         winston.debug('template ' + template);
 
-          this.createGreetingsAndOperationalsFaqs(savedFaq_kb._id, savedFaq_kb.createdBy, savedFaq_kb.id_project, template, options);
+  //         let options = {};
+  //         if (data.namespace_id) {
+  //           options.namespace_id = data.namespace_id;
+  //         }
 
-        } else {
-          winston.debug('(FaqService) Chatbot type: external bot');
-        }
+  //         this.createGreetingsAndOperationalsFaqs(savedFaq_kb._id, savedFaq_kb.createdBy, savedFaq_kb.id_project, template, options);
 
-        return resolve(savedFaq_kb);
-      });
+  //       } else {
+  //         winston.debug('(FaqService) Chatbot type: external bot');
+  //       }
+
+  //       return resolve(savedFaq_kb);
+  //     });
+
+  //   });
+  // }
+
+  async create(id_project, id_user, data) {
+
+    if (!this.validateSubagent(data)) {
+      throw new Error("parent_id is required for subtype 'subagent'");
+    }
+
+    // A creation body written the old way (`attributes.dsVersion`, `attributes.connectors`) is promoted
+    // to the fields, as the import does: a client not yet updated still creates a proper V3 agent.
+    v3FlowService.promoteLegacyJson(data);
+
+    if (data.connectors !== undefined && data.connectors !== null) {
+      const errors = v3FlowService.validateConnectors(data.connectors);
+      if (errors.length > 0) {
+        winston.error('(FaqService) invalid connectors list: ' + errors.join('; '));
+        throw new Error('Invalid connectors list: ' + errors.join('; '));
+      }
+    }
+
+    let chatbot = this.createChatbotObject(id_project, id_user, data);
+
+    let template;
+    if (data.type === "internal" || data.type === "tilebot") {
+      template = this.#resolveTemplate(data.subtype, data.template);
+      if (template === 'blank_subagent') {
+        this.#applyBlankSubagentAttributes(chatbot);
+      }
+    }
 
+    let options = {};
+    if (data.namespace_id) {
+      options.namespace_id = data.namespace_id;
+    }
+
+    // A V3 agent is born in V3 form: the template's blocks lose their V2 destinations and the
+    // connectors list is saved with the bot, so nothing has to be repaired on first open.
+    // A list given by the caller (an import, a fork) wins: the template is not converted then.
+    let templateFaqs = null;
+    if (template && v3FlowService.isV3(chatbot) && (data.connectors === undefined || data.connectors === null)) {
+      const flow = v3FlowService.toV3Flow(templates[template](options));
+      chatbot.connectors = flow.connectors;
+      templateFaqs = flow.intents;
+      winston.debug('(FaqService) template ' + template + ' in V3 form: ' + flow.connectors.items.length + ' connectors');
+    }
+
+    let savedChatbot;
+    try {
+      savedChatbot = await chatbot.save();
+      winston.verbose('(FaqService) saved chatbot ', savedChatbot.toObject());
+    } catch (error) {
+      throw error;
+    }
+
+    if (template) {
+      this.createGreetingsAndOperationalsFaqs(savedChatbot._id, savedChatbot.createdBy, savedChatbot.id_project, template, options, templateFaqs);
+    }
+
+    botEvent.emit('faqbot.create', savedChatbot);
+    return savedChatbot;
+  }
+
+  #applyBlankSubagentAttributes(chatbot) {
+    const notes = JSON.parse(JSON.stringify(subagentNotes.notes)).map(note => {
+      note.id_faq_kb = chatbot._id.toString();
+      return note;
     });
+
+    chatbot.attributes = {
+      ...(chatbot.attributes || {}),
+      notes
+    };
+  }
+
+  createChatbotObject(id_project, id_user, data) {
+    return new Faq_kb({
+      name: data.name,
+      slug: data.slug,
+      description: data.description,
+      url: data.url,
+      id_project: id_project.toString(),
+      webhook_url: data.webhook_url,
+      webhook_enabled: data.webhook_enabled,
+      type: data.type,
+      subtype: data.subtype,
+      language: data.language,
+      public: false,
+      certified: false,
+      mainCategory: data.mainCategory,
+      intentsEngine: data.intentsEngine,
+      trashed: false,
+      createdBy: id_user,
+      updatedBy: id_user,
+      attributes: data.attributes,
+      parent_id: data.parent_id,
+      ds_version: v3FlowService.normalizeDsVersion(data.ds_version),
+      connectors: data.connectors
+    })
+  }
+
+  validateSubagent(data) {
+    if (data.subtype === "subagent" && !data.parent_id) {
+      winston.error('(FaqService) parent_id is required for subtype ' + data.subtype);
+      return false;
+    }
+    return true;
   }
 
   #resolveTemplate(subtype, template) {
@@ -76,13 +189,14 @@ class FaqService {
     return defaultTemplate;
   }
 
-  createGreetingsAndOperationalsFaqs(faq_kb_id, created_by, projectid, template, options) {
+  createGreetingsAndOperationalsFaqs(faq_kb_id, created_by, projectid, template, options, faqs) {
     
     return new Promise( async (resolve, reject) =>  {
 
       winston.debug('(FaqService) create faqs from template: ' + template);
 
-      let faqsArray = templates[template](options);
+      // `faqs`: the template's blocks already prepared by the caller (a V3 agent); otherwise the template as it is.
+      let faqsArray = faqs || templates[template](options);
 
       faqsArray.forEach(faq => {