@tiledesk/tiledesk-tybot-connector 0.2.601-rc1 → 0.3.1

package/tiledeskChatbotPlugs/directives/DirBrevo.js

@@ -0,0 +1,353 @@
+const axios = require("axios").default;
+const { TiledeskChatbot } = require("../../models/TiledeskChatbot");
+const { Filler } = require("../Filler");
+const { DirIntent } = require("./DirIntent");
+let https = require("https");
+require('dotenv').config();
+
+
+class DirBrevo {
+
+  constructor(context) {
+    if (!context) {
+      throw new Error('context object is mandatory');
+    }
+    this.context = context;
+    this.tdcache = this.context.tdcache;
+    this.requestId = this.context.requestId;
+    this.intentDir = new DirIntent(context);
+    this.API_ENDPOINT = this.context.API_ENDPOINT;
+    this.log = context.log;
+  }
+
+  execute(directive, callback) {
+    if (this.log) { console.log("DirBrevo directive: ", directive); }
+    let action;
+    if (directive.action) {
+      action = directive.action;
+    }
+    else {
+      console.error("DirBrevo Incorrect directive: ", JSON.stringify(directive));
+      callback();
+      return;
+    }
+    this.go(action, (stop) => {
+      callback(stop);
+    })
+  }
+
+  async go(action, callback) {
+    if (this.log) { console.log("DirBrevo action:", JSON.stringify(action)); }
+    if (!this.tdcache) {
+      console.error("Error: DirBrevo tdcache is mandatory");
+      callback();
+      return;
+    }
+
+    let trueIntent = action.trueIntent;
+    let falseIntent = action.falseIntent;
+    let trueIntentAttributes = action.trueIntentAttributes;
+    let falseIntentAttributes = action.falseIntentAttributes;
+
+    if (this.log) {
+      console.log("DirBrevo trueIntent", trueIntent)
+      console.log("DirBrevo falseIntent", falseIntent)
+      console.log("DirBrevo trueIntentAttributes", trueIntentAttributes)
+      console.log("DirBrevo falseIntentAttributes", falseIntentAttributes)
+    }
+
+    let requestVariables = null;
+    requestVariables =
+      await TiledeskChatbot.allParametersStatic(
+        this.tdcache, this.requestId
+      )
+
+    //let token = action.token;
+    let bodyParameters = action.bodyParameters;
+    if (this.log) { console.log("DirBrevo bodyParameters: ", bodyParameters); }
+
+    if (!bodyParameters || bodyParameters === '') {
+      if (this.log) { console.error("DirBrevo ERROR - bodyParameters is undefined or null or empty string") };
+      callback();
+      return;
+    }
+
+    const brevo_base_url = process.env.BREVO_ENDPOINT || "https://api.brevo.com/v3"
+    if (this.log) { console.log("DirBrevo brevo_base_url ", brevo_base_url); }
+
+    let key = await this.getKeyFromIntegrations();
+    if (this.log) { console.log('DirBrevo key Debug1: ', key) }
+    // ONLY FOR DEBUG CANCELLARE!!!!!
+    //  if (process.env.BREVO_DEBUG == '1') {
+    //   key = process.env.BREVO_TOKEN;
+    //  }
+    if (!key) {
+      if (this.log) { console.log("DirBrevo - Key not found in Integrations."); }
+      if (falseIntent) {
+        await this.#executeCondition(false, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes);
+        callback(true);
+        return;
+      }
+    }
+
+    const filler = new Filler();
+    for (const [key, value] of Object.entries(bodyParameters)) {
+      if (this.log) { console.log("bodyParam:", key, "value:", value) }
+      let filled_value = filler.fill(value, requestVariables);
+      bodyParameters[key] = filled_value;
+    }
+    if (this.log) { console.log('DirBrevo bodyParameters filler: ', bodyParameters) }
+
+    // CREATE THE JSON FOR BREVO
+    let brevo_email = '';
+    let brevo_bodyParameters = {};
+    for (const [key, value] of Object.entries(bodyParameters)) {
+      if (this.log) { console.log("bodyParam:", key, "value:", value) }
+      if (key === 'email') {brevo_email = value}
+      else { brevo_bodyParameters[key] = value;}
+    }
+    if (this.log) { console.log('DirBrevo brevo_email: ', brevo_email) }
+    if (this.log) { console.log('DirBrevo brevo_bodyParameters: ', brevo_bodyParameters) }
+
+
+    let json = {
+      email: brevo_email,
+      attributes: brevo_bodyParameters,
+      "emailBlacklisted": false,
+			"smsBlacklisted": false,
+			"listIds": [
+					  0
+			],
+			"updateEnabled": false,
+			"smtpBlacklistSender": [
+					"info@mytest.com"
+			]
+    }
+    if (this.log) { console.log('DirBrevo key Debug2: ', key) }
+    //----------------
+    if (this.log) {console.log("DirBrevo brevo_base_url ",brevo_base_url);}
+    if (this.log) { console.log('DirBrevo json: ', json) }
+    const BREVO_HTTPREQUEST = {
+      url: brevo_base_url + '/contacts',
+      headers: {
+        'api-key': key,
+        'Content-Type': 'application/json',
+        'Accept': 'application/json'
+      },
+      json: json,
+      method: "POST"
+    }
+    if (this.log) { console.log("DirBrevo BREVO_HTTPREQUEST", JSON.stringify(BREVO_HTTPREQUEST)); }
+
+    this.#myrequest(
+      BREVO_HTTPREQUEST, async (err, resbody) => {
+        if (err) {
+          if (callback) {
+            if (this.log) {
+              console.error("(httprequest) DirBrevo err response:", err.response)
+              console.error("(httprequest) DirBrevo err data:", err.response.data)
+            };
+
+            let result = null;
+            let status = null;
+            let error;
+
+            if (err.response &&
+                err.response.status) {
+                  status = err.response.status;
+            }
+
+            if (err.response &&
+                err.response.data &&
+                err.response.data.message) {
+                  error = err.response.data.message;
+            }
+
+            if (this.log) {
+              console.error("(httprequest) DirBrevo err data result:", result); // CONTROLLA IL VALORE
+              console.error("(httprequest) DirBrevo err data status:", status);
+              console.error("(httprequest) DirBrevo err data error:", error);
+            }
+
+            await this.#assignAttributes(action, status, result, error);
+            if (falseIntent) {
+              await this.#executeCondition(false, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes);
+              callback(true);
+              return;
+            }
+            callback();
+            return;
+          }
+        } else if (callback) {
+          if (this.log) { console.log("DirBrevo resbody: ", JSON.stringify(resbody, null, 2).slice(2, -1)); }
+
+          let status = 201;
+          let error = null;
+          let result = JSON.stringify(resbody, null, 2).slice(2, -1);
+          await this.#assignAttributes(action, status, result, error);
+          if (trueIntent) {
+            await this.#executeCondition(true, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes)
+            callback(true);
+            return;
+          }
+          callback();
+          return;
+        }
+      }
+    );
+
+  }
+
+  async #assignAttributes(action, status, result, error) {
+    if (this.log) {
+      console.log("DirBrevo assignAttributes action:", action)
+      console.log("DirBrevo assignAttributes status:", status)
+      console.log("DirBrevo assignAttributes result:", result)
+      console.log("DirBrevo assignAttributes error:", error)
+    }
+    if (this.context.tdcache) {
+      if (action.assignStatusTo) {
+        await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.assignStatusTo, status);
+      }
+      if (action.assignResultTo) {
+        await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.assignResultTo, result);
+      }
+      if (action.assignErrorTo) {
+        await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.assignErrorTo, error);
+      }
+
+      // Debug log
+      if (this.log) {
+        const all_parameters = await TiledeskChatbot.allParametersStatic(this.context.tdcache, this.context.requestId);
+        for (const [key, value] of Object.entries(all_parameters)) {
+          if (this.log) { console.log("DirBrevo request parameter:", key, "value:", value, "type:", typeof value) }
+        }
+      }
+    }
+  }
+
+  #myrequest(options, callback) {
+    if (this.log) {
+      console.log("** API URL:", options.url);
+      console.log("** Options:", JSON.stringify(options));
+    }
+    let axios_options = {
+      url: options.url,
+      method: options.method,
+      params: options.params,
+      headers: options.headers
+    }
+    if (options.json !== null) {
+      axios_options.data = options.json
+    }
+    if (this.log) {
+      console.log("axios_options:", JSON.stringify(axios_options));
+    }
+    if (options.url.startsWith("https:")) {
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+      axios_options.httpsAgent = httpsAgent;
+    }
+    axios(axios_options)
+      .then((res) => {
+        if (this.log) {
+          console.log("Response for url:", options.url);
+          console.log("Response headers:\n", JSON.stringify(res.headers));
+          console.log("Response status:", JSON.stringify(res.status));
+        }
+        if (res && (res.status == 200 || res.status == 201) && res.data) {
+          if (callback) {
+            callback(null, res.data);
+          }
+        }
+        else {
+          if (callback) {
+            callback(new Error("Response status is not 200"), null);
+          }
+        }
+      })
+      .catch((error) => {
+        if (callback) {
+          callback(error, null);
+        }
+      });
+  }
+
+  async #executeCondition(result, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes, callback) {
+    let trueIntentDirective = null;
+
+    if (trueIntent) {
+      trueIntentDirective = DirIntent.intentDirectiveFor(trueIntent, trueIntentAttributes);
+    }
+    let falseIntentDirective = null;
+    if (falseIntent) {
+      falseIntentDirective = DirIntent.intentDirectiveFor(falseIntent, falseIntentAttributes);
+    }
+    if (this.log) { console.log('DirBrevo executeCondition/result', result) }
+    if (result === true) {
+      if (trueIntentDirective) {
+        this.intentDir.execute(trueIntentDirective, () => {
+          if (callback) {
+            callback();
+          }
+        });
+      }
+      else {
+        if (this.log) { console.log("No trueIntentDirective specified"); }
+        if (callback) {
+          callback();
+        }
+      }
+    }
+    else {
+      if (falseIntentDirective) {
+        this.intentDir.execute(falseIntentDirective, () => {
+          if (callback) {
+            callback();
+          }
+        });
+      }
+      else {
+        if (this.log) { console.log("No falseIntentDirective specified"); }
+        if (callback) {
+          callback();
+        }
+      }
+    }
+  }
+
+  async getKeyFromIntegrations() {
+    return new Promise((resolve) => {
+
+      const INTEGRATIONS_HTTPREQUEST = {
+        url: this.API_ENDPOINT + "/" + this.context.projectId + "/integration/name/Brevo",
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'JWT ' + this.context.token
+        },
+        method: "GET"
+      }
+      if (this.log) { console.log("Brevo INTEGRATIONS_HTTPREQUEST ", INTEGRATIONS_HTTPREQUEST) }
+
+      this.#myrequest(
+        INTEGRATIONS_HTTPREQUEST, async (err, integration) => {
+          if (err) {
+            resolve(null);
+          } else {
+
+            if (integration &&
+              integration.value) {
+              resolve(integration.value.apikey)
+            }
+            else {
+              resolve(null)
+            }
+          }
+        })
+    })
+  }
+
+}
+
+module.exports = { DirBrevo }

package/tiledeskChatbotPlugs/directives/DirCaptureUserReply.js

@@ -7,37 +7,10 @@ class DirCaptureUserReply {
     if (!context) {
       throw new Error('context object is mandatory.');
     }
+    
     this.context = context;
     this.reply = context.reply;
-    // reply = {
-    //   actions: [
-    //     {
-    //       _tdActionType: 'askgpt',
-    //       _tdActionTitle: 'gpt action',
-    //       assignReplyTo: 'gpt_reply',
-    //       assignSourceTo: 'gpt_source',
-    //       kbid: 'XXX',
-    //       trueIntent: '#SUCCESS',
-    //       falseIntent: '#FAILURE',
-    //       question: 'this is the question: ${last_user_message}'
-    //     }
-    //   ],
-    //   attributes: {
-    //     clienttimestamp: 1695548792706,
-    //     intent_info: {
-    //       intent_name: 'gpt success',
-    //       intent_id: '00f93b97-89ee-466d-a09c-e47a18943057',
-    //       is_fallback: false,
-    //       confidence: undefined,
-    //       question_payload: [Object],
-    //       botId: 'botID',
-    //       bot: [Object]
-    //     },
-    //     webhook: false
-    //   }
-    // }
     this.message = context.message;
-    this.tdclient = context.tdclient;
     this.chatbot = context.chatbot;
     this.tdcache = context.tdcache;
     this.requestId = context.requestId;
@@ -75,8 +48,8 @@ class DirCaptureUserReply {
       // console.log("(DirCaptureUserReply) lockIntent");
       await this.chatbot.lockAction(this.requestId, actionId);
       // console.log("(DirCaptureUserReply) lockAction");
-      let _lockedAction = await this.chatbot.currentLockedAction(this.requestId);
-      let _lockedIntent = await this.chatbot.currentLockedIntent(this.requestId);
+      // let _lockedAction = await this.chatbot.currentLockedAction(this.requestId);
+      // let _lockedIntent = await this.chatbot.currentLockedIntent(this.requestId);
       // console.log("(DirCaptureUserReply) _lockedAction", _lockedAction)
       // console.log("(DirCaptureUserReply) _lockedIntent", _lockedIntent)
       callback();

package/tiledeskChatbotPlugs/directives/DirClearTranscript.js

@@ -0,0 +1,22 @@
+
+const { TiledeskChatbotUtil } = require('../../models/TiledeskChatbotUtil');
+
+class DirClearTranscript {
+
+    constructor(context) {
+        if (!context) {
+            throw new Error('context object is mandatory.');
+        }
+        this.context = context;
+        this.requestId = context.requestId;
+    }
+    
+    execute(directive, callback) {
+        TiledeskChatbotUtil.clearConversationTranscript(this.context.chatbot, () => {
+            callback();
+        });
+    }
+
+  }
+  
+  module.exports = { DirClearTranscript };

package/tiledeskChatbotPlugs/directives/DirClose.js

@@ -1,4 +1,7 @@
 
+const { TiledeskClient } = require("@tiledesk/tiledesk-client");
+const { TiledeskChatbotConst } = require("../../models/TiledeskChatbotConst");
+
 class DirClose {
 
     constructor(context) {
@@ -6,17 +9,27 @@ class DirClose {
             throw new Error('context object is mandatory.');
         }
         this.context = context;
-        this.tdclient = context.tdclient;
         this.requestId = context.requestId;
+        this.chatbot = context.chatbot;
+        this.API_ENDPOINT = context.API_ENDPOINT;
+        this.log = context.log;
+
+        this.tdClient = new TiledeskClient({
+            projectId: this.context.projectId,
+            token: this.context.token,
+            APIURL: this.API_ENDPOINT,
+            APIKEY: "___",
+            log: this.log
+        });
     }
     
     execute(directive, callback) {
-        this.tdclient.closeRequest(this.requestId, (err) => {
+        this.tdClient.closeRequest(this.requestId, async (err) => {
             if (err) {
                 console.error("Error in 'close directive':", err);
             }
             else {
-                // console.log("Successfully closed on close()");
+                await this.chatbot.deleteParameter(TiledeskChatbotConst.USER_INPUT);
             }
             callback();
         });

package/tiledeskChatbotPlugs/directives/DirCode.js

@@ -81,7 +81,7 @@ class DirCode {
       // console.log("newvars_del:", newvars_del);
     }
     catch(err) {
-      console.error("An error occurred:", err);
+      console.error("(DirCode) An error occurred:", err);
     }
     callback();
     return;

package/tiledeskChatbotPlugs/directives/DirCondition.js

@@ -10,33 +10,7 @@ class DirCondition {
       throw new Error('context object is mandatory.');
     }
     this.context = context;
-    // let context =  {
-    //   projectId: projectId,
-    //   token: token,
-    //   supportRequest: supportRequest,
-    //   requestId: supportRequest.request_id,
-    //   TILEDESK_APIURL: API_URL,
-    //   TILEBOT_ENDPOINT:TILEBOT_ENDPOINT,
-    //   departmentId: depId,
-    //   tdcache: tdcache,
-    //   log: false
-    // }
-    // this.tdclient = new TiledeskClient({
-    //   projectId: context.projectId,
-    //   token: context.token,
-    //   APIURL: context.TILEDESK_APIURL,
-    //   APIKEY: "___",
-    //   log: context.log
-    // });
     this.intentDir = new DirIntent(context);
-    //   {
-    //     API_ENDPOINT: context.TILEDESK_APIURL,
-    //     TILEBOT_ENDPOINT: context.TILEBOT_ENDPOINT,
-    //     supportRequest: context.supportRequest,
-    //     token: context.token,
-    //     log: context.log
-    //   }
-    // );
     this.log = context.log;
   }
 

package/tiledeskChatbotPlugs/directives/DirConnectBlock.js

@@ -0,0 +1,182 @@
+let axios = require('axios');
+let https = require("https");
+const { v4: uuidv4 } = require('uuid');
+const ms = require('minimist-string');
+
+class DirConnectBlock {
+  constructor(context) {
+    if (!context) {
+      throw new Error('context object is mandatory.');
+    }
+    this.context = context;
+    this.API_ENDPOINT = context.API_ENDPOINT,
+    this.TILEBOT_ENDPOINT = context.TILEBOT_ENDPOINT;
+    this.supportRequest = context.supportRequest;
+    this.token = context.token;
+    this.log = context.log;
+  }
+
+  execute(directive, callback) {
+    let action;
+    if (directive.action) {
+      action = directive.action;
+    }
+    else {
+      console.error("Incorrect DirConnectBlock directive:", directive);
+      callback();
+      return;
+    }
+    this.go(action, () => {
+      callback();
+    });
+  }
+
+  go(action, callback) {
+    const intentName = action.intentName;
+    const projectId = this.supportRequest.id_project;
+    const requestId = this.supportRequest.request_id;
+    const botId = this.supportRequest.bot_id;
+    let intent_command;
+    if (intentName) {
+      intent_command = "/" + intentName;
+    }
+    else {
+      callback();
+      return;
+    }
+
+    let intent_command_request = {
+      "payload": {
+        "_id": uuidv4(),
+        "senderFullname": "_tdinternal",
+        "type": "text",
+        "sender": "_tdinternal",
+        "recipient": requestId,
+        "text": intent_command,
+        "id_project": projectId,
+        "request": {
+          "request_id": requestId,
+          "id_project": projectId
+        }
+      },
+      "token": this.token
+    }
+    if (this.log) {console.log("move to intent message:", intent_command_request);}
+
+    this.sendMessageToBot(this.TILEBOT_ENDPOINT, intent_command_request, botId, () => {
+      callback();
+    });
+  }
+
+  static intentDirectiveFor(intent, json_params) {
+    let string_params = null;
+    if (json_params) {
+      try {
+        string_params = JSON.stringify(json_params);
+      }
+      catch (error) {
+        console.error("Error stringigying JSON PARAMS", json_params);
+      }
+    }
+    if (string_params != null) {
+      intent += string_params
+    }
+    let intentDirective = {
+      action: {
+        intentName: intent
+      }
+    }
+    return intentDirective;
+  }
+
+  static fullIntentDirectiveFor(intent, json_params) {
+    let string_params = JSON.stringify(params);
+    let intentDirective = {
+      action: {
+        intentName: intent
+      }
+    }
+    return intentDirective;
+  }
+
+  /**
+   * A stub to send message to the "ext/botId" endpoint, hosted by tilebot on:
+   * /${TILEBOT_ROUTE}/ext/${botId}
+   *
+   * @param {Object} message. The message to send
+   * @param {string} botId. Tiledesk botId
+   * @param {string} token. User token
+   */
+  sendMessageToBot(TILEBOT_ENDPOINT, message, botId, callback) {
+    const url = `${TILEBOT_ENDPOINT}/ext/${botId}`;
+    // console.log("sendMessageToBot URL", url);
+    const HTTPREQUEST = {
+      url: url,
+      headers: {
+        'Content-Type' : 'application/json'
+      },
+      json: message,
+      method: 'POST'
+    };
+    this.myrequest(
+      HTTPREQUEST,
+      function(err, resbody) {
+        if (err) {
+          if (callback) {
+            callback(err);
+          }
+        }
+        else {
+          if (callback) {
+            callback(null, resbody);
+          }
+        }
+      }, false
+    );
+  }
+
+  myrequest(options, callback, log) {
+    if (this.log) {
+      console.log("API URL:", options.url);
+      console.log("** Options:", JSON.stringify(options));
+    }
+    let axios_options = {
+      url: options.url,
+      method: options.method,
+      data: options.json,
+      params: options.params,
+      headers: options.headers
+    }
+    if (options.url.startsWith("https:")) {
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+      axios_options.httpsAgent = httpsAgent;
+    }
+    axios(axios_options)
+    .then((res) => {
+      if (this.log) {
+        console.log("Response for url:", options.url);
+        console.log("Response headers:\n", JSON.stringify(res.headers));
+      }
+      if (res && res.status == 200 && res.data) {
+        if (callback) {
+          callback(null, res.data);
+        }
+      }
+      else {
+        if (callback) {
+          callback(TiledeskClient.getErr({message: "Response status not 200"}, options, res), null, null);
+        }
+      }
+    })
+    .catch( (error) => {
+      console.error("(DirConnectBlock) Axios error: ", JSON.stringify(error));
+      if (callback) {
+        callback(error, null, null);
+      }
+    });
+  }
+}
+
+module.exports = { DirIntent };