@tiledesk/tiledesk-whatsapp-connector 1.0.31 → 1.0.33

package/.env

@@ -1,2 +1,2 @@
 # CUSTOM ENV
-NPM_PUBLISH_TOKEN=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
+NPM_PUBLISH_TOKEN=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

package/index.js

@@ -31,6 +31,7 @@ const { TemplateManager } = require("./tiledesk/TemplateManager");
 const { WhatsappLogger } = require("./tiledesk/WhatsappLogger");
 const Utils = require("./tiledesk/Utils");
 const whatsappService = require("./tiledesk/WhatsappService");
+const { ensureGlobalSigninSubscription, ensureProjectTestSubscription, getActiveTest, isProjectId } = require("./tiledesk/BotTestSubscriptions");
 
 // mongo
 const { KVBaseMongo } = require("./tiledesk/KVBaseMongo");
@@ -560,22 +561,22 @@ router.post("/disconnect", async (req, res) => {
 // ***************************************
 // ****** MESSAGING SECTION - START ******
 // ***************************************
-router.post("/tiledesk", async (req, res) => {
+function phoneNumberIdFromTiledeskRecipient(recipient, attributes) {
+  if (attributes && attributes.whatsapp_phone_number_id) {
+    return attributes.whatsapp_phone_number_id;
+  }
+  if (!recipient || recipient.indexOf("wab-") === -1) {
+    return null;
+  }
+  return recipient.substring(recipient.lastIndexOf("wab-") + 4, recipient.lastIndexOf("-"));
+}
+
+async function handleTiledeskOutbound(req, res, settings) {
   winston.verbose("(wab) Message received from Tiledesk");
 
   let tiledeskChannelMessage = req.body.payload;
   winston.debug("(wab) tiledeskChannelMessage: ", tiledeskChannelMessage);
 
-  let project_id = req.body.payload.id_project;
-  let recipient = req.body.payload.recipient;
-  let waba_id = recipient.split('-')[5];
-
-  let settings = await utils.getSettingsByProjectId(project_id);
-
-  if (!settings) {
-    settings = await utils.getSettings(project_id, waba_id);
-  }
-
   let wab_token = settings.wab_token;
 
   var text = req.body.payload.text;
@@ -758,6 +759,55 @@ router.post("/tiledesk", async (req, res) => {
     winston.debug("(wab) no command, no text --> skip");
     return res.status(400).send({ success: false, error: "No command or text specified. Skip message." });
   }
+}
+
+router.post("/tiledesk", async (req, res) => {
+  const payload = req.body && req.body.payload;
+  if (!payload || !payload.recipient) {
+    return res.status(400).send({ success: false, error: "Invalid Tiledesk payload" });
+  }
+
+  const project_id = payload.id_project;
+  const waba_id = payload.recipient.split("-")[5];
+  let settings = await utils.getSettingsByProjectId(project_id);
+  if (!settings) {
+    settings = await utils.getSettings(project_id, waba_id);
+  }
+  if (!settings) {
+    winston.warn("(wab) settings not found for project " + project_id);
+    return res.sendStatus(200);
+  }
+
+  const phoneNumberId = phoneNumberIdFromTiledeskRecipient(payload.recipient, payload.attributes);
+  if (phoneNumberId) {
+    const official = await db.get("whatsapp-phone-" + phoneNumberId);
+    if (official && official.project_id && String(official.project_id) !== String(project_id)) {
+      winston.verbose("(wab) Skip Try on WhatsApp reply on the project subscription");
+      return res.sendStatus(200);
+    }
+  }
+
+  return handleTiledeskOutbound(req, res, settings);
+});
+
+router.post("/tiledesk/test", async (req, res) => {
+  const payload = req.body && req.body.payload;
+  if (!payload || !payload.recipient) {
+    return res.sendStatus(200);
+  }
+
+  const phoneNumberId = phoneNumberIdFromTiledeskRecipient(payload.recipient, payload.attributes);
+  if (!phoneNumberId) {
+    return res.sendStatus(200);
+  }
+
+  const settings = await db.get("whatsapp-phone-" + phoneNumberId);
+  if (!settings || !settings.wab_token) {
+    winston.verbose("(wab) No official WhatsApp settings for test reply " + phoneNumberId);
+    return res.sendStatus(200);
+  }
+
+  return handleTiledeskOutbound(req, res, settings);
 });
 
 // Endpoint for Whatsapp Business connected via OAuth
@@ -817,6 +867,7 @@ router.post('/webhook', async (req, res) => {
         db: db,
         tdChannel: tdChannel,
         tlr: tlr,
+        baseUrl: BASE_URL,
       });
       bottester.startBotConversation(req.body, code).then((result) => {
         winston.verbose("(wab) test conversation started");
@@ -880,7 +931,7 @@ router.post('/webhook', async (req, res) => {
         winston.verbose("(wab) tiledeskJsonMessage: ", tiledeskJsonMessage);
 
         try {
-          const response = await tdChannel.send(tiledeskJsonMessage, message_info, settings.department_id);
+          const response = await deliverInboundMessage(tdChannel, tiledeskJsonMessage, message_info, settings);
           winston.verbose("(wab) Message sent to Tiledesk!");
           winston.debug("(wab) response: ", response);
         } catch (err) {
@@ -998,6 +1049,7 @@ router.post("/webhook/:project_id", async (req, res) => {
           db: db,
           tdChannel: tdChannel,
           tlr: tlr,
+          baseUrl: BASE_URL,
         });
         bottester.startBotConversation(req.body, code).then((result) => {
           winston.verbose("(wab) test conversation started");
@@ -1114,7 +1166,7 @@ router.post("/webhook/:project_id", async (req, res) => {
 
         if (tiledeskJsonMessage) {
           winston.verbose("(wab) tiledeskJsonMessage: ", tiledeskJsonMessage);
-          const response = await tdChannel.send(tiledeskJsonMessage, message_info, settings.department_id);
+          const response = await deliverInboundMessage(tdChannel, tiledeskJsonMessage, message_info, settings);
           winston.verbose("(wab) Message sent to Tiledesk!");
           winston.debug("(wab) response: ", response);
         } else {
@@ -1268,6 +1320,22 @@ router.post("/newtest", async (req, res) => {
   let project_id = req.body.project_id;
   let bot_id = req.body.bot_id;
 
+  if (!project_id || !bot_id) {
+    return res.status(400).send({ success: false, message: "project_id and bot_id are required" });
+  }
+
+  if (!redis_client) {
+    return res.status(500).send({ message: "Test it out on Whatsapp not available. Redis not ready." });
+  }
+
+  try {
+    await ensureGlobalSigninSubscription(db, BASE_URL);
+    await ensureProjectTestSubscription(db, project_id, BASE_URL, redis_client);
+  } catch (err) {
+    winston.error("(wab) unable to prepare Try on WhatsApp: " + err);
+    return res.status(500).send({ success: false, message: "Try on WhatsApp is not available" });
+  }
+
   let info = {
     project_id: project_id,
     bot_id: bot_id,
@@ -1276,10 +1344,6 @@ router.post("/newtest", async (req, res) => {
   let short_uid = uuidv4().substring(0, 8);
   let key = "bottest:" + short_uid;
 
-  if (!redis_client) {
-    return res.status(500).send({ message: "Test it out on Whatsapp not available. Redis not ready." });
-  }
-
   await redis_client.set(key, JSON.stringify(info), "EX", 604800);
   redis_client.get(key, (err, value) => {
     if (err) {
@@ -1811,6 +1875,22 @@ async function getDepartments(project_id, token) {
   }
 }
 
+async function deliverInboundMessage(tdChannel, tiledeskJsonMessage, messageInfo, settings) {
+  const whatsapp = messageInfo && messageInfo.whatsapp;
+  const session = await getActiveTest(redis_client, whatsapp && whatsapp.phone_number_id, whatsapp && whatsapp.from);
+  if (session && session.request_id && isProjectId(session.project_id)) {
+    winston.verbose("(wab) Continue Try on WhatsApp in project " + session.project_id);
+    const signinSubscription = await ensureGlobalSigninSubscription(db, BASE_URL);
+    return tdChannel.sendToExistingRequest(tiledeskJsonMessage, messageInfo, {
+      project_id: session.project_id,
+      request_id: session.request_id,
+      subscriptionId: String(signinSubscription._id),
+      secret: signinSubscription.secret
+    });
+  }
+  return tdChannel.send(tiledeskJsonMessage, messageInfo, settings.department_id);
+}
+
 /**
  * Helper function to get or create user token with Redis caching
  * @param {Object} tdChannel - TiledeskChannel instance

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiledesk/tiledesk-whatsapp-connector",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "Tiledesk Whatsapp connector",
   "main": "index.js",
   "scripts": {

package/tiledesk/BotTestSubscriptions.js

@@ -0,0 +1,164 @@
+const { v4: uuidv4 } = require("uuid");
+const winston = require("../winston");
+
+const BOTTEST_SIGNIN_EVENT = "whatsapp.bottest.signin";
+const WHATSAPP_MESSAGE_EVENT = "message.create.request.channel.whatsapp";
+const BOTTEST_CREATED_BY = "whatsapp-bottest";
+
+function isProjectId(value) {
+  return typeof value === "string" && /^[a-fA-F0-9]{24}$/.test(value);
+}
+
+function subscriptions(kv) {
+  if (!kv || !kv.db || typeof kv.db.collection !== "function") {
+    throw new Error("WhatsApp storage is not connected");
+  }
+  return kv.db.collection("subscriptions");
+}
+
+async function ensureGlobalSigninSubscription(kv, baseUrl) {
+  if (!baseUrl) {
+    throw new Error("BASE_URL is required to prepare Try on WhatsApp");
+  }
+  const collection = subscriptions(kv);
+  const query = { event: BOTTEST_SIGNIN_EVENT, id_project: "*", global: true };
+  let existing = await collection.findOne(query);
+  if (existing) {
+    return existing;
+  }
+
+  const now = new Date();
+  const doc = {
+    event: BOTTEST_SIGNIN_EVENT,
+    target: baseUrl + "/tiledesk/test",
+    secret: uuidv4(),
+    id_project: "*",
+    global: true,
+    createdBy: BOTTEST_CREATED_BY,
+    createdAt: now,
+    updatedAt: now
+  };
+
+  try {
+    const result = await collection.insertOne(doc);
+    doc._id = result.insertedId;
+    return doc;
+  } catch (err) {
+    if (err && err.code === 11000) {
+      existing = await collection.findOne(query);
+      if (existing) {
+        return existing;
+      }
+    }
+    throw err;
+  }
+}
+
+async function ensureProjectTestSubscription(kv, projectId, baseUrl, redisClient) {
+  if (!isProjectId(projectId)) {
+    throw new Error("Try on WhatsApp project_id is invalid");
+  }
+  if (!baseUrl) {
+    throw new Error("BASE_URL is required to prepare Try on WhatsApp");
+  }
+
+  const collection = subscriptions(kv);
+  const target = baseUrl + "/tiledesk/test";
+  const query = { id_project: projectId, event: WHATSAPP_MESSAGE_EVENT, target: target };
+  let existing = await collection.findOne(query);
+  if (!existing) {
+    const now = new Date();
+    const doc = {
+      event: WHATSAPP_MESSAGE_EVENT,
+      target: target,
+      secret: uuidv4(),
+      id_project: projectId,
+      global: false,
+      createdBy: BOTTEST_CREATED_BY,
+      createdAt: now,
+      updatedAt: now
+    };
+    try {
+      const result = await collection.insertOne(doc);
+      doc._id = result.insertedId;
+      existing = doc;
+    } catch (err) {
+      if (err && err.code === 11000) {
+        existing = await collection.findOne(query);
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  await invalidateSubscriptionCache(redisClient, projectId, WHATSAPP_MESSAGE_EVENT);
+  return existing;
+}
+
+function activeTestKey(phoneNumberId, from) {
+  return "bottest:active:" + phoneNumberId + ":" + from;
+}
+
+function saveActiveTest(redisClient, phoneNumberId, from, session) {
+  if (!redisClient || !phoneNumberId || !from || !session) {
+    return Promise.resolve();
+  }
+  const key = activeTestKey(phoneNumberId, from);
+  return new Promise((resolve, reject) => {
+    redisClient.set(key, JSON.stringify(session), "EX", 604800, function (err) {
+      if (err) {
+        return reject(err);
+      }
+      resolve();
+    });
+  });
+}
+
+function getActiveTest(redisClient, phoneNumberId, from) {
+  if (!redisClient || !phoneNumberId || !from) {
+    return Promise.resolve(null);
+  }
+  const key = activeTestKey(phoneNumberId, from);
+  return new Promise((resolve) => {
+    redisClient.get(key, function (err, value) {
+      if (err || !value) {
+        return resolve(null);
+      }
+      try {
+        resolve(JSON.parse(value));
+      } catch (parseErr) {
+        resolve(null);
+      }
+    });
+  });
+}
+
+function invalidateSubscriptionCache(redisClient, projectId, event) {
+  if (!redisClient || !projectId || !event) {
+    return Promise.resolve();
+  }
+  const key = "cacheman:cachegoose-cache:" + projectId + ":subscriptions:event:" + event;
+  return new Promise((resolve) => {
+    try {
+      redisClient.del(key, function (err) {
+        if (err) {
+          winston.warn("(wab) unable to refresh subscription cache for " + projectId);
+        }
+        resolve();
+      });
+    } catch (err) {
+      winston.warn("(wab) unable to refresh subscription cache for " + projectId);
+      resolve();
+    }
+  });
+}
+
+module.exports = {
+  BOTTEST_SIGNIN_EVENT,
+  WHATSAPP_MESSAGE_EVENT,
+  isProjectId,
+  ensureGlobalSigninSubscription,
+  ensureProjectTestSubscription,
+  saveActiveTest,
+  getActiveTest
+};

package/tiledesk/TiledeskBotTester.js

@@ -7,6 +7,7 @@ const { TiledeskClient } = require('@tiledesk/tiledesk-client');
 const { TiledeskWhatsappTranslator } = require('./TiledeskWhatsappTranslator');
 const { TiledeskChannel } = require('./TiledeskChannel');
 const Utils = require("./Utils");
+const { ensureGlobalSigninSubscription, ensureProjectTestSubscription, isProjectId, saveActiveTest } = require("./BotTestSubscriptions");
 
 class TiledeskBotTester {
 
@@ -46,6 +47,7 @@ class TiledeskBotTester {
     this.db = config.db;
     this.tdChannel = config.tdChannel;
     this.tlr = config.tlr;
+    this.baseUrl = config.baseUrl;
 
     this.utils = new Utils({ db: this.db })
 
@@ -79,7 +81,7 @@ class TiledeskBotTester {
               test_info = JSON.parse(value)
             } catch(err) {
               winston.error("(wab) Error parsing value: " + value);
-              reject(err);
+              return reject(err);
             }
             let message_info = {
               channel: "whatsapp",
@@ -103,14 +105,36 @@ class TiledeskBotTester {
             
             whatsappChannelMessage.text.body = "/start";
             let tiledeskJsonMessage = await this.tlr.toTiledesk(whatsappChannelMessage, whatsappContact.profile.name);
-          
-            if (test_info) {
-              const response = await this.tdChannel.sendAndAddBot(tiledeskJsonMessage, message_info, test_info.bot_id)
-              return resolve(response)
-            } else {
+
+            if (!test_info || !test_info.bot_id || !isProjectId(test_info.project_id)) {
               winston.verbose("(wab) No bot selected for test. Exit..")
               return reject("Test skipped")
             }
+
+            try {
+              const phoneNumberId = message_info.whatsapp.phone_number_id;
+              if (phoneNumberId && this.tdChannel && this.tdChannel.settings) {
+                await this.db.set("whatsapp-phone-" + phoneNumberId, this.tdChannel.settings);
+              }
+              const signinSubscription = await ensureGlobalSigninSubscription(this.db, this.baseUrl);
+              await ensureProjectTestSubscription(this.db, test_info.project_id, this.baseUrl, this.redis_client);
+              const response = await this.tdChannel.sendAndAddBot(tiledeskJsonMessage, message_info, test_info.bot_id, {
+                project_id: test_info.project_id,
+                subscriptionId: String(signinSubscription._id),
+                secret: signinSubscription.secret
+              });
+              if (response && response.request_id) {
+                await saveActiveTest(this.redis_client, phoneNumberId, message_info.whatsapp.from, {
+                  project_id: test_info.project_id,
+                  bot_id: test_info.bot_id,
+                  request_id: response.request_id
+                });
+              }
+              return resolve(response);
+            } catch (prepareErr) {
+              winston.error("(wab) [TiledeskBotTester] unable to open test conversation: " + prepareErr);
+              return reject(prepareErr);
+            }
  
           }
         }

package/tiledesk/TiledeskChannel.js

@@ -181,18 +181,23 @@ class TiledeskChannel {
    * @param {string} bot_id - The bot ID
    * @returns {Promise<Object>} - The response from the Tiledesk API
    */
-  async sendAndAddBot(tiledeskMessage, messageInfo, bot_id) {
-    
+  async sendAndAddBot(tiledeskMessage, messageInfo, bot_id, targetProject) {
+
+    const projectId = targetProject && targetProject.project_id ? targetProject.project_id : this.settings.project_id;
+    const subscriptionId = targetProject && targetProject.subscriptionId ? targetProject.subscriptionId : this.settings.subscriptionId;
+    const secret = targetProject && targetProject.secret ? targetProject.secret : this.settings.secret;
+
     let channel;
     let new_request_id;
     tiledeskMessage.participants = ["bot_" + bot_id];
     tiledeskMessage.attributes = {
-      sourcePage: "whatsapp://&td_draft=true"
+      sourcePage: "whatsapp://&td_draft=true",
+      whatsapp_bottest: true
     }
 
     if (messageInfo.channel == "whatsapp") {
       channel = messageInfo.whatsapp;
-      new_request_id = "support-group-" + this.settings.project_id + "-" + uuidv4().substring(0, 8) + "-wab-" + channel.phone_number_id + "-" + channel.from;
+      new_request_id = "support-group-" + projectId + "-" + uuidv4().substring(0, 8) + "-wab-" + channel.phone_number_id + "-" + channel.from;
     } else {
       winston.verbose("(wab) [TiledeskChannel] Channel not supported")
       return null;
@@ -203,10 +208,11 @@ class TiledeskChannel {
       first_name: channel.firstname,
       last_name: channel.lastname,
       sub: 'userexternal',
-      aud: 'https://tiledesk.com/subscriptions/' + this.settings.subscriptionId
+      aud: 'https://tiledesk.com/subscriptions/' + subscriptionId
     }
 
-    var customToken = jwt.sign(payload, this.settings.secret);
+    var customToken = jwt.sign(payload, secret);
+    const signinBody = targetProject && targetProject.project_id ? { id_project: projectId } : {};
 
     return await axios({
       url: this.API_URL + "/auth/signinWithCustomToken",
@@ -214,7 +220,7 @@ class TiledeskChannel {
         'Content-Type': 'application/json',
         'Authorization': 'JWT ' + customToken
       },
-      data: {},
+      data: signinBody,
       method: 'POST'
     }).then((response) => {
       
@@ -222,7 +228,7 @@ class TiledeskChannel {
       token = this.fixToken(token);
 
       return axios({
-        url: this.API_URL + `/${this.settings.project_id}/requests/${new_request_id}/messages`,
+        url: this.API_URL + `/${projectId}/requests/${new_request_id}/messages`,
         headers: {
           'Content-Type': 'application/json',
           'Authorization': token
@@ -230,7 +236,9 @@ class TiledeskChannel {
         data: tiledeskMessage,
         method: 'POST'
       }).then((response) => {
-        return response.data
+        const data = response.data || {};
+        data.request_id = new_request_id;
+        return data;
       }).catch((err) => {
         const errorMessage = utils._extractErrorMessage(err);
         winston.error("(wab) [TiledeskChannel] send message (open conversation) error: " + errorMessage);
@@ -241,6 +249,49 @@ class TiledeskChannel {
     })
   }
 
+  /**
+   * Append a message to a Try on WhatsApp request that already lives in the bot's project.
+   */
+  async sendToExistingRequest(tiledeskMessage, messageInfo, target) {
+    if (!target || !target.project_id || !target.request_id || !target.subscriptionId || !target.secret) {
+      throw new Error("Try on WhatsApp session is incomplete");
+    }
+
+    const channel = messageInfo.whatsapp || {};
+    const payload = {
+      _id: 'wab-' + channel.from,
+      first_name: channel.firstname,
+      last_name: channel.lastname,
+      sub: 'userexternal',
+      aud: 'https://tiledesk.com/subscriptions/' + target.subscriptionId
+    };
+    const customToken = jwt.sign(payload, target.secret);
+
+    const signinResponse = await axios({
+      url: this.API_URL + "/auth/signinWithCustomToken",
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': 'JWT ' + customToken
+      },
+      data: { id_project: target.project_id },
+      method: 'POST'
+    });
+
+    const token = this.fixToken(signinResponse.data.token);
+    delete tiledeskMessage.participants;
+
+    const sendResponse = await axios({
+      url: this.API_URL + `/${target.project_id}/requests/${target.request_id}/messages`,
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': token
+      },
+      data: tiledeskMessage,
+      method: 'POST'
+    });
+    return sendResponse.data;
+  }
+
   /**
    * Get the project detail from Tiledesk
    * @returns {Promise<Object>} - The response from the Tiledesk API