@tiledesk/tiledesk-server 2.19.16 → 2.20.0

package/CHANGELOG.md

@@ -5,6 +5,10 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
+# 2.20.0
+- Updated tybot-connector to 2.1.8
+- Improved flow attributes management
+
 # 2.19.16
 - Queued /kb/scrape/single via scheduleScrape instead of sync startScrape
 - Improved guest closure event handling in activity monitoring

package/jobs.js

@@ -84,7 +84,14 @@ async function main()
    //************* LOAD CHAT21 ************ //
    channelManager.listen(); // chat21Handler is loaded with stadard events like request.create and NOT request.create.queue because it is used internally by the worker when the request is closed by ChatUnhandledRequestScheduler
 
-    
+    // Same Redis client as app.js — required by routing-queue (flow attributes cache delete)
+    const { TdCache } = require('./utils/TdCache');
+    let tdCache = new TdCache({
+      host: process.env.CACHE_REDIS_HOST,
+      port: process.env.CACHE_REDIS_PORT,
+      password: process.env.CACHE_REDIS_PASSWORD
+    });
+    tdCache.connect();
 
 
     let jobsManager = new JobsManager(undefined, geoService, botEvent, subscriptionNotifierQueued, botSubscriptionNotifier, updateLeadQueued, updateRequestSnapshotQueued);
@@ -102,7 +109,10 @@ async function main()
 
 
     let routingQueueQueued = require('./pubmodules/routing-queue').listenerQueued;
-    winston.debug("routingQueueQueued"); 
+    winston.debug("routingQueueQueued");
+    if (tdCache) {
+      routingQueueQueued.setTdCache(tdCache);
+    }
     jobsManager.listenRoutingQueue(routingQueueQueued);
 
     let whatsappQueue = require('@tiledesk/tiledesk-whatsapp-jobworker');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.19.16",
+  "version": "2.20.0",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",
@@ -49,7 +49,7 @@
     "@tiledesk/tiledesk-rasa-connector": "^1.0.10",
     "@tiledesk/tiledesk-sms-connector": "^0.1.13",
     "@tiledesk/tiledesk-telegram-connector": "^0.1.14",
-    "@tiledesk/tiledesk-tybot-connector": "^2.1.5",
+    "@tiledesk/tiledesk-tybot-connector": "^2.1.8",
     "@tiledesk/tiledesk-voice-twilio-connector": "^0.3.2",
     "@tiledesk/tiledesk-vxml-connector": "^0.1.91",
     "@tiledesk/tiledesk-whatsapp-connector": "1.0.26",

package/pubmodules/pubModulesManager.js

@@ -689,6 +689,9 @@ class PubModulesManager {
         }
         if (this.routingQueueQueued) {
             try {
+                if (this.tdCache) {
+                    this.routingQueueQueued.setTdCache(this.tdCache);
+                }
                 // this.routingQueueQueued.listen();  
                 this.jobsManager.listenRoutingQueue(this.routingQueueQueued);
                 winston.info("PubModulesManager routingQueue queued started");

package/pubmodules/routing-queue/listenerQueued.js

@@ -6,6 +6,7 @@ var Request = require('../../models/request')
 var winston = require('../../config/winston');
 
 var ProjectUserUtil = require("../../utils/project_userUtil");
+const requestService = require('../../services/requestService');
 
 // var request = require('retry-request', {
 //     request: require('request')
@@ -28,23 +29,36 @@ var ProjectUserUtil = require("../../utils/project_userUtil");
 // TODO web socket is not supported with queue
 class Listener {
 
- 
+
   constructor() {
     this.enabled = true;
-    if (process.env.ROUTE_QUEUE_ENABLED=="false" || process.env.ROUTE_QUEUE_ENABLED==false) {
-        this.enabled = false;
+    this.tdCache = null;
+    if (process.env.ROUTE_QUEUE_ENABLED == "false" || process.env.ROUTE_QUEUE_ENABLED == false) {
+      this.enabled = false;
     }
-    winston.debug("Listener this.enabled: "+ this.enabled);
+    winston.debug("Listener this.enabled: " + this.enabled);
   }
 
- 
+  /**
+   * Reuse app's TdCache instance instead of opening a new Redis connection.
+   * Injected by PubModulesManager.
+   * @param {TdCache} tdCache - shared Redis cache from app.get('redis_client')
+   */
+  setTdCache(tdCache) {
+    if (tdCache && typeof tdCache.del === 'function') {
+      this.tdCache = tdCache;
+      winston.debug("Route queue Listener using shared TdCache for flow attributes");
+    }
+  }
+
+
   // db.getCollection('project_users').find({"number_assigned_requests" : {"$lt":0}}).count()
 
   // New version of updateProjectUser() method.
   // This will not increment or decrement the number_assigned_requests field but search the exact number of assigned conversation to the project user
   updateProjectUser(id_user, id_project, operation) {
     // winston.debug("Route queue updateProjectUser start operation: " + operation + "id_user " + id_user + " id_project " + id_project);
-    
+
     // escludi id_user che iniziano con bot_
     if (id_user.startsWith('bot_')) {
       return winston.warn("Chatbot is not a project_user. Skip update.")
@@ -64,27 +78,27 @@ class Listener {
           // winston.debug("Route queue number_assigned_requests +1 :" + updatedPU.id);
           // winston.debug("Route queue number_assigned_requests +1 :" + updatedPU.id);
           winston.debug("Route queue number_assigned_requests updated to " + requestsCount + "for project user " + updatedPU.id);
-  
+
           updatedPU.populate({ path: 'id_user', select: { 'firstname': 1, 'lastname': 1 } }, function (err, updatedProject_userPopulated) {
-  
+
             var pu = updatedProject_userPopulated.toJSON();
-  
+
             return Project.findById(id_project).exec(function (err, project) {
               pu.isBusy = ProjectUserUtil.isBusy(updatedProject_userPopulated, project.settings && project.settings.max_agent_assigned_chat);
               winston.debug("Route queue pu.isBusy: " + pu.isBusy);
-  
+
               authEvent.emit('project_user.update', { updatedProject_userPopulated: pu, req: undefined, skipArchive: true }); //if queued with jobs -> websocket notification on project_user.update doesn't work??? forse si in quanto viene convertito in .pub.queue e poi rifunziiona
-  
-  
+
+
               // project_user.update triggers activityArchiver(tested), cache invalidation(tested), subscriptionNotifierQueued and websocket(tested works from queue i trigger ws)
               if (requestEvent.queueEnabled) {  //force to .queue to be catched into the queue (activity archiver, subscriptionNotifierQueued )
                 authEvent.emit('project_user.update.queue', { updatedProject_userPopulated: pu, req: undefined, skipArchive: true });
               }
-  
+
             })
-  
+
           });
-  
+
         });
     })
 
@@ -123,141 +137,184 @@ class Listener {
       });
   }
 
-    updateParticipatingProjectUsers(request, operation) {
-        winston.debug("Route queue request.participatingAgents", request.participatingAgents);
-        if (request.participatingAgents.length>0) {
-            request.participatingAgents.forEach(user => {
-              winston.debug("request.participatingAgents user",user); //it is a user and not a project_user
-                var userid = user.id || user._id;
-                winston.debug("updateParticipatingProjectUsers userid: "+userid); 
-
-                this.updateProjectUser(userid, request.id_project, operation);                
-            });
-        } 
-      }  
-
-    listen() {
-
-      if (this.enabled==true) {
-        winston.info("Route queue with queue Listener listen");
-      } else {
-          return winston.info("Route queue with queue Listener disabled");
+  updateParticipatingProjectUsers(request, operation) {
+    winston.debug("Route queue request.participatingAgents", request.participatingAgents);
+    if (request.participatingAgents.length > 0) {
+      request.participatingAgents.forEach(user => {
+        winston.debug("request.participatingAgents user", user); //it is a user and not a project_user
+        var userid = user.id || user._id;
+        winston.debug("updateParticipatingProjectUsers userid: " + userid);
+
+        this.updateProjectUser(userid, request.id_project, operation);
+      });
+    }
+  }
+
+  async saveFlowAttributes(request) {
+    try {
+      if (!request || !request.request_id) {
+        return winston.warn("saveFlowAttributes: missing request_id");
+      }
+      /**
+       * The parameters are taken from the chatbot, which already contains the logic to filter out system parameters.
+       * For deletion, you can act directly on Redis.
+       */
+      let parameters = await requestService.getRequestParametersFromChatbot(request.request_id);
+      if (!parameters || Object.keys(parameters).length === 0) {
+        return;
       }
+      await Request.updateOne(
+        { request_id: request.request_id, id_project: request.id_project },
+        { $set: { 'attributes.flowAttributes': parameters } }
+      );
+      winston.debug("Flow attributes saved for request: " + request.request_id);
 
-        var that = this;
- 
-        // TODO fai versione che passa anche project
-        var requestCreateKey = 'request.create';
-        if (requestEvent.queueEnabled) {
-          requestCreateKey = 'request.create.queue';
-        }
-        winston.debug('Route queue requestCreateKey: ' + requestCreateKey);
-   
-        requestEvent.on(requestCreateKey, async (request) => {
-            setImmediate(() => {
-              winston.debug('Route queue requestCreate');
-              this.updateParticipatingProjectUsers(request, +1);  
-            });
-        });
+      await this.deleteFlowAttributesFromCache(request);
 
-          // TODO usa versione complete con project per evitare query??
-        var requestCloseKey = 'request.close';   //request.close event here queued under job
-        if (requestEvent.queueEnabled) {
-          requestCloseKey = 'request.close.queue';
-        }
-        winston.debug('Route queue requestCloseKey: ' + requestCloseKey);
+    } catch (err) {
+      winston.error("Error saving flow attributes: ", err);
+    }
+  }
 
-        requestEvent.on(requestCloseKey, async (request) => {    //request.close event here noqueued
-          winston.debug("request.close event here 4")
-          setImmediate(() => {
-            winston.debug('Route queue requestClose');
-            this.updateParticipatingProjectUsers(request, -1);          
-          });
-        });
+  async deleteFlowAttributesFromCache(request) {
+    if (!this.tdCache) {
+      return winston.warn("deleteFlowAttributesFromCache: tdCache not set");
+    }
+    if (!request || !request.request_id) {
+      return winston.warn("deleteFlowAttributesFromCache: missing request_id");
+    }
+    const key = `tilebot:requests:${request.request_id}:parameters`;
+    try {
+      await this.tdCache.del(key);
+      winston.debug("Flow attributes cache deleted: " + key);
+    } catch (err) {
+      winston.error("Error deleting flow attributes from cache: ", err);
+    }
+  }
 
+  listen() {
 
-        var requestParticipantsJoinKey = 'request.participants.join';
-        if (requestEvent.queueEnabled) {
-          requestParticipantsJoinKey = 'request.participants.join.queue';
-        }
-        winston.debug('Route queue  requestParticipantsJoinKey: ' + requestParticipantsJoinKey);
-   
-        requestEvent.on(requestParticipantsJoinKey, async (data) => {
-          winston.debug('Route queue ParticipantsJoin');
-
-          var request = data.request;
-          var member = data.member;
-          setImmediate(() => {
-            this.updateProjectUser(member, request.id_project, 1);          
-          });
-        });
+    if (this.enabled == true) {
+      winston.info("Route queue with queue Listener listen");
+    } else {
+      return winston.info("Route queue with queue Listener disabled");
+    }
 
-        var requestParticipantsLeaveKey = 'request.participants.leave';
-        if (requestEvent.queueEnabled) {
-          requestParticipantsLeaveKey = 'request.participants.leave.queue';
-        }
-        winston.debug('Route queue  requestParticipantsLeaveKey: ' + requestParticipantsLeaveKey);
-   
-        requestEvent.on(requestParticipantsLeaveKey, async (data) => {
-          winston.debug('Route queue ParticipantsLeave');
-
-          var request = data.request;
-          var member = data.member;
-          setImmediate(() => {
-            this.updateProjectUser(member, request.id_project, -1);          
-          });
-        });
+    var that = this;
 
-        var requestParticipantsUpdateKey = 'request.participants.update';
-        if (requestEvent.queueEnabled) {
-         requestParticipantsUpdateKey = 'request.participants.update.queue';
-        }
-        winston.debug('Route queue  requestParticipantsUpdateKey: ' + requestParticipantsUpdateKey);
-   
-        requestEvent.on(requestParticipantsUpdateKey, async (data) => {
-          winston.debug('Route queue Participants Update');
+    // TODO fai versione che passa anche project
+    var requestCreateKey = 'request.create';
+    if (requestEvent.queueEnabled) {
+      requestCreateKey = 'request.create.queue';
+    }
+    winston.debug('Route queue requestCreateKey: ' + requestCreateKey);
 
-          var request = data.request;
-          var removedParticipants = data.removedParticipants;
-          var addedParticipants = data.addedParticipants;
+    requestEvent.on(requestCreateKey, async (request) => {
+      setImmediate(() => {
+        winston.debug('Route queue requestCreate');
+        this.updateParticipatingProjectUsers(request, +1);
+      });
+    });
 
-          setImmediate(() => {
+    // TODO usa versione complete con project per evitare query??
+    var requestCloseKey = 'request.close';   //request.close event here queued under job
+    if (requestEvent.queueEnabled) {
+      requestCloseKey = 'request.close.queue';
+    }
+    winston.debug('Route queue requestCloseKey: ' + requestCloseKey);
+
+    requestEvent.on(requestCloseKey, async (request) => {    //request.close event here noqueued
+      winston.debug("request.close event here 4")
+      setImmediate(() => {
+        winston.debug('Route queue requestClose');
+        this.updateParticipatingProjectUsers(request, -1);
+        this.saveFlowAttributes(request);
+      });
+    });
 
-            addedParticipants.forEach(participant => {
-              winston.debug('addedParticipants participant', participant);
-              this.updateProjectUser(participant, request.id_project, 1);          
-            });
 
-            removedParticipants.forEach(participant => {
-              winston.debug('removedParticipants participant', participant);
-              this.updateProjectUser(participant, request.id_project, -1);          
-            });
+    var requestParticipantsJoinKey = 'request.participants.join';
+    if (requestEvent.queueEnabled) {
+      requestParticipantsJoinKey = 'request.participants.join.queue';
+    }
+    winston.debug('Route queue  requestParticipantsJoinKey: ' + requestParticipantsJoinKey);
 
-          });
+    requestEvent.on(requestParticipantsJoinKey, async (data) => {
+      winston.debug('Route queue ParticipantsJoin');
+
+      var request = data.request;
+      var member = data.member;
+      setImmediate(() => {
+        this.updateProjectUser(member, request.id_project, 1);
+      });
+    });
+
+    var requestParticipantsLeaveKey = 'request.participants.leave';
+    if (requestEvent.queueEnabled) {
+      requestParticipantsLeaveKey = 'request.participants.leave.queue';
+    }
+    winston.debug('Route queue  requestParticipantsLeaveKey: ' + requestParticipantsLeaveKey);
+
+    requestEvent.on(requestParticipantsLeaveKey, async (data) => {
+      winston.debug('Route queue ParticipantsLeave');
+
+      var request = data.request;
+      var member = data.member;
+      setImmediate(() => {
+        this.updateProjectUser(member, request.id_project, -1);
+      });
+    });
+
+    var requestParticipantsUpdateKey = 'request.participants.update';
+    if (requestEvent.queueEnabled) {
+      requestParticipantsUpdateKey = 'request.participants.update.queue';
+    }
+    winston.debug('Route queue  requestParticipantsUpdateKey: ' + requestParticipantsUpdateKey);
+
+    requestEvent.on(requestParticipantsUpdateKey, async (data) => {
+      winston.debug('Route queue Participants Update');
+
+      var request = data.request;
+      var removedParticipants = data.removedParticipants;
+      var addedParticipants = data.addedParticipants;
+
+      setImmediate(() => {
+
+        addedParticipants.forEach(participant => {
+          winston.debug('addedParticipants participant', participant);
+          this.updateProjectUser(participant, request.id_project, 1);
         });
 
-        var requestWorkingStatusUpdateKey = 'request.workingStatus.update';
-        if (requestEvent.queueEnabled) {
-          requestWorkingStatusUpdateKey = 'request.workingStatus.update.queue';
-        }
-        winston.debug('Route queue requestWorkingStatusUpdateKey: ' + requestWorkingStatusUpdateKey);
-
-        requestEvent.on(requestWorkingStatusUpdateKey, async (data) => {
-          winston.debug('Route queue WorkingStatus Update');
-
-          var request = data.request;
-          var participantIds = (request.participantsAgents && request.participantsAgents.length)
-            ? request.participantsAgents
-            : (request.participatingAgents || []).map(u => u._id || u.id);
-          setImmediate(() => {
-            participantIds.forEach(id_user => {
-              if (id_user && !String(id_user).startsWith('bot_')) {
-                this.updateProjectUser(id_user, request.id_project, 0);
-              }
-            });
-          });
+        removedParticipants.forEach(participant => {
+          winston.debug('removedParticipants participant', participant);
+          this.updateProjectUser(participant, request.id_project, -1);
         });
+
+      });
+    });
+
+    var requestWorkingStatusUpdateKey = 'request.workingStatus.update';
+    if (requestEvent.queueEnabled) {
+      requestWorkingStatusUpdateKey = 'request.workingStatus.update.queue';
     }
+    winston.debug('Route queue requestWorkingStatusUpdateKey: ' + requestWorkingStatusUpdateKey);
+
+    requestEvent.on(requestWorkingStatusUpdateKey, async (data) => {
+      winston.debug('Route queue WorkingStatus Update');
+
+      var request = data.request;
+      var participantIds = (request.participantsAgents && request.participantsAgents.length)
+        ? request.participantsAgents
+        : (request.participatingAgents || []).map(u => u._id || u.id);
+      setImmediate(() => {
+        participantIds.forEach(id_user => {
+          if (id_user && !String(id_user).startsWith('bot_')) {
+            this.updateProjectUser(id_user, request.id_project, 0);
+          }
+        });
+      });
+    });
+  }
 
 }
 

package/routes/kb.js

@@ -240,7 +240,7 @@ router.post('/scrape/single', async (req, res) => {
         json.content = kb.content;
       }
 
-      if (kb.scrape_type) {
+      if (kb.scrape_type !== null) {
         json.scrape_type = kb.scrape_type
       }
 

package/routes/request.js

@@ -2479,12 +2479,17 @@ router.get('/:requestid/chatbot/parameters', async (req, res) => {
     return res.status(401).send({ success: false, message: "Request does not belong to the project"})
   }
 
-  requestService.getRequestParametersFromChatbot(request_id).then((parameters) => {
+  requestService.getRequestParameters(request_id).then((parameters) => {
     res.status(200).send(parameters);
 
   }).catch((err) => {
-    console.error("err: ", err.response)
-    res.status(400).send(err);
+    if (err.message) {
+      winston.error("Error getting request flow attributes: ", err.message);
+      res.status(400).send({ success: false, message: err.message });
+    } else {
+      winston.error("err: ", err);
+      res.status(400).send({ success: false, message: "Error getting request flow attributes" });
+    }
   })
 
 })

package/services/requestService.js

@@ -2478,7 +2478,27 @@ class RequestService {
     });
   }
 
+  async getRequestParameters(request_id) {
+    try {
+      let parameters = await this.getRequestParametersFromChatbot(request_id);
+      if (parameters && Object.keys(parameters).length > 0) {
+        return parameters;
+      }
+    } catch (err) {
+      winston.warn("Error getting request parameters from chatbot, falling back to DB: ", err.message || err);
+    }
+    return await this.getRequestParametersFromDB(request_id);
+  }
 
+  async getRequestParametersFromDB(request_id) {
+    try {
+      let request = await Request.findOne({ request_id: request_id }).select('attributes.flowAttributes').exec();
+      return request?.attributes?.flowAttributes || {};
+    } catch (err) {
+      winston.error("Error getting request parameters from DB: ", err);
+      throw new Error("Error getting request flow attributes");
+    }
+  }
 
   async getRequestParametersFromChatbot(request_id) {