@tiledesk/tiledesk-server 2.3.18 → 2.3.20

package/event/messageEvent.js

@@ -7,7 +7,7 @@ var MessageConstants = require("../models/messageConstants");
 var message2Event = require("../event/message2Event");
 
 var cacheUtil = require('../utils/cacheUtil');
-
+// var requestService = require("../services/requestService");
 
 
 class MessageEvent extends EventEmitter { 
@@ -40,7 +40,8 @@ function populateMessageCreate(message) {
   return populateMessageWithRequest(message, 'message.create');
 }
 function populateMessageUpdate(message) {
-  return populateMessageWithRequest(message, 'message.update');
+  // return populateMessageWithRequest(message, 'message.update');
+  return; // do not populate message.update it's not used by anyone. Not used by webhook. populate for message.update is slow.
 }
 
 
@@ -48,6 +49,7 @@ function populateMessageWithRequest(message, eventPrefix) {
 
   
   winston.debug("populateMessageWithRequest "+eventPrefix, message.toObject());
+  winston.debug("populateMessageWithRequest "+eventPrefix +" "+ message.text);
   
   var messageJson = message.toJSON();
 
@@ -159,4 +161,82 @@ messageEvent.on('message.create.simple', populateMessageCreate);
 messageEvent.on('message.update.simple', populateMessageUpdate);
 
 
+
+// riattiva commentato per performance
+
+
+// var messageCreateKey = 'message.create';
+// if (messageEvent.queueEnabled) {
+//   messageCreateKey = 'message.create.queue';
+// }
+// winston.debug("messageEvent.queueEnabled: "+messageEvent.queueEnabled); 
+
+// winston.debug("messageCreateKey: "+messageCreateKey); 
+
+// messageEvent.on(messageCreateKey, function(message) {
+//   setImmediate(() => {      
+//     winston.debug("message.create before");
+//     if (!message.request) {
+//       return;
+//     }
+//     let request_id = message.request.request_id;
+//     let id_project = message.request.id_project;
+
+
+//     //update waiitng time if write an  agent (member of participants)
+//     let visitor_sent_last_message = false;
+//     // winston.info(" message.request.snapshot.lead.lead_id: "+  message.request.snapshot.lead.lead_id);
+//     // winston.info(" message.sender: "+  message.sender);
+
+//     if (message.request.snapshot && message.request.snapshot.lead.lead_id == message.sender) { 
+//       visitor_sent_last_message = true;
+//     }
+
+
+
+//     // don't work for recursive call
+//     // requestService.incrementMessagesCountByRequestId(message.request._id, message.request.id_project).then(function (savedRequest) {
+//     //   winston.info("incremented request", savedRequest);
+//     // });
+//     let clonedmessage = Object.assign({}, message);
+//     delete clonedmessage.request
+    
+    
+//     let data = {
+//       $push: {
+//         "snapshot.messages.data": {
+//               $each: [ clonedmessage ],
+//               $slice: -30
+//             }
+//       },
+//       $inc : {'snapshot.messages.messages_count' : 1},
+//       "snapshot.messages.visitor_sent_last_message": visitor_sent_last_message,
+//       "snapshot.messages.last_message_timestamp": message.createdAt
+//     };
+
+//     // db.getCollection('requests').find({"$expr": { "$gt": [ "$snapshot.messages.visitor_last_message_timestamp", "$snapshot.messages.agent_last_message_timestamp"]}})
+    
+    
+//     if (visitor_sent_last_message) {
+//       data["snapshot.messages.visitor_last_message_timestamp"]= message.createdAt;
+//     } else {
+//       data["snapshot.messages.agent_last_message_timestamp"]= message.createdAt;
+//     }
+//     // db.getCollection('requests').updateOne({"request_id":"support-group-630600bfaf7cd942116bc993-3da378ec63924bb9b4934b2835b37a7c"},{"$push":{"snapshot.messages.data":{"$each":["s"],"$slice":-5}}}}})
+//     winston.debug("data", data);
+
+//     return Request       
+//             .findOneAndUpdate({request_id: request_id, id_project: id_project}, data, {new: true, upsert:false}, function(err, updatedRequest) {
+//                 if (err) {
+//                   winston.error(err);
+//                   return reject(err);
+//                 }
+//                 winston.info("Message count +1");
+                
+//               });
+
+//   });
+// });
+
+
 module.exports = messageEvent;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.3.18",
+  "version": "2.3.20",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",
@@ -33,9 +33,7 @@
     "@tiledesk-ent/tiledesk-server-dialogflow": "^1.1.6",
     "@tiledesk-ent/tiledesk-server-jwthistory": "^1.1.9",
     "@tiledesk-ent/tiledesk-server-payments": "^1.1.6",
-    "@tiledesk-ent/tiledesk-server-queue": "^1.1.11",
     "@tiledesk-ent/tiledesk-server-request-history": "^1.1.5",
-    "@tiledesk-ent/tiledesk-server-routing-queue": "^1.1.11",
     "@tiledesk-ent/tiledesk-server-visitorcounter": "^1.1.1",
     "@tiledesk-ent/tiledesk-server-enterprise": "^1.0.0"
   },

package/pubmodules/pubModulesManager.js

@@ -33,6 +33,12 @@ class PubModulesManager {
 
         this.tilebot = undefined;
         this.tilebotRoute = undefined;
+
+        this.queue = undefined;
+
+        this.jobsManager = undefined;
+
+        this.routingQueue = undefined;
     }
 
   
@@ -88,6 +94,8 @@ class PubModulesManager {
     init(config) {
         winston.debug("PubModulesManager init");
 
+        // this.jobsManager = config.jobsManager;
+
         try {
             this.appRules = require('./rules/appRules');
             // this.appRules.start();
@@ -128,7 +136,6 @@ class PubModulesManager {
         }
         
         
-        
          try {
             this.emailNotification = require('./emailNotification');
             winston.debug("this.emailNotification:"+ this.emailNotification);
@@ -203,7 +210,6 @@ class PubModulesManager {
 
 
 
-
         try {
             this.activityArchiver = require('./activities').activityArchiver;
             // this.activityArchiver.listen();
@@ -282,6 +288,39 @@ class PubModulesManager {
         }
 
 
+
+
+        try {
+            this.queue = require('./queue');
+            winston.debug("this.queue:"+ this.queue);                
+
+            winston.info("PubModulesManager initialized queue.");
+        } catch(err) {
+            if (err.code == 'MODULE_NOT_FOUND') { 
+                winston.info("PubModulesManager init queue module not found");
+            }else {
+                winston.info("PubModulesManager error initializing init queue module", err);
+            }
+        }
+
+
+
+
+        try {
+            this.routingQueue = require('./routing-queue').listener;
+            // this.routingQueue.listen();
+            winston.debug("this.routingQueue:"+ this.routingQueue);           
+
+            winston.info("PubModulesManager routing queue initialized");
+        } catch(err) {
+            if (err.code == 'MODULE_NOT_FOUND') {
+                winston.info("PubModulesManager init routing queue module not found");
+            }else {
+                winston.error("PubModulesManager error initializing init routing queue module", err);
+            }
+        }
+
+
     }
 
     start() {
@@ -316,9 +355,11 @@ class PubModulesManager {
             
         }
         
+        // job_here
         if (this.emailNotification) {
             try {
                 this.emailNotification.requestNotification.listen();
+                // this.jobsManager.listenEmailNotification(this.emailNotification);
                 winston.info("PubModulesManager emailNotification started.");   
             } catch(err) {        
                 winston.info("PubModulesManager error starting requestNotification module", err);            
@@ -334,13 +375,24 @@ class PubModulesManager {
             }
         } 
 
-
+        // job_here
         if (this.activityArchiver) {
             try {
                 this.activityArchiver.listen();
-                winston.info("ModulesManager activityArchiver started");
+                // this.jobsManager.listenActivityArchiver(this.activityArchiver);
+                winston.info("PubModulesManager activityArchiver started");
+            } catch(err) {        
+                winston.info("PubModulesManager error starting activityArchiver module", err);            
+            }
+        }
+
+
+        if (this.routingQueue) {
+            try {
+                this.routingQueue.listen();
+                winston.info("PubModulesManager routingQueue started");
             } catch(err) {        
-                winston.info("ModulesManager error starting activityArchiver module", err);            
+                winston.info("PubModulesManager error starting routingQueue module", err);            
             }
         }
 

package/pubmodules/queue/index.js

@@ -0,0 +1,4 @@
+const reconnect = require("./reconnect");
+const reconnectFanout = require("./reconnectFanout");
+
+module.exports = {reconnect:reconnect,reconnectFanout: reconnectFanout };

package/pubmodules/queue/reconnect.js

@@ -0,0 +1,247 @@
+var amqp = require('amqplib/callback_api');
+var winston = require('../../config/winston');
+const requestEvent = require('../../event/requestEvent');
+const messageEvent = require('../../event/messageEvent');
+const authEvent = require('../../event/authEvent');
+// https://elements.heroku.com/addons/cloudamqp
+// https://gist.github.com/carlhoerberg/006b01ac17a0a94859ba#file-reconnect-js
+// http://www.rabbitmq.com/tutorials/tutorial-one-javascript.html
+
+// if the connection is closed or fails to be established at all, we will reconnect
+var amqpConn = null;
+
+var url = process.env.CLOUDAMQP_URL + "?heartbeat=60" || "amqp://localhost";
+// attento devi aggiornare configMap di PRE E PROD
+// var url = process.env.AMQP_URL + "?heartbeat=60" || "amqp://localhost?heartbeat=60";
+
+var exchange = 'amq.topic';
+
+function start() {
+  amqp.connect(url, function(err, conn) {
+    if (err) {
+      winston.error("[AMQP]", err.message);
+      return setTimeout(start, 1000);
+    }
+    conn.on("error", function(err) {
+      if (err.message !== "Connection closing") {
+        winston.error("[AMQP] conn error", err);
+      }
+    });
+    conn.on("close", function() {
+      winston.error("[AMQP] reconnecting");
+      return setTimeout(start, 1000);
+    });
+
+    winston.info("[AMQP] connected");
+    amqpConn = conn;
+
+    whenConnected();
+  });
+}
+
+function whenConnected() {
+  startPublisher();
+
+
+  let jobWorkerEnabled = false;
+  if (process.env.JOB_WORKER_ENABLED=="true" || process.env.JOB_WORKER_ENABLED == true) {
+      jobWorkerEnabled = true;
+  }
+  winston.info("JobsManager jobWorkerEnabled: "+ jobWorkerEnabled);  
+
+  if (jobWorkerEnabled == false) {
+    winston.info("Queue Reconnect start worker");
+    startWorker();
+  } else {
+    winston.info("Queue Reconnect without worker because external worker is enabled");
+  }
+  
+}
+
+var pubChannel = null;
+var offlinePubQueue = [];
+function startPublisher() {
+  amqpConn.createConfirmChannel(function(err, ch) {
+    if (closeOnErr(err)) return;
+    ch.on("error", function(err) {
+      winston.error("[AMQP] channel error", err);
+    });
+    ch.on("close", function() {
+      winston.info("[AMQP] channel closed");
+    });
+
+    pubChannel = ch;
+    while (true) {
+      var m = offlinePubQueue.shift();
+      if (!m) break;
+      publish(m[0], m[1], m[2]);
+    }
+  });
+}
+
+// method to publish a message, will queue messages internally if the connection is down and resend later
+function publish(exchange, routingKey, content) {
+  try {
+    pubChannel.publish(exchange, routingKey, content, { persistent: true },
+                       function(err, ok) {
+                         if (err) {
+                          winston.error("[AMQP] publish", err);
+                           offlinePubQueue.push([exchange, routingKey, content]);
+                           pubChannel.connection.close();
+                         }
+                       });
+  } catch (e) {
+    winston.error("[AMQP] publish", e);
+    offlinePubQueue.push([exchange, routingKey, content]);
+  }
+}
+
+// A worker that acks messages only if processed succesfully
+// var channel;
+function startWorker() {
+    amqpConn.createChannel(function(err, ch) {
+      if (closeOnErr(err)) return;
+      ch.on("error", function(err) {
+        winston.error("[AMQP] channel error", err);
+      });
+      ch.on("close", function() {
+        winston.info("[AMQP] channel closed");
+      });
+      ch.prefetch(10);//leggila da env
+      ch.assertExchange(exchange, 'topic', {
+        durable: true
+      });
+      ch.assertQueue("jobs", { durable: true }, function(err, _ok) {
+        if (closeOnErr(err)) return;
+        ch.bindQueue(_ok.queue, exchange, "request_create", {}, function(err3, oka) {
+            winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_create");
+            winston.info("Data queue", oka)
+        });
+        ch.bindQueue(_ok.queue, exchange, "request_update", {}, function(err3, oka) {
+            winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_update");
+            winston.info("Data queue", oka)
+        });
+        ch.bindQueue(_ok.queue, exchange, "message_create", {}, function(err3, oka) {
+              winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: message_create");
+              winston.info("Data queue", oka)
+        });
+        ch.bindQueue(_ok.queue, exchange, "project_user_update", {}, function(err3, oka) {
+          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: project_user_update");
+          winston.info("Data queue", oka)
+        });
+        ch.consume("jobs", processMsg, { noAck: false });
+        winston.info("Worker is started");
+      });
+  
+
+    function processMsg(msg) {
+      work(msg, function(ok) {
+        try {
+          if (ok)
+            ch.ack(msg);
+          else
+            ch.reject(msg, true);
+        } catch (e) {
+          closeOnErr(e);
+        }
+      });
+    }
+  });
+}
+
+function work(msg, cb) {
+  const message_string = msg.content.toString();
+  const topic = msg.fields.routingKey //.replace(/[.]/g, '/');
+
+  winston.debug("Got msg topic:" + topic);
+
+  winston.debug("Got msg:"+ message_string +  " topic:" + topic);
+
+  if (topic === 'request_create') {
+    winston.info("here topic:" + topic);
+    // requestEvent.emit('request.create.queue', msg.content);
+    requestEvent.emit('request.create.queue', JSON.parse(message_string));
+  }
+  if (topic === 'request_update') {
+    winston.info("here topic:" + topic);
+    // requestEvent.emit('request.update.queue',  msg.content);
+    requestEvent.emit('request.update.queue',  JSON.parse(message_string));
+  }
+  if (topic === 'message_create') {
+    winston.debug("here topic:" + topic);
+    // requestEvent.emit('request.create.queue', msg.content);
+    messageEvent.emit('message.create.queue', JSON.parse(message_string));
+  }
+  if (topic === 'project_user_update') {
+    winston.debug("here topic:" + topic);
+    // requestEvent.emit('request.create.queue', msg.content);
+    authEvent.emit('project_user.update.queue', JSON.parse(message_string));
+  }
+  cb(true);
+//   WebSocket.cb(true);
+//   requestEvent.on(msg.KEYYYYYYY+'.ws', msg.content);
+}
+
+
+function closeOnErr(err) {
+  if (!err) return false;
+  winston.error("[AMQP] error", err);
+  amqpConn.close();
+  return true;
+}
+
+// setInterval(function() {
+//     var d = new Date();
+//   publish(exchange, "request_create", Buffer.from("work work work: "+d));
+//   publish(exchange, "request_update", Buffer.from("work2 work work: "+d));
+// }, 1000);
+
+
+function listen() {
+
+    // http://www.squaremobius.net/amqp.node/channel_api.html
+    // https://docs.parseplatform.org/parse-server/guide/#scalability
+
+    requestEvent.on('request.create', function(request) {
+      setImmediate(() => {
+        winston.info("reconnect request.create")
+        publish(exchange, "request_create", Buffer.from(JSON.stringify(request)));
+      });
+    });
+
+    requestEvent.on('request.update', function(request) {
+      setImmediate(() => {
+        winston.info("reconnect request.update")
+        publish(exchange, "request_update", Buffer.from(JSON.stringify(request)));
+      });
+    });
+
+
+    messageEvent.on('message.create', function(message) {
+      setImmediate(() => {
+        publish(exchange, "message_create", Buffer.from(JSON.stringify(message)));
+      });
+    });
+
+    authEvent.on('project_user.update',function(data) {
+      setImmediate(() => {
+        let user = undefined;
+        if (data.req && data.req.user) { //i think is null from chat21webhook 
+          user = data.req.user;
+        }
+        var dat = {updatedProject_userPopulated: data.updatedProject_userPopulated, req: {user: user}}; //remove request
+        publish(exchange, "project_user_update", Buffer.from(JSON.stringify(dat)));
+      });
+    });
+
+}
+
+if (process.env.QUEUE_ENABLED === "true") {
+    requestEvent.queueEnabled = true;
+    messageEvent.queueEnabled = true;
+    authEvent.queueEnabled = true;
+    listen();
+    start();
+    winston.info("Queue enabled. endpint: " + url );
+} 
+

package/pubmodules/queue/reconnectFanout.js

@@ -0,0 +1,250 @@
+var amqp = require('amqplib/callback_api');
+var winston = require('../../config/winston');
+const requestEvent = require('../../event/requestEvent');
+const messageEvent = require('../../event/messageEvent');
+const authEvent = require('../../event/authEvent');
+// https://elements.heroku.com/addons/cloudamqp
+// https://gist.github.com/carlhoerberg/006b01ac17a0a94859ba#file-reconnect-js
+// http://www.rabbitmq.com/tutorials/tutorial-one-javascript.html
+
+// if the connection is closed or fails to be established at all, we will reconnect
+var amqpConn = null;
+var url = process.env.CLOUDAMQP_URL + "?heartbeat=60" || "amqp://localhost";
+// attento devi aggiornare configMap di PRE E PROD
+// var url = process.env.AMQP_URL + "?heartbeat=60" || "amqp://localhost";
+
+// MOD0
+var exchange = 'ws';
+
+function start() {
+  amqp.connect(url, function(err, conn) {
+    if (err) {
+      winston.error("[AMQP Fanout]", err.message);
+      return setTimeout(start, 1000);
+    }
+    conn.on("error", function(err) {
+      if (err.message !== "Connection closing") {
+        winston.error("[AMQP Fanout] conn error", err);
+      }
+    });
+    conn.on("close", function() {
+      winston.error("[AMQP Fanout] reconnecting");
+      return setTimeout(start, 1000);
+    });
+
+    winston.info("[AMQP Fanout] connected");
+    amqpConn = conn;
+
+    whenConnected();
+  });
+}
+
+function whenConnected() {
+  startPublisher();
+  startWorker();
+}
+
+var pubChannel = null;
+var offlinePubQueue = [];
+function startPublisher() {
+  amqpConn.createConfirmChannel(function(err, ch) {
+    if (closeOnErr(err)) return;
+    ch.on("error", function(err) {
+      winston.error("[AMQP Fanout] channel error", err);
+    });
+    ch.on("close", function() {
+      winston.info("[AMQP Fanout] channel closed");
+    });
+
+    pubChannel = ch;
+    while (true) {
+      var m = offlinePubQueue.shift();
+      if (!m) break;
+      publish(m[0], m[1], m[2]);
+    }
+  });
+}
+
+// method to publish a message, will queue messages internally if the connection is down and resend later
+function publish(exchange, routingKey, content) {
+  try {
+
+    // MOD2 
+    // pubChannel.publish('logs', '', Buffer.from('Hello World!'));
+    pubChannel.publish(exchange, routingKey, content, { },
+    // pubChannel.publish(exchange, routingKey, content, { persistent: true },
+                       function(err, ok) {
+                         if (err) {
+                          winston.error("[AMQP Fanout] publish", err);
+                           offlinePubQueue.push([exchange, routingKey, content]);
+                           pubChannel.connection.close();
+                         }
+                       });
+  } catch (e) {
+    winston.error("[AMQP Fanout] publish", e);
+    offlinePubQueue.push([exchange, routingKey, content]);
+  }
+}
+
+// A worker that acks messages only if processed succesfully
+// var channel;
+function startWorker() {
+    amqpConn.createChannel(function(err, ch) {
+      if (closeOnErr(err)) return;
+      ch.on("error", function(err) {
+        winston.error("[AMQP Fanout] channel error", err);
+      });
+      ch.on("close", function() {
+        winston.info("[AMQP Fanout] channel closed");
+      });
+      ch.prefetch(10);//leggila da env
+
+      // ch.assertExchange(exchange, 'topic', {
+      //   durable: true
+      // });
+
+      // MOD1
+      ch.assertExchange(exchange, 'fanout', {durable: false});
+
+      //MOD3 
+      ch.assertQueue('', {exclusive: true}, function(err, _ok) {
+      // ch.assertQueue("jobs", { durable: true }, function(err, _ok) {
+
+        if (closeOnErr(err)) return;
+        
+      //MOD4 
+        ch.bindQueue(_ok.queue, exchange, '', {}, function(err3, oka) {
+          winston.info("Queue Fanout bind: "+_ok.queue+ " err: "+err3);
+          winston.info("Data Queue", oka)
+        });
+
+        // ch.bindQueue(_ok.queue, exchange, "request_create", {}, function(err3, oka) {
+        //     console.log("queue bind: "+_ok.queue+ " err: "+err3+ " key: request_create");
+        //     console.log("data queue", oka)
+        // });
+        // ch.bindQueue(_ok.queue, exchange, "request_update", {}, function(err3, oka) {
+        //     console.log("queue bind: "+_ok.queue+ " err: "+err3+ " key: request_update");
+        //     console.log("data queue", oka)
+        // });
+        // ch.bindQueue(_ok.queue, exchange, "message_create", {}, function(err3, oka) {
+        //       console.log("queue bind: "+_ok.queue+ " err: "+err3+ " key: message_create");
+        //       console.log("data queue", oka)
+        // });
+        // ch.bindQueue(_ok.queue, exchange, "project_user_update", {}, function(err3, oka) {
+        //   console.log("queue bind: "+_ok.queue+ " err: "+err3+ " key: project_user_update");
+        //   console.log("data queue", oka)
+        // });
+        ch.consume(_ok.queue, processMsg, { noAck: false });
+        winston.info("Worker Fanout is started");
+      });
+  
+
+    function processMsg(msg) {
+      work(msg, function(ok) {
+        try {
+          if (ok)
+            ch.ack(msg);
+          else
+            ch.reject(msg, true);
+        } catch (e) {
+          closeOnErr(e);
+        }
+      });
+    }
+  });
+}
+
+function work(msg, cb) {
+  const message_string = msg.content.toString();
+  const topic = msg.fields.routingKey //.replace(/[.]/g, '/');
+
+  winston.debug("Got Fanout msg topic:" + topic);
+  
+  winston.debug("Got Fanout msg:"+ message_string +  " topic:" + topic);
+
+  if (topic === 'request_create') {
+    winston.debug("here topic:" + topic);
+    winston.info("reconnect request.update")
+    requestEvent.emit('request.create.queue.pubsub', JSON.parse(message_string));
+  }
+  if (topic === 'request_update') {
+    winston.debug("here topic:" + topic);
+    requestEvent.emit('request.update.queue.pubsub',  JSON.parse(message_string));
+  }
+  if (topic === 'message_create') {
+    winston.debug("here topic:" + topic);
+    messageEvent.emit('message.create.queue.pubsub', JSON.parse(message_string));
+  }
+  if (topic === 'project_user_update') {
+    winston.debug("here topic:" + topic);
+    authEvent.emit('project_user.update.queue.pubsub', JSON.parse(message_string));
+  }
+  cb(true);
+//   WebSocket.cb(true);
+//   requestEvent.on(msg.KEYYYYYYY+'.ws', msg.content);
+}
+
+
+function closeOnErr(err) {
+  if (!err) return false;
+  winston.error("[AMQP Fanout] error", err);
+  amqpConn.close();
+  return true;
+}
+
+// setInterval(function() {
+//     var d = new Date();
+//   publish(exchange, "request_create", Buffer.from("work work work: "+d));
+// }, 10000);
+
+
+
+// http://www.squaremobius.net/amqp.node/channel_api.html
+// https://docs.parseplatform.org/parse-server/guide/#scalability
+
+
+
+function listen() {
+    
+  requestEvent.on('request.create', function(request) {
+    setImmediate(() => {
+      publish(exchange, "request_create", Buffer.from(JSON.stringify(request)));
+    });
+  });
+
+  requestEvent.on('request.update', function(request) {
+    setImmediate(() => {
+      publish(exchange, "request_update", Buffer.from(JSON.stringify(request)));
+    });
+  });
+
+
+  messageEvent.on('message.create', function(message) {
+    setImmediate(() => {
+      publish(exchange, "message_create", Buffer.from(JSON.stringify(message)));
+    });
+  });
+  
+  authEvent.on('project_user.update',function(data) {
+    setImmediate(() => {
+
+      let user = undefined;
+      if (data.req && data.req.user) { //i think is null from chat21webhook 
+        user = data.req.user;
+      }
+      var dat = {updatedProject_userPopulated: data.updatedProject_userPopulated, req: {user: user}}; //remove request
+
+      publish(exchange, "project_user_update", Buffer.from(JSON.stringify(dat)));
+    });
+  });
+}
+
+if (process.env.QUEUE_ENABLED === "true") {
+    requestEvent.queueEnabled = true;
+    messageEvent.queueEnabled = true;
+    authEvent.queueEnabled = true; 
+    listen();
+    start();
+    winston.info("Queue Fanout enabled. endpint: " + url );
+} 
+

package/pubmodules/routing-queue/index.js

@@ -0,0 +1,3 @@
+const listener = require("./listener");
+
+module.exports = {listener:listener };

package/pubmodules/routing-queue/listener.js

@@ -0,0 +1,328 @@
+const projectEvent = require('../../event/projectEvent');
+const departmentEvent = require('../../event/departmentEvent');
+const authEvent = require('../../event/authEvent');
+const requestEvent = require('../../event/requestEvent');
+var Request = require('../../models/request');
+var Project = require('../../models/project');
+var Project_user = require('../../models/project_user');
+var winston = require('../../config/winston');
+
+var ProjectUserUtil = require("../../utils/project_userUtil");
+
+// var request = require('retry-request', {
+//     request: require('request')
+//   });
+
+// TODO riabilitare questo
+
+// const ROUTE_QUEUE_ENDPOINT = process.env.ROUTE_QUEUE_ENDPOINT;
+// winston.debug("ROUTE_QUEUE_ENDPOINT: " + ROUTE_QUEUE_ENDPOINT);
+
+// if (ROUTE_QUEUE_ENDPOINT) {
+//   winston.info("Route queue endpoint: " + ROUTE_QUEUE_ENDPOINT);
+// } else {
+//    winston.info("Route queue endpoint not configured");
+// }
+
+
+class Listener {
+
+ 
+  constructor() {
+    this.enabled = true;
+    if (process.env.ROUTE_QUEUE_ENABLED=="false" || process.env.ROUTE_QUEUE_ENABLED==false) {
+        this.enabled = false;
+    }
+    winston.debug("Listener this.enabled: "+ this.enabled);
+}
+
+     nextOperator(array, index) {
+        // console.log('array: ', array);
+        // console.log('index: ' + index);
+    
+        index = index || 0;
+    
+        if (array === undefined || array === null)
+          array = [];
+        else if (!Array.isArray(array))
+          throw new Error('Expecting argument to RoundRound to be an Array');
+    
+        // return function () {
+            index++;
+          if (index >= array.length) index = 0;
+          // console.log('index: ' + index);
+          return array[index];
+        // };
+      }
+
+      // db.getCollection('project_users').find({"number_assigned_requests" : {"$lt":0}}).count()
+
+
+    updateProjectUser(id_user, id_project, operation) {
+      winston.debug("updateProjectUser start");
+      return Project_user       
+                    .findOneAndUpdate({id_user: id_user, id_project: id_project}, {$inc : {'number_assigned_requests' : operation}}, {new: true, upsert:false}, function(err, updatedPU) {
+                    if (err) {
+                     return winston.error(err);
+                    }
+                    winston.debug("number_assigned_requests +1 :" + 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("pu.isBusy: "+ pu.isBusy);
+                        authEvent.emit('project_user.update', {updatedProject_userPopulated:pu, req: undefined, skipArchive: true});
+                      })
+                      
+                    });
+
+                });
+    }
+
+    updateParticipatingProjectUsers(request, operation) {
+        winston.debug("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
+                this.updateProjectUser(user.id, request.id_project, operation);                
+            });
+        } 
+      }  
+
+    listen() {
+
+      if (this.enabled==true) {
+        winston.info("Route queue Listener listen");
+      } else {
+          return winston.info("Route queue Listener disabled");
+      }
+
+        var that = this;
+ 
+        // TODO fai versione che passa anche project
+        requestEvent.on('request.create', async (request) => {
+            setImmediate(() => {
+              this.updateParticipatingProjectUsers(request, +1);  
+            });
+        });
+
+          // TODO usa versione complete con project per evitare query??
+        requestEvent.on('request.close', async (request) => {
+          setImmediate(() => {
+            this.updateParticipatingProjectUsers(request, -1);          
+          });
+        });
+
+
+        requestEvent.on('request.participants.join', async (data) => {
+          var request = data.request;
+          var member = data.member;
+          setImmediate(() => {
+            this.updateProjectUser(member, request.id_project, 1);          
+          });
+        });
+
+        requestEvent.on('request.participants.leave', async (data) => {
+          var request = data.request;
+          var member = data.member;
+          setImmediate(() => {
+            this.updateProjectUser(member, request.id_project, -1);          
+          });
+        });
+
+        requestEvent.on('request.participants.update', async (data) => {
+          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);          
+            });
+
+            removedParticipants.forEach(participant => {
+              winston.debug('removedParticipants participant', participant);
+              this.updateProjectUser(participant, request.id_project, -1);          
+            });
+
+          });
+        });
+
+        departmentEvent.on('operator.select.base2', async (res) => {
+            // departmentEvent.prependListener('operator.select', async (data) => {
+            
+              var operatorsResult = res.result;
+              winston.info('operator.select.base2 res', res);   
+          
+          
+              var disableWebHookCall = res.disableWebHookCall;
+              winston.debug("operator.select.base2 disableWebHookCall: "+ disableWebHookCall);
+          
+            if (disableWebHookCall===true) {      
+              winston.debug("operator.select.base2 disableWebHookCall enabled: "+ disableWebHookCall);
+              // return callNextEvent('operator.select', res);
+              return res.resolve(operatorsResult);
+          
+            }
+          
+          
+          
+          
+          
+          
+          
+          
+            var project = operatorsResult.project;
+            var max_agent_assigned_chat = undefined;
+          
+            
+            // console.log("project: ", project);
+          
+            if (project && project.settings && project.settings.chat_limit_on && project.settings.max_agent_assigned_chat) {
+              max_agent_assigned_chat = project.settings.max_agent_assigned_chat;
+              winston.debug('operator.select max_agent_assigned_chat: '+max_agent_assigned_chat);   
+          
+            } else {
+              winston.debug("chat_limit_on not defined calling next ");
+              return departmentEvent.callNextEvent('operator.select', res);
+            }
+          
+          
+             
+          
+            // winston.info('qui', operatorsResult.available_agents.length);   
+            operatorsResult.available_agents_request  = [];
+          
+            if (operatorsResult && operatorsResult.available_agents && operatorsResult.available_agents.length > 0) {        
+          
+              // winston.info('qui1');   
+               //  qui1000
+              var query = {id_project: operatorsResult.id_project, status: {$lt:1000}};      
+              // asyncForEach(operatorsResult.available_agents, async (aa) => {
+              for (const aa of operatorsResult.available_agents) {
+                query.participants = aa.id_user._id.toString();// attento qui
+                winston.debug("department operators query:" , query);
+
+
+                // questa cosa nn va bene. nn puoi usare ? number_assigned_requests??
+                var count =  await Request.countDocuments(query);
+                winston.debug("department operators count: "+ count);
+                operatorsResult.available_agents_request.push({project_user: aa, openRequetsCount : count});
+          
+              }
+          
+            }
+          
+          
+
+         
+             
+          
+              var available_agents_request = operatorsResult.available_agents_request;
+              var available_agents_not_busy = [];
+              if (available_agents_request && available_agents_request.length>0) {
+                for (const aa of available_agents_request) {
+                // console.log("aa.openRequetsCount ", aa.openRequetsCount, " for:", aa.project_user.id_user);
+          
+                  var maxAssignedchatForUser = max_agent_assigned_chat;
+          
+                  var max_agent_assigned_chat_specific_user = aa.project_user.max_assigned_chat;
+                  // console.log("max_agent_assigned_chat_specific_user: ", max_agent_assigned_chat_specific_user);
+          
+                  if (max_agent_assigned_chat_specific_user && max_agent_assigned_chat_specific_user!=-1 ) {
+                    maxAssignedchatForUser = max_agent_assigned_chat_specific_user;           
+                  }            
+                  
+                  winston.debug("maxAssignedchatForUser: "+ maxAssignedchatForUser);
+          
+                  if (aa.openRequetsCount < maxAssignedchatForUser) {
+                    winston.debug("adding  "+ aa.project_user.id_user+ " with openRequetsCount: "+ aa.openRequetsCount +" and with maxAssignedchatForUser " + maxAssignedchatForUser +" to available_agents_not_busy" );
+                    available_agents_not_busy.push(aa.project_user);
+                  }
+                }
+              } else {
+                winston.debug("available_agents_request not defined");
+              }
+          
+              winston.debug("available_agents_not_busy", available_agents_not_busy);
+          
+          
+
+                 // TODO non riassegnare allo stesso utente usa history oppure lastabandonedby in attributes 
+            // in project_user sengni il numero di abandoni se uguale a psettng lo metto offline
+            winston.debug("res.context",res.context);  
+
+            winston.debug("res.context.request.attributes",res.context.request.attributes);  
+
+              if (res.context && res.context.request  && res.context.request && 
+                res.context.request.attributes && res.context.request.attributes.abandoned_by_project_users ) {  //&& res.context.request.attributes.queue_important==false  (vip sla continuo reassign)
+                  
+                  // var abandoned_by_project_users= {"5ecd44cfa3f5670034109b44":true,"5ecd56a10e7d2d00343203cc":true}
+
+                  winston.debug("res.context.request.attributes.abandoned_by_project_users: ", res.context.request.attributes.abandoned_by_project_users );
+                  
+                  var abandoned_by_project_usersAsArray = Object.keys(res.context.request.attributes.abandoned_by_project_users);
+
+                  if (abandoned_by_project_usersAsArray.length>0 )  {
+                    winston.debug("abandoned_by_project_usersAsArray", abandoned_by_project_usersAsArray);
+
+                    var available_agents_not_busy = available_agents_not_busy.filter(projectUser=> !abandoned_by_project_usersAsArray.includes(projectUser._id.toString()))
+                  
+                    winston.debug("available_agents_not_busy after: ", available_agents_not_busy );                           
+                  }
+              }
+
+              // if (res.context && res.context.request  && res.context.request && 
+              //   res.context.request.attributes && res.context.request.attributes.last_abandoned_by )  {
+              //     winston.debug("res.context.request.attributes.last_abandoned_by: "+res.context.request.attributes.last_abandoned_by );
+              //     let last_abandoned_by_index = available_agents_not_busy.findIndex(projectUser => projectUser._id.toString() === res.context.request.attributes.last_abandoned_by);
+              //     winston.debug("last_abandoned_by_index: "+last_abandoned_by_index );
+              //     if (last_abandoned_by_index>-1) {
+              //       available_agents_not_busy.splice(last_abandoned_by_index, 1);
+              //       winston.debug("available_agents_not_busy after", available_agents_not_busy );
+              //     }                  
+
+              // }
+
+
+              var lastOperatorId  = operatorsResult.lastOperatorId;
+          
+              let lastOperatorIndex = available_agents_not_busy.findIndex(projectUser => projectUser.id_user.toString() === lastOperatorId);
+              winston.debug("lastOperatorIndex: "+ lastOperatorIndex);
+              var nextOper = that.nextOperator(available_agents_not_busy, lastOperatorIndex);
+              // console.log("nextOper: ", nextOper);
+              var nextOperatorId = undefined; 
+              if (nextOper && nextOper.id_user) {
+                nextOperatorId = nextOper.id_user;
+                winston.verbose("nextOperatorId: "+ nextOperatorId);
+          
+                operatorsResult.operators = [{id_user: nextOperatorId}];
+          
+                // return resolve(result);
+              } else {
+                winston.debug("nextOper is not defined");
+                operatorsResult.operators = [];
+                // return resolve(result);
+              }
+          
+          
+              return departmentEvent.callNextEvent('operator.select', res);
+          
+           
+          
+          });
+
+       
+    }
+
+}
+
+var listener = new Listener();
+
+
+module.exports = listener;

package/services/modulesManager.js

@@ -24,6 +24,7 @@ var licenseKey = process.env.LICENSE_KEY;
 if (licenseKey) {
     var maskedLicenseKey = MaskData.maskPhone(licenseKey, maskOptions);
     winston.info("LicenseKey: " + maskedLicenseKey);    
+    // winston.info("LicenseKey: " + licenseKey);    
 }
 
 class ModulesManager {
@@ -38,8 +39,8 @@ class ModulesManager {
         this.dialogflowListener = undefined;
         this.requestHistoryArchiver = undefined;
         this.requestHistoryRoute = undefined;
-        this.routingQueue = undefined;
-        this.queue = undefined;
+        // this.routingQueue = undefined;
+        // this.queue = undefined;
         this.cache = undefined;
         this.visitorCounterRoute = undefined;
         this.visitorCounterMiddleware = undefined;
@@ -216,34 +217,34 @@ class ModulesManager {
         }
 
 
-        try {
-            this.routingQueue = require('@tiledesk-ent/tiledesk-server-routing-queue').listener;
-            // this.routingQueue.listen();
-            winston.debug("this.routingQueue:"+ this.routingQueue);           
+        // try {
+        //     this.routingQueue = require('@tiledesk-ent/tiledesk-server-routing-queue').listener;
+        //     // this.routingQueue.listen();
+        //     winston.debug("this.routingQueue:"+ this.routingQueue);           
 
-            winston.info("ModulesManager routing queue initialized");
-        } catch(err) {
-            if (err.code == 'MODULE_NOT_FOUND') {
-                winston.info("ModulesManager init routing queue module not found");
-            }else {
-                winston.error("ModulesManager error initializing init routing queue module", err);
-            }
-        }
+        //     winston.info("ModulesManager routing queue initialized");
+        // } catch(err) {
+        //     if (err.code == 'MODULE_NOT_FOUND') {
+        //         winston.info("ModulesManager init routing queue module not found");
+        //     }else {
+        //         winston.error("ModulesManager error initializing init routing queue module", err);
+        //     }
+        // }
 
 
 
-        try {
-            this.queue = require('@tiledesk-ent/tiledesk-server-queue');            
-            winston.debug("this.queue:"+ this.queue);           
+        // try {
+        //     this.queue = require('@tiledesk-ent/tiledesk-server-queue');            
+        //     winston.debug("this.queue:"+ this.queue);           
 
-            winston.info("ModulesManager queue initialized");
-        } catch(err) {
-            if (err.code == 'MODULE_NOT_FOUND') {
-                winston.info("ModulesManager init queue module not found");
-            }else {
-                winston.error("ModulesManager error initializing init queue module", err);
-            }
-        }
+        //     winston.info("ModulesManager queue initialized");
+        // } catch(err) {
+        //     if (err.code == 'MODULE_NOT_FOUND') {
+        //         winston.info("ModulesManager init queue module not found");
+        //     }else {
+        //         winston.error("ModulesManager error initializing init queue module", err);
+        //     }
+        // }
 
 
         try {            
@@ -329,14 +330,14 @@ class ModulesManager {
                 winston.info("ModulesManager error starting requestHistoryArchiver module", err);            
             }
         }
-        if (this.routingQueue) {
-            try {
-                this.routingQueue.listen();
-                winston.info("ModulesManager routingQueue started");
-            } catch(err) {        
-                winston.info("ModulesManager error starting routingQueue module", err);            
-            }
-        }
+        // if (this.routingQueue) {
+        //     try {
+        //         this.routingQueue.listen();
+        //         winston.info("ModulesManager routingQueue started");
+        //     } catch(err) {        
+        //         winston.info("ModulesManager error starting routingQueue module", err);            
+        //     }
+        // }
         if (this.dialogflowListener) {
             try {
                 this.dialogflowListener.listen();