@tiledesk/tiledesk-tybot-connector 0.1.0

package/index.js

@@ -0,0 +1,376 @@
+const express = require('express');
+const router = express.Router();
+const bodyParser = require('body-parser');
+var cors = require('cors');
+
+//router.use(cors());
+router.use(bodyParser.json({limit: '50mb'}));
+router.use(bodyParser.urlencoded({ extended: true , limit: '50mb'}));
+
+// DEV
+//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');
+
+// PROD
+const { MessagePipeline } =  require('@tiledesk/tiledesk-chatbot-plugs/MessagePipeline');
+const { DirectivesChatbotPlug } = require('@tiledesk/tiledesk-chatbot-plugs/DirectivesChatbotPlug');
+const { SplitsChatbotPlug } = require('@tiledesk/tiledesk-chatbot-plugs/SplitsChatbotPlug');
+const { MarkbotChatbotPlug } = require('@tiledesk/tiledesk-chatbot-plugs/MarkbotChatbotPlug');
+const { WebhookChatbotPlug } = require('@tiledesk/tiledesk-chatbot-plugs/WebhookChatbotPlug');
+
+var path = require("path");
+var fs = require('fs');
+
+const { TiledeskChatbotClient } = require('@tiledesk/tiledesk-chatbot-client');
+const jwt = require('jsonwebtoken');
+const { v4: uuidv4 } = require('uuid');
+
+// THE IMPORT
+var mongoose = require('mongoose');
+var Faq = require('./models/faq');
+var Faq_kb = require('./models/faq_kb');
+let connection;
+
+router.post('/ext/:botid', async (req, res) => {
+  console.log("Reques body:", req.body);
+  res.status(200).send({"success":true});
+
+  const botId = req.params.botid;
+  console.log("query botId:", botId);
+  const message = req.body.payload;
+  const faq_kb = req.body.hook;
+  const token = req.body.token;
+  
+  //const bot = await Faq_kb.findById(botId).exec();
+  const bot = await Faq_kb.findById(botId).select('+secret').exec();
+  console.log("bot:", bot);
+
+  // CREATE TOKEN
+  //var botWithSecret = await Faq_kb.findById(bot._id).select('+secret').exec();
+
+  var signOptions = {
+    issuer:  'https://tiledesk.com',
+    subject:  'bot',
+    audience:  'https://tiledesk.com/bots/'+bot._id,   
+    jwtid: uuidv4()
+  };
+  const bot_token = jwt.sign(bot.toObject(), bot.secret, signOptions);
+  console.log("bot_token:", bot_token);
+  //
+  
+  // SETUP EXACT MATCH
+  let query = { "id_project": message.id_project, "id_faq_kb": botId, "question": message.text };
+  // BUT CHECKING ACTION BUTTON...
+  if (message.attributes && message.attributes.action) {
+    var action = message.attributes.action;
+    var action_parameters_index = action.indexOf("?");
+    if (action_parameters_index > -1) {
+        action = action.substring(0, action_parameters_index);
+    }
+    console.debug("action: " + action);
+    query = { "id_project": message.id_project, "id_faq_kb": botId, "intent_display_name": action };
+    //var isObjectId = mongoose.Types.ObjectId.isValid(action);
+    //console.debug("isObjectId:" + isObjectId);
+    //if (isObjectId) {
+    //    query = { "id_project": message.id_project, "id_faq_kb": botId, "_id": action };
+    //} else {
+    // query = { "id_project": message.id_project, "id_faq_kb": botId, $or: [{ "intent_id": action }, { "intent_display_name": action }] };
+    //}
+  }
+  
+  // SEARCH INTENTS
+  Faq.find(query).lean().exec(async (err, faqs) => {
+    if (err) {
+      return console.error("Error getting faq object.", err);
+    }
+    if (faqs && faqs.length > 0 && faqs[0].answer) { // EXACT MATCH!
+      console.log("FAQ:", faqs[0]);
+      execFaq(req, res, faqs, botId, message, bot_token, bot);
+    }
+    else { // FULL TEXT
+      console.log("Go fulltext...");
+      query = { "id_project": message.id_project, "id_faq_kb": botId };
+      var mongoproject = undefined;
+      var sort = undefined;
+      var search_obj = { "$search": message.text };
+
+      if (faq_kb.language) {
+          search_obj["$language"] = faq_kb.language;
+      }
+      query.$text = search_obj;
+      console.debug("fulltext search query", query);
+
+      mongoproject = { score: { $meta: "textScore" } };
+      sort = { score: { $meta: "textScore" } } 
+      // DA QUI RECUPERO LA RISPOSTA DATO (ID: SE EXT_AI) (QUERY FULLTEXT SE NATIVE-BASIC-AI)
+      Faq.find(query, mongoproject).sort(sort).lean().exec(async (err, faqs) => {
+        console.log("Found:", faqs);
+        if (err) {
+          console.erro("Error:", err);
+          return console.error('Error getting fulltext objects.', err);
+        }
+        console.debug("faqs:", faqs);
+        if (faqs && faqs.length > 0 && faqs[0].answer) {
+          execFaq(req, res, faqs, botId, message, bot_token, bot);
+        }
+        else {
+          // fallback
+          const fallbackIntent = await getIntentByDisplayName("defaultFallback", bot);
+          const faqs = [fallbackIntent];
+          execFaq(req, res, faqs, botId, message, bot_token, bot);
+        }
+      });
+    }
+  });
+  
+});
+
+async function execFaq(req, res, faqs, botId, message, token, bot) {
+  let sender = 'bot_' + botId;
+  console.debug("sender", sender);
+  var answerObj;
+  answerObj = faqs[0];
+  answerObj.score = 100; //exact search not set score
+  console.debug("answerObj.score", answerObj.score);
+  
+  const context = {
+    payload: {
+      //text: text,
+      bot: bot,
+      message: message, // USER MESSAGE (JSON)
+      intent: answerObj
+    },
+    token: token
+  };
+  const static_bot_answer = { // static design of the chatbot reply
+    //type: answerObj.type,
+    text: answerObj.answer,
+    attributes: answerObj.attributes,
+    metadata: answerObj.metadata,
+    // language: ?
+    // channel: ? whatsapp|telegram|facebook...
+  };
+  if (!static_bot_answer.attributes) {
+    static_bot_answer.attributes = {}
+  }
+  static_bot_answer.attributes.directives = true;
+  static_bot_answer.attributes.splits = false;
+  static_bot_answer.attributes.markbot = true;
+  
+  static_bot_answer.attributes.webhook = answerObj.webhook_enabled;
+  console.log("static_bot_answer.attributes", static_bot_answer.attributes)
+
+  // faq[0] => PIPELINE => bot_answer
+  const APIURL = "https://tiledesk-server-pre.herokuapp.com"
+  const messagePipeline = new MessagePipeline(static_bot_answer, context);
+  const webhookurl = bot.webhook_url;
+  messagePipeline.addPlug(new WebhookChatbotPlug(message.request, webhookurl, token));
+  let directivesPlug = new DirectivesChatbotPlug(message.request, APIURL, token);
+  messagePipeline.addPlug(directivesPlug);
+  messagePipeline.addPlug(new SplitsChatbotPlug());
+  messagePipeline.addPlug(new MarkbotChatbotPlug());
+  const bot_answer = await messagePipeline.exec();
+  console.log("End pipeline, bot_answer:", JSON.stringify(bot_answer));
+  
+  var attr = bot_answer.attributes;
+  if (!attr) {
+    attr = {};
+  }
+  var timestamp = Date.now();
+  attr['clienttimestamp'] = timestamp;
+  if (answerObj && answerObj._id) {
+    attr._answerid = answerObj._id.toString();
+  }
+  // DECORATES THE FINAL ANSWER
+  // question_payload = clone of user's original message
+  let question_payload = Object.assign({}, message);
+  delete question_payload.request;
+  let clonedfaqs = faqs.slice();
+  if (clonedfaqs && clonedfaqs.length > 0) {
+      clonedfaqs = clonedfaqs.shift()
+  }
+  const intent_info = {
+      intent_name: answerObj.intent_display_name,
+      is_fallback: false,
+      confidence: answerObj.score,
+      question_payload: question_payload,
+      others: clonedfaqs
+  }
+  console.debug("intent_info", intent_info);
+  attr.intent_info = intent_info;
+  const tdclient = new TiledeskChatbotClient(
+  {
+    request: req,
+    APIKEY: '__APIKEY__',
+    APIURL: APIURL
+  });
+  console.log("Sending back:", JSON.stringify(bot_answer));
+  tdclient.sendMessage(bot_answer, () => {
+    console.log("Message sent.");
+    directivesPlug.processDirectives(() => {
+      console.log("End processing directives.");
+    })
+  });
+}
+
+function getIntentByDisplayName(name, bot) {
+  return new Promise(function(resolve, reject) {
+    var query = { "id_project": bot.id_project, "id_faq_kb": bot._id, "intent_display_name": name};
+    console.debug('query', query);
+    Faq.find(query).lean().exec(function (err, faqs) {
+      if (err) {
+        return reject();
+      }
+      console.debug("faqs", faqs);
+      if (faqs && faqs.length > 0) {
+        const intent = faqs[0];
+        return resolve(intent);
+      }
+      else {
+        return resolve(null);
+      }
+    });
+  });
+}
+
+// IGNORALA
+/*app.post('/extorig', (req, res) => {
+  res.status(200).send({"success":true});
+  const tdclient = 
+    new TiledeskChatbotClient(
+      {
+        APIURL: apiurl(),
+        request: req,
+        APIKEY: '__APIKEY__'
+      });
+  if (tdclient.text === "\\start") {
+    tdclient.sendMessage(
+      {
+        text: 'started',
+        attributes: {
+          attachment: {
+            type:"template",
+            buttons: [
+              {
+                  type: "text",
+                  value: "Ok"
+              }
+            ]
+          }
+        }
+      }
+    );
+  }
+  else {
+    tdclient.sendMessage({text: 'Not trained for this'});
+  }
+});
+*/
+
+// Tiledesk Resolution-bot webhook endpoint
+/*app.post('/bot', async (req, res) => {
+  console.log("Webhook. Request body: " + JSON.stringify(req.body));
+  // INTENTS
+  let intent = null;
+  intent = req.body.payload.intent.intent_display_name;
+  //const projectId = req.body.payload.bot.id_project;
+  const token = req.body.token;
+  const request = req.body.payload.message.request;
+  //const requestId = request.request_id;
+  console.log("Got intent:", intent);
+  API_URL = apiurl();
+  const original_answer = req.body.payload.intent.answer;
+  
+  const messagePipeline = new MessagePipeline();
+  messagePipeline.addPlug(new DirectivesChatbotPlug(request, API_URL, token));
+  messagePipeline.addPlug(new SplitsChatbotPlug());
+  messagePipeline.addPlug(new MarkbotChatbotPlug());
+  
+  const message = {
+      text: original_answer
+    };
+  messagePipeline.execOn(message, (_message) => {
+    res.json(_message);
+    console.log("End pipeline.");
+  });
+  
+});*/
+
+
+
+
+
+function apiurl() {
+  const server = "pre";
+  //const server = "prod";
+  const API_URL_PRE = 'https://tiledesk-server-pre.herokuapp.com';
+  const API_URL_PROD = 'https://api.tiledesk.com/v2';
+  // choose a server
+  let API_URL = API_URL_PROD;
+  if (server === 'pre') {
+    API_URL = API_URL_PRE;
+  }
+  return API_URL;
+}
+
+
+router.get('/', (req, res) => {
+  res.send('Hello Tybot!');
+});
+
+function startTybot(settings, completionCallback) {
+  console.log("Starting Tybot with Settings:", settings);
+
+  if (!settings.MONGODB_URI) {
+    throw new Error("settings.MONGODB_URI is mandatory.");
+  }
+  if (!settings.API_ENDPOINT) {
+    throw new Error("settings.API_ENDPOINT is mandatory.");
+  }
+  else {
+    API_ENDPOINT = settings.API_ENDPOINT;
+    console.log("(Tybot) settings.API_ENDPOINT:", API_ENDPOINT);
+  }
+  if (!settings.log) {
+    log = false;
+  }
+  
+  console.log("Starting Tybot connector...");
+  console.log("(Tybot) Connecting to mongodb...");
+
+  connection = mongoose.connect(process.env.mongoUrl, { "useNewUrlParser": true, "autoIndex": false }, function(err) {
+  if (err) { 
+    console.error('Failed to connect to MongoDB on ' + settings.MONGODB_URI + " ", err);
+    //process.exit(1); // add => exitOnFail: true
+  }
+  else {
+    console.info("Tybot Mongodb connected.");
+    if (completionCallback) {
+      completionCallback();
+    }
+  }
+});  
+}
+
+/*
+var connection = mongoose.connect(process.env.mongoUrl, { "useNewUrlParser": true, "autoIndex": false }, function(err) {
+  if (err) { 
+    console.error('Failed to connect to MongoDB on ' + process.env.mongoUrl + " ", err);
+    //process.exit(1);
+  }
+  else {
+    console.info("Mongodb connected")
+  }
+});
+*/
+
+/*
+  app.listen(3000, () => {
+  console.log('server started');
+});
+*/
+
+module.exports = { router: router, startTybot: startTybot};

package/models/faq.js

@@ -0,0 +1,120 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+var { nanoid } = require("nanoid");
+const uuidv4 = require('uuid/v4');
+
+var defaultFullTextLanguage = process.env.DEFAULT_FULLTEXT_INDEX_LANGUAGE || "none";
+
+var FaqSchema = new Schema({
+  id_faq_kb: {
+    type: String,
+    index: true    
+  },
+  intent_id: { 
+    type: String,
+    required: false,
+    index:true,
+    default: function() {
+      return uuidv4();
+    } 
+  },
+  intent_display_name: { //documentare
+    type: String,
+    required: false,  
+    index:true,
+    default: function() {
+      return nanoid(6);
+    } 
+  },
+  question: {
+    type: String,
+    required: true 
+  },
+
+  webhook_enabled: { //usa questo
+    type: Boolean,
+    required: false,
+    default: false,
+  },
+  answer: {
+    type: String,
+    required: true
+  },
+  id_project: {
+    type: String,
+    required: true,
+    index: true
+  },
+  topic: {
+    type: String,
+    default: "default",
+    index: true
+    // required: true
+  },
+  status: {
+    type: String,
+    default: "live",
+    index: true
+    // required: true
+  },
+  language: {
+    type: String,
+    required: false,
+    index: true
+  },
+
+//   "stats":{  
+//     "conversation_count":2,
+//     "all_done_count":0,
+//     "wait_for_team_count":2
+//  }
+
+  createdBy: {
+    type: String,
+    required: true
+  }
+},{
+  timestamps: true,
+  toJSON: { virtuals: true } //used to polulate messages in toJSON// https://mongoosejs.com/docs/populate.html
+}
+);
+
+FaqSchema.virtual('faq_kb', {
+  ref: 'faq_kb', // The model to use
+  localField: 'id_faq_kb', // Find people where `localField`
+  foreignField: '_id', // is equal to `foreignField`
+  justOne: false,
+  //options: { sort: { name: -1 }, limit: 5 } // Query options, see http://bit.ly/mongoose-query-options
+});
+
+FaqSchema.index({ id_project: 1, id_faq_kb: 1, question: 1 }); 
+
+// https://docs.mongodb.com/manual/core/index-text/
+// https://docs.mongodb.com/manual/tutorial/specify-language-for-text-index/
+// https://docs.mongodb.com/manual/reference/text-search-languages/#text-search-languages
+
+
+FaqSchema.index({question: 'text'},
+ {"name":"faq_fulltext","default_language": defaultFullTextLanguage,"language_override": "language"}); // schema level
+
+//  FaqSchema.index({question: 'text', answer: 'text'},
+//  {"name":"faq_fulltext","default_language": defaultFullTextLanguage,"language_override": "language", weights: {question: 10,answer: 1}}); // schema level
+
+
+FaqSchema.index({ id_project: 1, id_faq_kb: 1, intent_display_name: 1  }, { unique: true }); 
+
+
+ var faq = mongoose.model('faq', FaqSchema);
+
+ //faq.on('index', function(error) {
+  // "_id index cannot be sparse"
+  //console.debug('index:', error);
+//});
+
+if (process.env.MONGOOSE_SYNCINDEX) {
+  faq.syncIndexes();
+  console.info("faq syncIndexes")
+}
+
+
+module.exports = faq;

package/models/faq_kb.js

@@ -0,0 +1,87 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+const uuidv4 = require('uuid/v4');
+
+var Faq_kbSchema = new Schema({
+  name: {
+    type: String,
+    required: true,
+    index:true
+  },
+  description: {
+    type: String,
+    // index:true
+  },
+  url: { 
+    type: String,
+    // required: true
+  },
+  webhook_url: {
+    type: String,
+    // required: true
+  },
+  webhook_enabled: { 
+    type: Boolean,
+    required: false,
+    default: false,
+  },
+  id_project: {
+    type: String,
+    required: true,
+    index: true
+  },
+  // kbkey_remote: { //serve?
+  //   type: String,
+  // },  
+  type: {
+    type: String,
+    default: 'internal',
+    index: true
+  },
+  // external: {
+  //   type: Boolean,
+  //   default: false
+  // },
+  trashed: {
+    type: Boolean,
+    index: true
+  },
+  secret: {
+    type: String,
+    required: true,
+    default: uuidv4(),
+    select: false
+  },
+  language: {
+    type: String,
+    required: false,
+    default: 'en'
+    // index: true
+  },
+  attributes: {
+    type: Object,
+  },
+  createdBy: {
+    type: String,
+    required: true
+  }
+},{
+  timestamps: true
+}
+);
+
+Faq_kbSchema.virtual('fullName').get(function () {
+  // winston.debug("faq_kb fullName virtual called");
+  return (this.name);
+});
+
+var faq_kb = mongoose.model('faq_kb', Faq_kbSchema);
+
+if (process.env.MONGOOSE_SYNCINDEX) {
+  faq_kb.syncIndexes();
+  console.log("faq_kb syncIndexes");
+}
+
+
+
+module.exports = faq_kb

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@tiledesk/tiledesk-tybot-connector",
+  "version": "0.1.0",
+  "description": "Tiledesk Tybot connector",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@tiledesk/tiledesk-chatbot-client": "^0.5.30",
+    "@tiledesk/tiledesk-chatbot-util": "^0.8.36",
+    "@tiledesk/tiledesk-client": "^0.8.28",
+    "@tiledesk/tiledesk-chatbot-plugs": "^0.1.1",
+    "axios": "^0.27.2",
+    "body-parser": "^1.19.0",
+    "express": "^4.17.1",
+    "jsonwebtoken": "^8.5.1",
+    "mongoose": "^6.3.5",
+    "nanoid": "^3.1.25",
+    "request": "^2.88.2",
+    "uuid": "^3.3.3",
+    "cors": "^2.8.5"
+  }
+}

package/publish.sh

@@ -0,0 +1,10 @@
+#npm version patch
+version=`node -e 'console.log(require("./package.json").version)'`
+echo "version $version"
+
+if [ "$version" != "" ]; then
+    git tag -a "$version" -m "`git log -1 --format=%s`"
+    echo "Created a new tag, $version"
+    git push --tags
+    npm publish --access public
+fi

package/tiledeskChatbotPlugs/DirectivesChatbotPlug.js

@@ -0,0 +1,218 @@
+const { TiledeskChatbotUtil } = require('@tiledesk/tiledesk-chatbot-util');
+const { TiledeskClient } = require('@tiledesk/tiledesk-client');
+
+class DirectivesChatbotPlug {
+
+  /**
+   * @example
+   * const { DirectivesChatbotPlug } = require('./DirectivesChatbotPlug');
+   * 
+   */
+
+  constructor(supportRequest, API_URL, token) {
+    this.supportRequest = supportRequest;
+    this.API_URL = API_URL;
+    this.token = token;
+  }
+
+  exec(pipeline) {
+    let message = pipeline.message;
+    if (message.attributes && message.attributes.directives && message.attributes.directives == true) {
+      const message_text = message.text;
+      console.log("processing message:", message_text);
+      /*const message_text =
+`We are looking for an operator..
+-
+JUST WAIT A MOMENT
+\\agent`;*/
+      let parsed_result = TiledeskChatbotUtil.parseDirectives(message_text);
+      console.log("Message directives:", parsed_result);
+      console.log("Message text ripped from directives:", parsed_result.text);
+      if (parsed_result && parsed_result.directives && parsed_result.directives.length > 0) {
+        // do not process more intents. Process directives and return
+        const text = parsed_result.text;
+        message.text = text;
+        this.directives = parsed_result.directives;
+        pipeline.nextplug();
+        /*this.processDirectives( () => {
+          console.log("End process directives.");
+          pipeline.nextplug();
+        });*/
+      }
+      else {
+        pipeline.nextplug();
+      }
+    }
+    else {
+      pipeline.nextplug();
+      return;
+    }
+    
+  }
+
+
+  
+  moveToDepartment(tdclient, requestId, depName, callback) {
+    tdclient.getAllDepartments((err, deps) => {
+      console.log("deps:", deps, err);
+      if (err) {
+        console.error("getAllDepartments() error:", err);
+        callback(err);
+        return;
+      }
+      let dep = null;
+      for(i=0; i < deps.length; i++) {
+        d = deps[i];
+        if (d.name.toLowerCase() === depName.toLowerCase()) {
+          dep = d;
+          break;
+        }
+      }
+      if (dep) {
+        tdclient.updateRequestDepartment(requestId, dep._id, null, (err) => {
+          if (err) {
+            console.error("An error:", err);
+            callback(err);
+          }
+          else {
+            callback();
+          }
+        });
+      }
+    });
+  }
+
+  processDirectives(theend) {
+    
+    const directives = this.directives;
+    if (!directives || directives.length === 0) {
+      console.log("No directives to process.");
+      return;
+    }
+    const supportRequest = this.supportRequest;
+    const token = this.token;
+    const API_URL = this.API_URL;
+      
+    const requestId = supportRequest.request_id
+    const depId = supportRequest.department._id;
+    const projectId = supportRequest.id_project;
+    const tdclient = new TiledeskClient({
+      projectId: projectId,
+      token: token,
+      APIURL: API_URL,
+      APIKEY: "___",
+      log:false
+    });
+    
+    let i = -1;
+    console.log("processing directives:", directives);
+    function process(directive) {
+      if (directive) {
+        console.log("directive:", directive);
+        console.log("directive.name:", directive.name);
+      }
+      let directive_name = null;
+      if (directive && directive.name) {
+        directive_name = directive.name.toLowerCase();
+      }
+      if (directive == null) {
+        theend();
+      }
+      else if (directive_name === TiledeskChatbotUtil.DEPARTMENT_DIRECTIVE) {
+        let dep_name = "default department";
+        if (directive.parameter) {
+          dep_name = directive.parameter;
+        }
+        console.log("department:", dep_name);
+        moveToDepartment(tdclient, requestId, dep_name, () => {
+          console.log("moved to department:", dep_name);
+          process(nextDirective());
+        });
+      }
+      else if (directive_name === TiledeskChatbotUtil.HMESSAGE_DIRECTIVE) {
+        if (directive.parameter) {
+          let text = directive.parameter.trim();
+          let message = {
+            text: text,
+            attributes: {
+              subtype: "info"
+            }
+          };
+          console.log("Message:", message)
+          tdclient.sendSupportMessage(requestId, message, () => {
+            process(nextDirective());
+          });
+        }
+      }
+      else if (directive_name === TiledeskChatbotUtil.MESSAGE_DIRECTIVE) {
+        if (directive.parameter) {
+          let text = directive.parameter.trim();
+          let message = {text: text};
+          console.log("text.lastIndexOf(hide)", text.lastIndexOf("\\hide"))
+          if (text.lastIndexOf("\\hide") >= 0) {
+            console.log("HIDDEN");
+            message.text = text.slice(0, text.lastIndexOf("\\hide")).trim();
+            message.attributes = {
+              subtype: "info"
+            }
+          }
+          console.log("Message:", message)
+          tdclient.sendSupportMessage(requestId, message, () => {
+            process(nextDirective());
+          });
+        }
+      }
+      else if (directive_name === "\\agent") {
+        console.log("assign to request:", requestId);
+        console.log("assign to dep:", depId);
+        console.log("assign to dep name:", supportRequest.department.name);
+        tdclient.log = true;
+        tdclient.agent(requestId, depId, (err) => {
+          if (err) {
+            console.error("Error moving to agent:", err);
+          }
+          else {
+            console.log("Successfully moved to agent");
+          }
+          process(nextDirective());
+        });
+      }
+      else if (directive_name === "\\removecurrentbot") {
+        console.log("assign to request:", requestId);
+        console.log("assign to dep:", depId);
+        console.log("assign to dep name:", request.department.name);
+        tdclient.log = true;
+        tdclient.removeCurrentBot(requestId, (err) => {
+          if (err) {
+            console.error("Error removeCurrentBot():", err);
+          }
+          else {
+            console.log("Successfully removeCurrentBot()");
+          }
+          process(nextDirective());
+        });
+      }
+      else {
+        console.log("Unknown directive:", directive.name);
+        process(nextDirective());
+      }
+    }
+    process(nextDirective());
+    
+    function nextDirective() {
+      i += 1;
+      console.log("i:", i);
+      if (i < directives.length) {
+        let nextd = directives[i];
+        console.log("next:", nextd);
+        return nextd;
+      }
+      else {
+        return null;
+      }
+    }
+  }
+  
+}
+
+module.exports = { DirectivesChatbotPlug };

package/tiledeskChatbotPlugs/MarkbotChatbotPlug.js

@@ -0,0 +1,85 @@
+const { TiledeskChatbotUtil } = require('@tiledesk/tiledesk-chatbot-util');
+
+class MarkbotChatbotPlug {
+
+  
+/**
+   * @example
+   * const { MarkbotChatbotPlug } = require('./MarkbotChatbotPlug');
+   * 
+   */
+
+  constructor() {
+  }
+
+  exec(pipeline) {
+    let message = pipeline.message;
+    console.log("markbot, message.attributes", message.attributes)
+    if (message.attributes && message.attributes.markbot != undefined && message.attributes.markbot == false) {
+      console.log("markbot disabled")
+      pipeline.nextplug();
+      return;
+    }
+    // the legacy 'microlanguage' command
+    /*if (message.attributes && message.attributes.microlanguage != undefined && message.attributes.microlanguage == false) {
+      console.log("microlanguage disabled");
+      pipeline.nextplug();
+      return;
+    }*/
+    
+    if (!message.attributes) {
+      message.attributes = {}
+    }
+    
+    if (message.text) {
+      console.log("markbotting main message...");
+      let parsed_reply = TiledeskChatbotUtil.parseReply(message.text);
+      console.log("parsed", JSON.stringify(parsed_reply));
+      if (parsed_reply) {
+        message.text = parsed_reply.message.text;
+        message.type = parsed_reply.message.type;
+        message.metadata = parsed_reply.message.metadata;
+        console.log("parsed_reply.message.attributes", parsed_reply.message.attributes);
+        if (parsed_reply.message.attributes) {
+          for(const [key, value] of Object.entries(parsed_reply.message.attributes)) {
+            console.log("key:", key)
+            console.log("value:", value)
+            
+            message.attributes[key] = value;
+          }
+        }
+        //message.attributes.attachment = parsed_reply.message.attributes.attachment;  
+      }
+    }
+    
+    if (message.attributes && message.attributes.commands) {
+      let commands = message.attributes.commands;
+      console.log("commands for markbot:", commands);
+      if (commands.length > 1) {
+        for (let i = 0; i < commands.length; i++) {
+          if (commands[i].type === 'message' && commands[i].message && commands[i].message.text) {
+            let parsed_reply = TiledeskChatbotUtil.parseReply(commands[i].message.text);
+            //console.log("PARSED***", parsed_reply);
+            commands[i].message = parsed_reply.message;
+          }
+        }
+      }
+    }
+    console.log("Message out of Markbot:", JSON.stringify(message));
+    pipeline.nextplug(pipeline);
+    
+  }
+  
+/*
+  next(pipeline, completionCallback) {
+    const plug = pipeline.nextplug();
+    if (!plug) {
+      completionCallback();
+    }
+    else {
+      plug.exec(pipeline);
+    }
+  }*/
+}
+
+module.exports = { MarkbotChatbotPlug };

package/tiledeskChatbotPlugs/MessagePipeline.js

@@ -0,0 +1,116 @@
+class MessagePipeline {
+
+  /**
+   * @example
+   * const { MessagePipeline } = require('./MessagePipeline');
+   * 
+   */
+
+  constructor(message, context) {
+    this.context = context;
+    this.message = message;
+    this.plugs = [];
+    this.counter = -1;
+  }
+
+  addPlug(plug) {
+    this.plugs.push(plug);
+  }
+
+  exec(completionCallback) {
+    this.completionCallback = completionCallback;
+    return new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+      this.nextplug();
+    });
+  }
+  
+  /*
+exec(completionCallback) {
+    this.completionPromise = new Promise((resolve, reject) => {
+      console.log("The context", context)
+      const plug = this.nextplug();
+      if (!plug) {
+        console.log("NO PLUGS!");
+        if (completionCallback) {
+            console.log("completionCallback found.");
+            completionCallback();
+          }
+          console.log("Resolving...", this.message);
+          return resolve();
+      }
+      else {
+        plug.exec(this, () => {
+          if (completionCallback) {
+            console.log("completionCallback found.");
+            completionCallback();
+          }
+          console.log("Resolving...", this.message);
+          return resolve();
+        });
+      }
+    });
+    return this.completionPromise;
+  }
+  */
+  
+  /*execOn(message, context, completionCallback) {
+    return new Promise((resolve, reject) => {
+      this.message = message;
+      console.log("The context", context)
+      this.process(this.nextplug(), context, (message) => {
+        console.log("All plugs processed.", message)
+        if (completionCallback) {
+          console.log("completionCallback found.")
+          completionCallback(message);
+        }
+        console.log("Resolving...", message)
+        return resolve(message);
+      });
+    });
+  }*/
+
+  /*process(plug, context, completionCallback) {
+    if (plug) {
+      plug.execOn(this.message, context, () => {
+        this.process(this.nextplug(), context, completionCallback);
+      });
+    }
+    else {
+      completionCallback(this.message);
+    }
+  }*/
+
+  nextplug() {
+    this.counter += 1;
+    console.log(`processing plug[${this.counter}]`);
+    if (this.counter < this.plugs.length) {
+      console.log("Still plugs...")
+      let nextp = this.plugs[this.counter];
+      console.log("nextp is:", nextp)
+      nextp.exec(this);
+    }
+    else {
+      console.log("no more plugs");
+      this.resolve(this.message);
+    }
+  }
+  /*
+  nextplug() {
+    this.counter += 1;
+    console.log(`processing plug[${this.counter}]`);
+    if (this.counter < this.plugs.length) {
+      let nextp = this.plugs[this.counter];
+      return nextp;
+    }
+    else {
+      console.log("no more plugs");
+      return null;
+    }
+  }
+  */
+  
+}
+
+module.exports = { MessagePipeline };

package/tiledeskChatbotPlugs/SplitsChatbotPlug.js

@@ -0,0 +1,48 @@
+const { TiledeskChatbotUtil } = require('@tiledesk/tiledesk-chatbot-util');
+
+class SplitsChatbotPlug {
+
+  
+/**
+   * @example
+   * const { SplitsChatbotPlug } = require('./SplitsChatbotPlug');
+   * 
+   */
+
+  constructor() {
+  }
+
+  exec(pipeline) {
+    let message = pipeline.message;
+    if (message.attributes && message.attributes.splits && message.attributes.splits == false) {
+      completionCallback(message);
+      return;
+    }
+    console.log("Splitting...")
+    // if splits found just a attributs.commands payload is attached
+    // to the original json message with split commands
+    let commands = TiledeskChatbotUtil.splitPars(message.text);
+    console.log("commands", commands)
+    if (commands && commands.length > 1) {
+      if (!message.attributes) {
+        message.attributes = {}
+      }
+      message.attributes.commands = commands;
+    }
+    console.log("Message out of Splits plugin:", JSON.stringify(message));
+    pipeline.nextplug();
+    //next(pipeline, completionCallback);
+  }
+
+  next(pipeline, completionCallback) {
+    const plug = pipeline.nextplug();
+    if (!plug) {
+      completionCallback();
+    }
+    else {
+      plug.exec(pipeline);
+    }
+  }
+}
+
+module.exports = { SplitsChatbotPlug };

package/tiledeskChatbotPlugs/WebhookChatbotPlug.js

@@ -0,0 +1,182 @@
+let axios = require('axios');
+
+class WebhookChatbotPlug {
+
+  /**
+   * @example
+   * const { DirectivesChatbotPlug } = require('./DirectivesChatbotPlug');
+   * 
+   */
+
+  constructor(supportRequest, webhookurl, token) {
+    this.supportRequest = supportRequest;
+    this.webhookurl = webhookurl;
+    this.token = token;
+  }
+
+  exec(pipeline) {
+    let message = pipeline.message;
+    let context = pipeline.context;
+    console.log("EXECUTIN WEBHOOK", message.attributes)
+    console.log("EXECUTIN WEBHOOK.webhook", message.attributes.webhook)
+    console.log("EXECUTIN WEBHOOK", message.attributes)
+    if (message.attributes && message.attributes.webhook && message.attributes.webhook === true) {
+      console.log("EXECUTING WEBHOOK!", this.webhookurl);
+      this.execWebhook(message, context, this.webhookurl, (err, message_from_webhook) => {
+        console.log("Err", err)
+        console.log("message", message_from_webhook)
+        if (err) {
+          console.error("Error calling webhook", this.webhookurl)
+          pipeline.nextplug();
+        }
+        else {
+          console.log("Webhook successfully end:", message_from_webhook);
+          pipeline.message = message_from_webhook;
+          pipeline.nextplug();
+        }
+      });
+    }
+    else {
+      console.log("NO WEBHOOK!");
+      pipeline.nextplug();
+      return;
+    }
+    console.log("Start processing webhook...");
+  }
+  
+  execWebhook(reply_message, context, webhookurl, callback) {
+    console.log("WEBHOOK. on context", context)
+    console.log("WEBHOOK. on message", reply_message)
+    const HTTPREQUEST = {
+      url: webhookurl,
+      headers: {
+        'Content-Type' : 'application/json', 
+        'User-Agent': 'tiledesk-bot',
+        'Origin': "pre"
+      },
+      json: context,
+      method: 'POST'
+    };
+    WebhookChatbotPlug.myrequest(
+      HTTPREQUEST,
+      function(err, res) {
+        if (err || (res && res.status >= 400) || (res && !res.data)) {
+          console.error("An error occurred calling intent's webhook url:", webhookurl);
+          if (callback) {
+            callback(reply_message);
+          }
+        }
+        else {
+          console.log("Hello", res.data)
+          if (callback) {
+            callback(null, res.data);
+          }
+        }
+      }, this.log
+    );
+
+    /*
+    return request({                    
+                    uri :  webhookurl,
+                    headers: {
+                        'Content-Type' : 'application/json', 
+                        'User-Agent': 'tiledesk-bot',
+                        'Origin': webhook_origin
+                         //'x-hook-secret': s.secret
+                       },
+                    method: 'POST',
+                    json: true,
+                    body: {payload:{text: text, bot: bot, message: message, intent: faq}, token: token},
+                    // }).then(response => {
+                    }, function(err, response, json){
+                        if (err) {
+                            winston.error("Error from webhook reply of getParsedMessage. Return standard reply", err);
+
+                            return resolve(messageReply);
+
+                            // return error
+                            
+                        }
+                         if (response.statusCode >= 400) {      
+                            winston.verbose("The ChatBot webhook return error http status code. Return standard reply", response);            
+                            return resolve(messageReply);
+                        }
+
+                        if (!json) { //the webhook return empty body
+                            winston.verbose("The ChatBot webhook return no json. Return standard reply", response);
+                            return resolve(messageReply);
+                        }
+                       
+                        winston.debug("webhookurl repl_message ", response);
+
+                        var text = undefined;
+                        if(json && json.text===undefined) {
+                            winston.verbose("webhookurl json is defined but text not. return standard reply",{json:json, response:response});
+                            // text = 'Field text is not defined in the webhook respose of the faq with id: '+ faq._id+ ". Error: " + JSON.stringify(response);
+                            return resolve(messageReply);
+                        }else {
+                            text = json.text;
+                        }
+                        winston.debug("webhookurl text:  "+ text);
+
+                        // // let cloned_message = Object.assign({}, messageReply);
+                        // let cloned_message =  message;
+                        // winston.debug("cloned_message :  ",cloned_message);
+
+                        // if (json.attributes) {
+                        //     if (!cloned_message.attributes) {
+                        //         cloned_message.attributes = {}
+                        //     }
+                        //     winston.debug("ChatBot webhook json.attributes: ",json.attributes);
+                        //     for(const [key, value] of Object.entries(json.attributes)) {
+                        //         cloned_message.attributes[key] = value
+                        //     }
+                        // }
+
+                        // winston.debug("cloned_message after attributes:  ",cloned_message);
+
+                        that.parseMicrolanguage(text, message, bot, faq, true, json).then(function(bot_answer) {
+                            return resolve(bot_answer);
+                        });
+                    });
+    */
+  }
+
+  // ************************************************
+  // ****************** HTTP REQUEST ****************
+  // ************************************************
+
+  static myrequest(options, callback, log) {
+    if (log) {
+      console.log("API URL:", options.url);
+      console.log("** Options:", options);
+    }
+    axios(
+      {
+        url: options.url,
+        method: options.method,
+        data: options.json,
+        headers: options.headers
+      })
+    .then(function (res) {
+      if (log) {
+        console.log("Response for url:", options.url);
+        console.log("Response headers:\n", res.headers);
+        console.log("******** Response for url:", res);
+        console.log("Response body:\n", res.data);
+      }
+      if (callback) {
+        callback(null, res);
+      }
+    })
+    .catch(function (error) {
+      console.error("An error occurred:", error);
+      if (callback) {
+        callback(error, null, null);
+      }
+    });
+  }
+  
+}
+
+module.exports = { WebhookChatbotPlug };

package/tiledeskChatbotPlugs/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@tiledesk/tiledesk-chatbot-plugs",
+  "version": "0.1.1",
+  "description": "Tiledesk Chatbot Plugs",
+  "engines": {
+    "node": ">=12.x"
+  },
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Tiledesk/tiledesk-chatbot.git"
+  },
+  "author": "Andrea Sponziello",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Tiledesk/tiledesk-chatbot/issues"
+  },
+  "homepage": "https://github.com/Tiledesk/tiledesk-chatbot#readme",
+  "dependencies": {
+    "@tiledesk/tiledesk-chatbot-util": "^0.8.36",
+    "@tiledesk/tiledesk-client": "^0.8.28",
+    "axios": "^0.27.2"
+  }
+}

package/tiledeskChatbotPlugs/publish.sh

@@ -0,0 +1,10 @@
+#npm version patch
+version=`node -e 'console.log(require("./package.json").version)'`
+echo "version $version"
+
+if [ "$version" != "" ]; then
+    git tag -a "$version" -m "`git log -1 --format=%s`"
+    echo "Created a new tag, $version"
+    git push --tags
+    npm publish --access public
+fi