@tiledesk/tiledesk-tybot-connector 0.2.28 → 0.2.30

package/CHANGELOG.md

@@ -5,6 +5,13 @@
 available on:
  ▶️ https://www.npmjs.com/package/@tiledesk/tiledesk-tybot-connector
 
+### v0.2.30
+- Updated WhatsappByAttribute action
+- Fixed bug: WhatsappByAttribute action pointed to whatsapp pre
+
+### v0.2.29
+- Added Make action 
+
 ### v0.2.28
 - DirSetAttribute, added support for attribute-filling in constants
 - DirSetAttribute, added function JSONparse

package/index.js

@@ -37,7 +37,6 @@ router.post('/ext/:botid', async (req, res) => {
     console.log("Removed req.body.payload.request.snapshot field");
   }
   if (log) {console.log("REQUEST BODY:", JSON.stringify(req.body));}
-  res.status(200).send({"success":true});
   
   const botId = req.params.botid;
   if (log) {console.log(" :", botId);}
@@ -53,6 +52,14 @@ router.post('/ext/:botid', async (req, res) => {
   if (message.request.id_project === null || message.request.id_project === undefined) {
     message.request.id_project = projectId;
   }
+
+  // let request_check = checkRequest(message.request.request_id, message.id_project);
+  // if (request_check === true) {
+  //   res.status(200).send({ "successs": true });
+  // } else {
+  //   return res.status(400).send({ "success": false, "message": "Invalid request_id"})
+  // }
+  res.status(200).send({"success":true});
   
   const request_botId_key = "tilebot:botId_requests:" + requestId;
   await tdcache.set(
@@ -541,4 +548,23 @@ async function connectRedis() {
   return;
 }
 
+async function checkRequest(request_id, id_project) {
+  // TO DO CHECK
+
+  // if (request_id startsWith "support-request-{$project_id}")
+  //    if (project_id is equal to the id_project)
+  //        return true;
+  //    else 
+  //        return (false, motivation)
+  // else if (request_id startsWith "automation-request-{$project_id}")
+  //    if (project_id is equal to the id_project)
+  //        return true;
+  //    else 
+  //        return (false, motivation)
+  // else
+  //    return (false, motivation);
+  
+  // WARNING! Move this function in models/TiledeskChatbotUtil.js
+}
+
 module.exports = { router: router, startApp: startApp};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiledesk/tiledesk-tybot-connector",
-  "version": "0.2.28",
+  "version": "0.2.30",
   "description": "Tiledesk Tybot connector",
   "main": "index.js",
   "scripts": {

package/tiledeskChatbotPlugs/DirectivesChatbotPlug.js

@@ -40,6 +40,7 @@ const { DirRandomReply } = require('./directives/DirRandomReply');
 const { DirGptTask } = require('./directives/DirGptTask');
 const { DirForm } = require('./directives/DirForm');
 const { DirCaptureUserReply } = require('./directives/DirCaptureUserReply');
+const { DirMake } = require('./directives/DirMake');
 
 class DirectivesChatbotPlug {
 
@@ -609,6 +610,12 @@ class DirectivesChatbotPlug {
         this.process(next_dir);
       })
     }
+    else if (directive_name === Directives.MAKE) {
+      new DirMake(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      })
+    }
     else {
       //console.log("Unhandled Post-message Directive:", directive_name);
       let next_dir = await this.nextDirective(this.directives);

package/tiledeskChatbotPlugs/directives/DirMake.js

@@ -0,0 +1,257 @@
+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 DirMake {
+
+  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.log = context.log;
+    this.intentDir = new DirIntent(context);
+  }
+
+  execute(directive, callback) {
+    if (this.log) { console.log("DirMake directive: ", directive); }
+    let action;
+    if (directive.action) {
+      action = directive.action;
+    }
+    else {
+      console.error("DirMake Incorrect directive: ", JSON.stringify(directive));
+      callback();
+      return;
+    }
+    this.go(action, () => {
+      callback();
+    })
+  }
+
+  async go(action, callback) {
+    if (this.log) { console.log("DirMake action:", JSON.stringify(action)); }
+    if (!this.tdcache) {
+      console.error("Error: DirMake tdcache is mandatory");
+      callback();
+      return;
+    }
+    //console.log('DirMake work!');
+    let requestVariables = null;
+    requestVariables =
+      await TiledeskChatbot.allParametersStatic(
+        this.tdcache, this.requestId
+      )
+
+    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("DirMake request parameter:", key, "value:", value, "type:", typeof value) }
+      }
+    }
+
+    let webhook_url = action.url;
+    let bodyParameters = action.bodyParameters;
+    if (this.log) {
+      console.log("DirMake webhook_url: ", webhook_url);
+      console.log("DirMake bodyParameters: ", bodyParameters);
+    }
+    if (!bodyParameters || bodyParameters === '') {
+      console.error("DirMake ERROR - bodyParameters is undefined or null or empty string");
+      callback();
+      return;
+    }
+    if (!webhook_url || webhook_url === '') {
+      console.error("DirMake ERROR - webhook_url is undefined or null or empty string");
+      callback();
+      return;
+    }
+    let url;
+    try {
+    console.log('CIAOkkkk',bodyParameters)
+    let make_base_url = process.env.MAKE_ENDPOINT;
+    if (make_base_url) {
+      url = make_base_url + "/make/";
+    } else {
+      url = action.url;
+    }
+    console.log('Make url: ', url);
+    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;
+      }
+    
+      console.log('CIAO',bodyParameters)
+    
+
+
+    
+    // Condition branches
+    let trueIntent = action.trueIntent;
+    let falseIntent = action.falseIntent;
+    console.log('trueIntent',trueIntent)
+ 
+    if (this.log) { console.log("DirMake MakeEndpoint URL: ", make_base_url); }
+    const MAKE_HTTPREQUEST = {
+      url: url,
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      json: bodyParameters,
+      method: "POST"
+    }
+  
+    if (this.log) { console.log("myrequest/DirMake MAKE_HTTPREQUEST", MAKE_HTTPREQUEST); }
+    this.#myrequest(
+      MAKE_HTTPREQUEST, async (err, resbody) => {
+        if (err) {
+          if (callback) {
+            console.error("myrequest/(httprequest) DirMake make err:", err);
+            let status = 404;   
+            let error = 'Not found';
+            await this.#assignAttributes(action, status, error);
+            this.#executeCondition(false, trueIntent, null, falseIntent, null, () => {
+              callback(false); // continue the flow
+            });
+            callback();
+          }
+        } else if (callback) {
+          if (this.log) { console.log("myrequest/DirMake Make resbody: ", resbody); }
+          let status = 200;   
+          let error = null;
+          await this.#assignAttributes(action, status, error); 
+          await this.#executeCondition(true, trueIntent, null, falseIntent, null, () => {
+            callback(); // stop the flow
+          });
+          console.log('myrequest/status: ',status)
+          callback();
+        }
+      }
+    );
+  } catch(e) {
+    console.error('error: ', e)
+  }
+  }
+
+  async #assignAttributes(action, status, error) {
+    if (this.log) {
+      console.log("DirMake assignAttributes action:", action)
+      console.log("DirMake assignAttributes status:", status)
+      console.log("DirMake assignAttributes error:", error)
+    }
+    if (this.context.tdcache) {
+      if (action.assignStatusTo) {
+        await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.assignStatusTo, status);
+      }
+      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("DirMake 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 status:", res.status);
+          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(new Error("Response status is not 200"), null);
+          }
+        }
+      })
+      .catch((error) => {
+        // console.error("An error occurred:", JSON.stringify(error.data));
+        if (callback) {
+          callback(error, null);
+        }
+      });
+  }
+  async #executeCondition(result, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes, callback) {
+    let trueIntentDirective = null;
+   
+    if (trueIntent) {
+      //console.log('executeCondition/trueIntent',trueIntent)
+      trueIntentDirective = DirIntent.intentDirectiveFor(trueIntent, trueIntentAttributes);
+      //console.log('executeCondition/trueIntentDirective',trueIntentDirective)
+      //console.log('executeCondition/trueIntentAttributes',trueIntentAttributes)
+    }
+    let falseIntentDirective = null;
+    if (falseIntent) {
+      falseIntentDirective = DirIntent.intentDirectiveFor(falseIntent, falseIntentAttributes);
+    }
+    if (this.log) {console.log('DirMake executeCondition/result',result)}
+    if (result === true) {
+      if (trueIntentDirective) {
+        this.intentDir.execute(trueIntentDirective, () => {
+          callback();
+        });
+      }
+      else {
+        if (this.log) {console.log("No trueIntentDirective specified");}
+        callback();
+      }
+    }
+    else {
+      if (falseIntentDirective) {
+        this.intentDir.execute(falseIntentDirective, () => {
+          callback();
+        });
+      }
+      else {
+        if (this.log) {console.log("No falseIntentDirective specified");}
+        callback();
+      }
+    }
+  }
+}
+
+module.exports = { DirMake }

package/tiledeskChatbotPlugs/directives/DirSetAttributeV2.js

@@ -134,10 +134,23 @@ class DirSetAttributeV2 {
         attributes.TiledeskString = TiledeskString;
         const result = new TiledeskExpression().evaluateJavascriptExpression(expression, attributes);
         console.log("filling in setattribute, result:", result);
-        await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.destination, result);
+        let destination = await this.fillDestination(action.destination);
+        await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, destination, result);
         callback();
     }
 
+    async fillDestination(destination) {
+        if (this.tdcache) {
+            // console.log("tdcache in setattribute...", this.tdcache);
+            const requestAttributes = 
+                await TiledeskChatbot.allParametersStatic(this.tdcache, this.context.requestId);
+            // console.log("requestAttributes in setattribute...", requestAttributes);
+            const filler = new Filler();
+            destination = filler.fill(destination, requestAttributes);
+            console.log("setattribute, final destination:", destination);
+        }
+        return destination
+    }
     async fillValues(operands) {
         // operation: {
         //     operators: ["addAsNumber", "subtractAsNumber", "divideAsNumber", "multiplyAsNumber"],

package/tiledeskChatbotPlugs/directives/DirWhatsappByAttribute.js

@@ -30,65 +30,126 @@ class DirWhatsappByAttribute {
   }
 
   async go(action, callback) {
+
     if (this.log) {
       console.log("whatsapp by attributes action: ", JSON.stringify(action))
     }
 
-    if (process.env.API_URL) {
-      whatsapp_api_url = "https://tiledesk-whatsapp-connector.giovannitroisi3.repl.co/api";
-      // whatsapp_api_url = process.env.API_URL + "/modules/whatsapp";
-      console.log("(Tilebot) DirWhatsappByAttribute whatsapp_api_url: ", whatsapp_api_url);
+    /////////// 
+
+    const whatsapp_api_url_pre = process.env.WHATSAPP_ENDPOINT;
+    const server_base_url = process.env.API_URL || process.env.API_ENDPOINT;
+
+    if (whatsapp_api_url_pre) {
+      whatsapp_api_url = whatsapp_api_url_pre;
     } else {
-      console.error("(Tilebot) ERROR Missing whatsapp_api_url. Unable to use action WhatsApp By Attributes");
+      whatsapp_api_url = server_base_url + "/modules/whatsapp/api"
+    }
+    console.log("DirWhatsappByAttribute whatsapp_api_url: ", whatsapp_api_url);
+
+    if (!action.attributeName) {
+      console.error("DirWhatsappByAttribute attributeName is mandatory")
       callback();
       return;
     }
+    if (this.log) { console.log("DirWhatsappByAttribute attributeName: ", action.attributeName )};
 
-    if (action.attributeName) {
-      if (this.log) { console.log("whatsapp attributeName:", action.attributeName); }
-      let attribute_value = null;
-      if (this.context.tdcache) {
+    const attribute_value = await TiledeskChatbot.getParameterStatic(this.context.tdcache, this.context.requestId, action.attributeName)
+    if (this.log) { console.log("attribute_value:", JSON.stringify(attribute_value)); }
 
-        const attribute_value = await TiledeskChatbot.getParameterStatic(this.context.tdcache, this.context.requestId, action.attributeName)
-        if (this.log) { console.log("attribute_value:", JSON.stringify(attribute_value)); }
+    if (attribute_value == null) {
+      console.error("DirWhatsappByAttribute attribute_value is undefined");
+      callback();
+      return;
+    }
 
-        if (attribute_value == null) {
-          console.error("(Tilebot) attribute_value is undefined");
-          callback();
-          return;
-        }
+    attribute_value.transaction_id = this.context.requestId;
 
-        const URL = whatsapp_api_url + '/tiledesk/broadcast';
-        const HTTPREQUEST = {
-          url: URL,
-          headers: {
-            'Content-Type': 'application/json'
-          },
-          json: attribute_value,
-          method: 'POST'
-        };
-        let promise = new Promise((resolve, reject) => {
-          DirWhatsappByAttribute.myrequest(
-            HTTPREQUEST,
-            function (err, resbody) {
-              if (err) {
-                if (callback) {
-                  callback(err);
-                }
-                reject(err);
-              }
-              else {
-                if (callback) {
-                  callback(null, resbody);
-                }
-                console.log("(tybot) broadcast sent: ", resbody);
-                resolve(resbody);
-              }
-            }, true);
-        })
-        return promise;
-      }
+    const HTTPREQUEST = {
+      url: whatsapp_api_url + "/tiledesk/broadcast",
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      json: attribute_value,
+      method: 'POST'
     }
+
+    return new Promise((resolve, reject) => {
+      DirWhatsappByAttribute.myrequest(
+        HTTPREQUEST,
+        function (err, resbody) {
+          if (err) {
+            if (callback) {
+              callback(err);
+            }
+            reject(err);
+          }
+          else {
+            if (callback) {
+              callback(null, resbody);
+            }
+            console.log("(tybot) broadcast sent: ", resbody);
+            resolve(resbody);
+          }
+        }, true);
+    })
+
+
+    // if (process.env.API_URL) {
+    //   whatsapp_api_url = "https://tiledesk-whatsapp-connector.giovannitroisi3.repl.co/api";
+    //   // whatsapp_api_url = process.env.API_URL + "/modules/whatsapp";
+    //   console.log("(Tilebot) DirWhatsappByAttribute whatsapp_api_url: ", whatsapp_api_url);
+    // } else {
+    //   console.error("(Tilebot) ERROR Missing whatsapp_api_url. Unable to use action WhatsApp By Attributes");
+    //   callback();
+    //   return;
+    // }
+    // if (action.attributeName) {
+    //   if (this.log) { console.log("whatsapp attributeName:", action.attributeName); }
+    //   let attribute_value = null;
+    //   if (this.context.tdcache) {
+
+    //     const attribute_value = await TiledeskChatbot.getParameterStatic(this.context.tdcache, this.context.requestId, action.attributeName)
+    //     if (this.log) { console.log("attribute_value:", JSON.stringify(attribute_value)); }
+
+    //     if (attribute_value == null) {
+    //       console.error("(Tilebot) attribute_value is undefined");
+    //       callback();
+    //       return;
+    //     }
+
+    //     const URL = whatsapp_api_url + '/tiledesk/broadcast';
+    //     const HTTPREQUEST = {
+    //       url: URL,
+    //       headers: {
+    //         'Content-Type': 'application/json',
+            
+    //       },
+    //       json: attribute_value,
+    //       method: 'POST'
+    //     };
+    //     let promise = new Promise((resolve, reject) => {
+    //       DirWhatsappByAttribute.myrequest(
+    //         HTTPREQUEST,
+    //         function (err, resbody) {
+    //           if (err) {
+    //             if (callback) {
+    //               callback(err);
+    //             }
+    //             reject(err);
+    //           }
+    //           else {
+    //             if (callback) {
+    //               callback(null, resbody);
+    //             }
+    //             console.log("(tybot) broadcast sent: ", resbody);
+    //             resolve(resbody);
+    //           }
+    //         }, true);
+    //     })
+    //     return promise;
+    //   }
+    // }
   }
 
   // HTTP REQUEST

package/tiledeskChatbotPlugs/directives/Directives.js

@@ -32,6 +32,7 @@ class Directives {
   static FORM = "form";
   static CAPTURE_USER_REPLY = "capture_user_reply";
   static QAPLA = 'qapla';
+  static MAKE = 'make';
 
   // static WHEN_ONLINE_MOVE_TO_AGENT = "whenonlinemovetoagent"; // DEPRECATED?
   // static WHEN_OFFLINE_HOURS = "whenofflinehours"; // DEPRECATED // adds a message on top of the original message when offline hours opts: --replace