@tiledesk/tiledesk-server 2.3.17 → 2.3.19

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/pubmodules/trigger/start.js

@@ -102,9 +102,13 @@ projectEvent.on('project.create', async (project) => {
 */
 
         
-        winston.info("triggers created for new project");
+        winston.debug("triggers created for new project");
 
 
+
+
+        // cc
+
     });
 });
 

package/routes/auth.js

@@ -112,13 +112,18 @@ function (req, res) {
     winston.error("SigninAnonymously validation error", {errors: errors, reqBody: req.body, reqUrl: req.url });
     return res.status(422).json({ errors: errors.array() });
   }
-  var firstname = req.body.firstname || "Guest";
+
+  let uid = uuidv4();
+  let shortuid = uid.substring(0,4); 
+  var firstname = req.body.firstname || "guest#"+shortuid; // guest_here
+  // var firstname = req.body.firstname || "Guest"; // guest_here
+  
   
 
   //TODO togli trattini da uuidv4()
   
 // TODO remove email.sec?
-  let userAnonym = {_id: uuidv4(), firstname:firstname, lastname: req.body.lastname, email: req.body.email, attributes: req.body.attributes};
+  let userAnonym = {_id: uid, firstname:firstname, lastname: req.body.lastname, email: req.body.email, attributes: req.body.attributes};
 
   req.user = UserUtil.decorateUser(userAnonym);
 

package/routes/project_user.js

@@ -220,6 +220,10 @@ router.put('/', [passport.authenticate(['basic', 'jwt'], { session: false }), va
   if (req.body.user_available!=undefined) {
     update.user_available = req.body.user_available;
   }
+
+  if (req.body.profileStatus!=undefined) {
+    update.profileStatus = req.body.profileStatus;
+  }
   
   if (req.body.max_assigned_chat!=undefined) {
     update.max_assigned_chat = req.body.max_assigned_chat;
@@ -241,6 +245,7 @@ router.put('/', [passport.authenticate(['basic', 'jwt'], { session: false }), va
 
 
 
+
   Project_user.findByIdAndUpdate(req.projectuser.id, update,  { new: true, upsert: true }, function (err, updatedProject_user) {
     if (err) {
       winston.error("Error gettting project_user for update", err);
@@ -274,6 +279,10 @@ router.put('/:project_userid', [passport.authenticate(['basic', 'jwt'], { sessio
     update.user_available = req.body.user_available;
   }
 
+  if (req.body.profileStatus!=undefined) {
+    update.profileStatus = req.body.profileStatus;
+  }
+  
   if (req.body.max_assigned_chat!=undefined) {
     update.max_assigned_chat = req.body.max_assigned_chat;
   }

package/routes/request.js

@@ -162,6 +162,20 @@ router.patch('/:requestid', function (req, res) {
     update.priority = req.body.priority;
   }
 
+  if (req.body.smartAssignment!=undefined) {
+    update.smartAssignment = req.body.smartAssignment;
+  }
+  
+  if (req.body.workingStatus!=undefined) {
+    update.workingStatus = req.body.workingStatus;
+  }
+  
+
+  if (req.body.channelName) {
+    update["channel.name"] = req.body.channelName;
+  }
+
+
   
   winston.verbose("Request patch update",update);
 
@@ -710,6 +724,10 @@ router.get('/', function (req, res, next) {
     winston.debug('REQUEST ROUTE - QUERY DEPT ID', query.department);
   }
 
+  if (req.query.requester_email) {
+    query["snapshot.lead.email"] = req.query.requester_email;
+  }
+
   if (req.query.full_text) {
     winston.debug('req.query.fulltext', req.query.full_text);
     query.$text = { "$search": req.query.full_text };