@tiledesk/tiledesk-server 2.2.39 → 2.3.1-8.1

package/pubmodules/analytics/index.js

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

package/pubmodules/canned/cannedResponse.js

@@ -0,0 +1,55 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+var winston = require('../../config/winston');
+
+
+var CannedResponseSchema = new Schema({
+  
+  title: {
+    type: String,
+    required: false,
+    index: true
+  },
+  text: {
+    type: String,
+    required: true,
+  },
+  shared: {
+    type: Boolean,
+    required: true
+  },
+  attributes: {
+    type: Object,
+  },
+  id_project: {
+    type: String,
+    required: true,
+    index: true
+  },
+  createdBy: {
+    type: String,
+    required: true
+  },
+  status: {
+    type: Number,
+    required: false,
+    default: 100,
+    index: true
+  }, 
+},{
+  timestamps: true
+}
+);
+
+
+// CannedResponseSchema.index({text: 'text'},
+//  {"name":"cannedresponse_fulltext","default_language": "italian","language_override": "dummy"}); // schema level
+
+ var CannedResponse = mongoose.model('cannedResponse', CannedResponseSchema);
+
+ if (process.env.MONGOOSE_SYNCINDEX) {
+  CannedResponse.syncIndexes();
+  winston.info("CannedResponse syncIndexes")
+}
+
+module.exports = CannedResponse;

package/pubmodules/canned/cannedResponseRoute.js

@@ -0,0 +1,163 @@
+var express = require('express');
+var router = express.Router();
+var CannedResponse = require("./cannedResponse");
+var winston = require('../../config/winston');
+// const CannedResponseEvent = require('../event/CannedResponseEvent');
+
+
+router.post('/', function (req, res) {
+
+  winston.debug(req.body);
+  winston.debug("req.user", req.user);
+
+  var newCannedResponse = new CannedResponse({
+    title: req.body.title,  
+    text: req.body.text,
+    id_project: req.projectid,
+    createdBy: req.user.id,
+    updatedBy: req.user.id
+  });
+
+  if (req.projectuser.role == 'owner' || req.projectuser.role == 'admin') {
+    newCannedResponse.shared = true;
+  } else {
+    newCannedResponse.shared = false;
+  }
+
+  newCannedResponse.save(function (err, savedCannedResponse) {
+    if (err) {
+      winston.error('--- > ERROR ', err)
+
+      return res.status(500).send({ success: false, msg: 'Error saving object.' });
+    }
+
+    res.json(savedCannedResponse);
+  });
+});
+
+router.put('/:cannedResponseid', function (req, res) {
+  winston.debug(req.body);
+  var update = {};
+  
+  if (req.body.title!=undefined) {
+    update.title = req.body.title; 
+  }  
+  if (req.body.text!=undefined) {
+    update.text = req.body.text;   
+  }
+  if (req.body.attributes!=undefined) {
+    update.attributes = req.body.attributes;
+  }
+  
+  
+  CannedResponse.findByIdAndUpdate(req.params.cannedResponseid, update, { new: true, upsert: true }, function (err, updatedCannedResponse) {
+    if (err) {
+      winston.error('--- > ERROR ', err);
+      return res.status(500).send({ success: false, msg: 'Error updating object.' });
+    }
+
+  
+
+    // CannedResponseEvent.emit('CannedResponse.update', updatedCannedResponse);
+    res.json(updatedCannedResponse);
+  });
+});
+
+router.delete('/:cannedResponseid', function (req, res) {
+  winston.debug(req.body);
+
+  CannedResponse.findByIdAndUpdate(req.params.cannedResponseid, {status: 1000}, { new: true, upsert: true }, function (err, updatedCannedResponse) {
+    if (err) {
+      winston.error('--- > ERROR ', err);
+      return res.status(500).send({ success: false, msg: 'Error updating object.' });
+    }
+
+   
+
+    // CannedResponseEvent.emit('CannedResponse.delete', updatedCannedResponse);
+    res.json(updatedCannedResponse);
+  });
+});
+
+router.delete('/:cannedResponseid/physical', function (req, res) {
+  winston.debug(req.body);
+
+  CannedResponse.remove({ _id: req.params.cannedResponseid }, function (err, cannedResponse) {
+    if (err) {
+      winston.error('--- > ERROR ', err);
+      return res.status(500).send({ success: false, msg: 'Error deleting object.' });
+    }
+
+  
+    // CannedResponseEvent.emit('CannedResponse.delete', CannedResponse);
+
+    res.json(cannedResponse);
+  });
+});
+
+router.get('/:cannedResponseid', function (req, res) {
+  winston.debug(req.body);
+
+  CannedResponse.findById(req.params.cannedResponseid, function (err, cannedResponse) {
+    if (err) {
+      return res.status(500).send({ success: false, msg: 'Error getting object.' });
+    }
+    if (!cannedResponse) {
+      return res.status(404).send({ success: false, msg: 'Object not found.' });
+    }
+    res.json(cannedResponse);
+  });
+});
+
+router.get('/', function (req, res) {
+  var limit = 1000; // Number of CannedResponses per page
+  var page = 0;
+
+  if (req.query.page) {
+    page = req.query.page;
+  }
+
+  var skip = page * limit;
+  winston.debug('CannedResponse ROUTE - SKIP PAGE ', skip);
+
+  // var query = { "id_project": req.projectid, "status": {$lt:1000}};
+  console.log("canned_req.user: ", req.user);
+  var query = {"id_project": req.projectid, "status": { $lt:1000 }, $or:[ { shared: true }, { createdBy: req.user._id } ] }
+
+  if (req.query.full_text) {
+    winston.debug('CannedResponse ROUTE req.query.fulltext', req.query.full_text);
+    query.$text = { "$search": req.query.full_text };
+  }
+
+  var direction = -1; //-1 descending , 1 ascending
+  if (req.query.direction) {
+    direction = req.query.direction;
+  }
+
+  var sortField = "createdAt";
+  if (req.query.sort) {
+    sortField = req.query.sort;
+  }
+
+  var sortQuery = {};
+  sortQuery[sortField] = direction;
+
+  winston.debug("sort query", sortQuery);
+
+  return CannedResponse.find(query).
+    skip(skip).limit(limit).
+    sort(sortQuery).
+    exec(function (err, cannedResponses) {
+      if (err) {
+        winston.error('CannedResponse ROUTE - REQUEST FIND ERR ', err)
+        return (err);
+      }
+    
+        return res.json(cannedResponses);
+    });
+});
+
+
+
+
+module.exports = router;

package/pubmodules/canned/index.js

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

package/pubmodules/emailNotification/requestNotification.js

@@ -31,11 +31,25 @@ winston.debug('********* RequestNotification apiUrl: ' + apiUrl);
 
 class RequestNotification {
 
+  constructor() {
+    this.enabled = true;
+    if (process.env.EMAIL_NOTIFICATION_ENABLED=="false" || process.env.EMAIL_NOTIFICATION_ENABLED==false) {
+        this.enabled = false;
+    }
+    winston.debug("RequestNotification this.enabled: "+ this.enabled);
+}
 
 listen() {
-    var that = this;
+    var that = this; 
     
 
+      
+    if (this.enabled==true) {
+      winston.info("RequestNotification listener started");
+    } else {
+        return winston.info("RequestNotification listener disabled");
+    }
+
 
     var messageCreateKey = 'message.create';
     if (messageEvent.queueEnabled) {
@@ -47,7 +61,7 @@ listen() {
     messageEvent.on(messageCreateKey, function(message) {
 
       setImmediate(() => {      
-        winston.debug("sendUserEmail", message);
+        winston.debug("messageEvent.on(messageCreateKey", message);
         
         if (message.attributes && message.attributes.subtype==='info') {
           return winston.debug("not sending sendUserEmail for attributes.subtype info messages");
@@ -56,17 +70,18 @@ listen() {
 
         if (message.request && (message.request.channel.name===ChannelConstants.EMAIL || message.request.channel.name===ChannelConstants.FORM)) {
 
+          //messages sent from admins or agents to requester
           if (message.sender != message.request.lead.lead_id) {
             winston.verbose("sending sendToUserEmailChannelEmail for EMAIL or FORM channel");
-
-            if (message.attributes && message.attributes.subtype==='private') {
-              return winston.debug("not sending sendToUserEmailChannelEmail for attributes.subtype private messages");
-            }            
-            return that.sendToUserEmailChannelEmail(message.id_project, message);           
-          } else {
+             
+            //send email notification to requester (send also to followers)
+            return that.sendToUserEmailChannelEmail(message.id_project, message);        
+          } else { //messages sent from requester to agents or admins
 
             if (message.text != message.request.first_text) {              
               winston.verbose("sending sendToAgentEmailChannelEmail for EMAIL or FORM channel");
+
+              //send email notification to admins and agents(send also to followers)
               return that.sendToAgentEmailChannelEmail(message.id_project, message);           
             } else {
               winston.debug("sending sendToAgentEmailChannelEmail for EMAIL or FORM channel disabled for first text message")
@@ -76,16 +91,22 @@ listen() {
           
         } else {
           winston.debug("sendUserEmail chat channel");
-              // controlla se sta funzionando
-          if (process.env.DISABLE_SEND_OFFLINE_EMAIL === "true" || process.env.DISABLE_SEND_OFFLINE_EMAIL === true ) {
-            return winston.debug("DISABLE_SEND_OFFLINE_EMAIL disabled");
-          }
-            // mandare email se ultimo messaggio > X MINUTI configurato in Notification . potresti usare request.updated_at ?
+                       
+
+            
+            
+            //messages sent from admins or agents
+            //send email notification to requester
           if (message.request && message.request.lead && message.sender != message.request.lead.lead_id) {
+            winston.debug("sendUserEmail");
             winston.debug("sendUserEmail", message);
 
-            // send an email only if offline and has an email 
+            // send an email only if offline and has an email (send also to followers)
             return that.sendUserEmail(message.id_project, message);
+          } else { //send email  to followers
+
+            that.sendToFollower(message.id_project, message);
+
           }
           
         }
@@ -139,7 +160,6 @@ listen() {
 
 
 
-
     //  requestEvent.on("request.update.preflight", function(request) {
       
     //   winston.info("requestEvent request.update.preflight");
@@ -227,15 +247,19 @@ listen() {
 
 
 sendToUserEmailChannelEmail(projectid, message) {
+  winston.debug("sendToUserEmailChannelEmail");
+  var that = this;
   try {
 
     if (!message.request) {
       return winston.debug("This is a direct message");
     }
 
-    if (!message.request.lead || !message.request.lead.email) {
-      return winston.debug("The lead object is undefined or has empty email");
-    }
+
+    
+
+
+    
 
     Project.findOne({_id: projectid, status: 100}).select("+settings").exec(function(err, project){
       if (err) {
@@ -245,6 +269,7 @@ sendToUserEmailChannelEmail(projectid, message) {
       if (!project) {
        return winston.warn("Project not found", projectid);
       } 
+      
 
       // if (project.settings && project.settings.email && project.settings.email.notification && project.settings.email.notification.conversation && project.settings.email.notification.conversation.offline && project.settings.email.notification.conversation.offline.blocked == true ) {
       //   return winston.info("RequestNotification offline email notification for the project with id : " + projectid + " for  the conversations is blocked");
@@ -256,7 +281,7 @@ sendToUserEmailChannelEmail(projectid, message) {
       // }
 
       let lead = message.request.lead;
-      winston.debug("sending channel emaol email to lead ", lead);
+      winston.debug("sending channel email to lead ", lead);
 
       
       winston.debug("sending user email to  "+ lead.email);
@@ -307,8 +332,24 @@ sendToUserEmailChannelEmail(projectid, message) {
       }
       winston.debug("tokenQueryString:  "+tokenQueryString);
       
+
+
+       // winston.info("savedRequest.followers", savedRequest.followers);
+      // winston.info("savedRequest.followers.length:"+ savedRequest.followers.length);
+      that.notifyFollowers(message.request, project, message);
+
+
+      if (message.attributes && message.attributes.subtype==='private') {
+        return winston.debug("not sending sendToUserEmailChannelEmail for attributes.subtype private messages");
+      }           
+
+      // nn va bene qui
+      if (!message.request.lead || !message.request.lead.email) {
+        return winston.debug("The lead object is undefined or has empty email");
+      }
+
       emailService.sendEmailChannelNotification(message.request.lead.email, message, project, tokenQueryString, sourcePage);
-    
+
 
     });
 
@@ -318,9 +359,112 @@ sendToUserEmailChannelEmail(projectid, message) {
 }
 
 
+async notifyFollowers(savedRequest, project, message) {
+
+  if (message.attributes && message.attributes.subtype==='info/support') {
+    return winston.debug("not sending notifyFollowers for attributes.subtype info/support messages");
+  }     
+
+  if (message.attributes && message.attributes.subtype==='info') {
+    return winston.debug("not sending notifyFollowers for attributes.subtype info messages");
+  }
+
+  if (!savedRequest) {
+    return winston.debug("not sending notifyFollowers for direct messages");
+  }
+
+  // Cannot read property '_id' of undefined at RequestNotification.notifyFollowers (/usr/src/app/pubmodules/emailNotification/requestNotification.js:358:62) at /usr/src/app
+  // forse meglio .id
+  
+  var reqWithFollowers = await Request.findById(savedRequest._id).populate('followers').exec();
+  winston.debug("reqWithFollowers");
+  winston.debug("reqWithFollowers",reqWithFollowers);
+  // console.log("reqWithFollowers",reqWithFollowers);
+
+  if (reqWithFollowers.followers && reqWithFollowers.followers.length>0) {
+
+    winston.debug("reqWithFollowers.followers.length: "+reqWithFollowers.followers.length);
+
+    reqWithFollowers.followers.forEach(project_user => {
+       winston.debug("project_user", project_user); 
+        //TODO skip participants from followers
+
+      var userid = project_user.id_user;
+      
+       if (project_user.settings && project_user.settings.email && project_user.settings.email.notification && project_user.settings.email.notification.conversation && project_user.settings.email.notification.conversation.ticket && project_user.settings.email.notification.conversation.ticket.follower == false ) {
+         return winston.verbose("RequestNotification email notification for the user with id " +  userid+ " the follower conversation ticket is disabled");
+       }                  
+        
+         User.findOne({_id: userid , status: 100})
+          //@DISABLED_CACHE .cache(cacheUtil.defaultTTL, "users:id:"+userid)
+          .exec(function (err, user) {
+           if (err) {
+           //  winston.debug(err);
+           }
+           if (!user) {
+            winston.warn("User not found", userid);
+           } else {
+             winston.info("Sending notifyFollowers to user with email: "+ user.email);
+             if (user.emailverified) {
+              emailService.sendFollowerNotification(user.email, message, project);
+              // emailService.sendEmailChannelNotification(user.email, message, project);
+              
+              // emailService.sendNewAssignedAgentMessageEmailNotification(user.email, savedRequest, project, message);
+
+             }else {
+               winston.info("User email not verified", user.email);
+             }
+           }
+         });
+
+         
+       });
+
+
+  }
+}
+
+sendToFollower(projectid, message) {
+  winston.debug("sendToFollower");            
+  var that = this;
+    let savedRequest = message.request;
+      // send email
+      try {
+     
+     
+      Project.findOne({_id: projectid, status: 100}).select("+settings").exec(async function(err, project){
+         if (err) {
+           return winston.error(err);
+         }
+     
+         if (!project) {
+          return winston.warn("Project not found", projectid);
+         } else {
+           
+            winston.debug("project", project);            
+  
+            // if (project.settings && project.settings.email && project.settings.email.notification && project.settings.email.notification.conversation && project.settings.email.notification.conversation.blocked == true ) {
+            //   return winston.verbose("RequestNotification email notification for the project with id : " + projectid + " for all the conversations is blocked");
+            // }
+  
+            winston.debug("savedRequest", savedRequest);
+
+
 
+            // winston.info("savedRequest.followers", savedRequest.followers);
+            // winston.info("savedRequest.followers.length:"+ savedRequest.followers.length);
+            that.notifyFollowers(message.request, project, message);
+
+
+          }
+        })
+    } catch (e) {
+      winston.warn("Error sending email", {error:e, projectid:projectid, message: message, savedRequest:savedRequest}); //it's better to view error email at this stage
+    }
+}
 
 sendToAgentEmailChannelEmail(projectid, message) {
+  var that = this;
     let savedRequest = message.request;
       // send email
       try {
@@ -343,9 +487,17 @@ sendToAgentEmailChannelEmail(projectid, message) {
   
             winston.debug("savedRequest", savedRequest);
 
-  
 
 
+            // winston.info("savedRequest.followers", savedRequest.followers);
+            // winston.info("savedRequest.followers.length:"+ savedRequest.followers.length);
+            that.notifyFollowers(message.request, project, message);
+
+
+  
+    //         UnhandledPromiseRejectionWarning: TypeError: Cannot read property 'status' of undefined
+    // at /Users/andrealeo/dev/chat21/ti
+
                 // TODO fare il controllo anche sul dipartimento con modalità assigned o pooled
                    if (savedRequest.status==RequestConstants.UNASSIGNED) { //POOLED
   
@@ -523,15 +675,19 @@ sendEmailChannelTakingNotification(projectid, request) {
 
 
 sendUserEmail(projectid, message) {
+  winston.debug("sendUserEmail");
+  var that = this;
+
+ 
   try {
 
     if (!message.request) {
       return winston.debug("This is a direct message");
     }
+   
 
-    if (!message.request.lead || !message.request.lead.email) {
-      return winston.debug("The lead object is undefined or has empty email");
-    }
+
+    
 
     Project.findOne({_id: projectid, status: 100}).select("+settings").exec(function(err, project){
       if (err) {
@@ -542,6 +698,28 @@ sendUserEmail(projectid, message) {
        return winston.warn("Project not found", projectid);
       } 
 
+      winston.debug("notifyFollowers");
+      that.notifyFollowers(message.request, project, message);
+
+
+
+      if (process.env.DISABLE_SEND_OFFLINE_EMAIL === "true" || process.env.DISABLE_SEND_OFFLINE_EMAIL === true ) {
+        return winston.debug("DISABLE_SEND_OFFLINE_EMAIL disabled");
+      }
+      if (message.attributes && message.attributes.subtype==='info/support') {
+        return winston.debug("not sending sendUserEmail for attributes.subtype info/support messages");
+      }     
+    
+      if (message.attributes && message.attributes.subtype==='info') {
+        return winston.debug("not sending sendUserEmail for attributes.subtype info messages");
+      }
+
+
+      
+      if (!message.request.lead || !message.request.lead.email) {
+        return winston.debug("The lead object is undefined or has empty email");
+      }
+
       if (project.settings && project.settings.email && project.settings.email.notification && project.settings.email.notification.conversation && project.settings.email.notification.conversation.offline && project.settings.email.notification.conversation.offline.blocked == true ) {
         return winston.info("RequestNotification offline email notification for the project with id : " + projectid + " for  the conversations is blocked");
       }
@@ -550,8 +728,8 @@ sendUserEmail(projectid, message) {
       if (project.settings && project.settings.email && project.settings.email.notification && project.settings.email.notification.conversation && project.settings.email.notification.conversation.offline && project.settings.email.notification.conversation.offline.enabled == false ) {
         return winston.info("RequestNotification offline email notification for the project with id : " + projectid + " for the offline conversation is disabled");
       }
-
-
+      
+      
 
         var recipient = message.request.lead.lead_id;
         winston.debug("recipient:"+ recipient);
@@ -649,7 +827,12 @@ sendAgentEmail(projectid, savedRequest) {
     // send email
     try {
    
-   
+  //  console.log("sendAgentEmail")
+    if (savedRequest.preflight === true) {   //only for channel email and form preflight is false otherwise request.participants.update is used i think?
+      winston.debug("preflight request sendAgentEmail disabled")
+      return 0;
+    }
+
     Project.findOne({_id: projectid, status: 100}).select("+settings").exec( async function(err, project){
        if (err) {
          return winston.error(err);
@@ -670,6 +853,8 @@ sendAgentEmail(projectid, savedRequest) {
               // TODO fare il controllo anche sul dipartimento con modalità assigned o pooled
                  if (savedRequest.status==RequestConstants.UNASSIGNED) { //POOLED
 
+                  winston.debug("savedRequest.status==RequestConstants.UNASSIGNED");        
+
                   if (project.settings && project.settings.email && project.settings.email.notification && project.settings.email.notification.conversation && project.settings.email.notification.conversation.pooled == false ) {
                     return winston.info("RequestNotification email notification for the project with id : " + projectid + " for the pooled conversation is disabled");
                   }
@@ -678,7 +863,7 @@ sendAgentEmail(projectid, savedRequest) {
                   }
 
 
-
+                 
                   var snapshotAgents = savedRequest; //riassegno varibile cosi nn cambio righe successive
 
                   
@@ -742,6 +927,8 @@ sendAgentEmail(projectid, savedRequest) {
                    // TODO fare il controllo anche sul dipartimento con modalità assigned o pooled
                    else if (savedRequest.status==RequestConstants.ASSIGNED) { //ASSIGNED
 
+                    winston.debug("savedRequest.status==RequestConstants.ASSIGNED");        
+
                     if (project.settings && project.settings.email && project.settings.email.notification && project.settings.email.notification.conversation && project.settings.email.notification.conversation.assigned == false ) {
                       return winston.verbose("RequestNotification email notification for the project with id : " + projectid + " for the assigned conversation is disabled");
                     }