@tiledesk/tiledesk-server 2.3.1 → 2.3.2

package/services/requestService.js

@@ -21,6 +21,7 @@ class RequestService {
 
   listen() {
     this.updateSnapshotLead();
+    this.sendMessageUpdateLead();
   }
   updateSnapshotLead() {
     leadEvent.on('lead.update', function(lead) {
@@ -58,6 +59,62 @@ class RequestService {
           });
         });
   }
+
+
+  sendMessageUpdateLead() {
+    leadEvent.on('lead.fullname.update', function(lead) {
+      // leadEvent.on('lead.update', function(lead) {
+      
+      setImmediate(() => {
+          winston.debug("sendMessageUpdateLead on lead.update ",  lead);
+          
+          Request.find({lead: lead._id, id_project: lead.id_project}, function(err, requests) {
+
+            if (err) {
+                winston.error("Error getting sendMessageUpdateLead request by lead", err);
+                return 0;
+            }
+            if (!requests || (requests && requests.length==0)) {
+                winston.warn("sendMessageUpdateLead No request found for lead id " +lead._id );
+                return 0;
+            }
+            
+            // winston.info("sendMessageUpdateLead requests ", requests);
+
+            requests.forEach(function(request) {
+
+              winston.debug("sendMessageUpdateLead request ", request);
+
+              // send(sender, senderFullname, recipient, text, id_project, createdBy, attributes, type, metadata, language)
+              messageService.send(
+                  'system', 
+                  'Bot',     
+                  // lead.fullname,                                
+                  request.request_id,
+                  "Lead updated", 
+                  request.id_project,
+                  'system', 
+                  { 
+                    subtype:"info/support",
+                    "updateconversation" : false, 
+                    messagelabel: {key: "LEAD_UPDATED"},
+                    updateUserEmail: lead.email,
+                    updateUserFullname: lead.fullname
+                  },
+                  undefined,
+                  request.language
+
+              ); 
+
+            });
+
+          });          
+         
+        });
+    });
+  }
+
+
   getAvailableAgentsCount(agents) {
      
       var project_users_available = agents.filter(function (projectUser) {
@@ -142,6 +199,7 @@ class RequestService {
             request.snapshot = {}
           }
 
+          
           request.snapshot.department = result.department;
           request.snapshot.agents = result.agents;
           request.snapshot.availableAgentsCount = that.getAvailableAgentsCount(result.agents);
@@ -400,6 +458,10 @@ class RequestService {
     var notes = request.notes;
     var priority = request.priority;
 
+    var auto_close = request.auto_close;
+
+    var followers = request.followers;
+
     if (!departmentid) {
       departmentid ='default';
     }
@@ -421,7 +483,7 @@ class RequestService {
           first_text:first_text, departmentid:departmentid, sourcePage:sourcePage, language:language, userAgent:userAgent, status:status, 
           createdBy:createdBy, attributes:attributes, subject:subject, preflight: preflight, channel: channel, location: location,
           participants:participants, tags: tags, notes:notes,
-          priority: priority}};
+          priority: priority, auto_close: auto_close, followers: followers}};
 
           winston.debug("context",context);
 
@@ -505,6 +567,7 @@ class RequestService {
             snapshot.department = result.department;
           }
           
+          // console.log("result.agents",result.agents);
           snapshot.agents = agents;
           snapshot.availableAgentsCount = that.getAvailableAgentsCount(agents);
 
@@ -549,7 +612,9 @@ class RequestService {
                 snapshot: snapshot,
                 tags: tags,
                 notes: notes,
-                priority: priority
+                priority: priority,
+                auto_close: auto_close,
+                followers: followers
               });
                     
 
@@ -842,14 +907,14 @@ class RequestService {
 
   }
 
-  setClosedAtByRequestId(request_id, id_project, closed_at) {
+  setClosedAtByRequestId(request_id, id_project, closed_at, closed_by) {
 
     return new Promise(function (resolve, reject) {
      // winston.debug("request_id", request_id);
      // winston.debug("newstatus", newstatus);
 
         return Request        
-        .findOneAndUpdate({request_id: request_id, id_project: id_project}, {closed_at: closed_at}, {new: true, upsert:false})
+        .findOneAndUpdate({request_id: request_id, id_project: id_project}, {closed_at: closed_at, closed_by: closed_by}, {new: true, upsert:false})
         .populate('lead')
         .populate('department')
         .populate('participatingBots')
@@ -934,7 +999,7 @@ class RequestService {
   }
 
 
-  closeRequestByRequestId(request_id, id_project, skipStatsUpdate, notify) {
+  closeRequestByRequestId(request_id, id_project, skipStatsUpdate, notify, closed_by) {
 
     var that = this;
     return new Promise(function (resolve, reject) {
@@ -991,7 +1056,8 @@ class RequestService {
                   return resolve(updatedRequest);
                 }
                 
-                return that.setClosedAtByRequestId(request_id, id_project, new Date().getTime()).then(function(updatedRequest) {
+                // setClosedAtByRequestId(request_id, id_project, closed_at, closed_by)
+                return that.setClosedAtByRequestId(request_id, id_project, new Date().getTime(), closed_by).then(function(updatedRequest) {
                   
                     winston.verbose("Request closed with id: " + updatedRequest.id);
                     winston.debug("Request closed ", updatedRequest);
@@ -1728,6 +1794,298 @@ class RequestService {
 
 
 
+
+
+
+
+  addFollowerByRequestId(request_id, id_project, member) {
+    winston.debug("request_id: " + request_id);
+    winston.debug("id_project: " + id_project);
+    winston.debug("addFollowerByRequestId member: " + member);
+
+ 
+
+//TODO control if member is a valid project_user of the project
+// validate member is string
+    return new Promise(function (resolve, reject) {
+
+      if (member==undefined) {
+        var err = "addFollowerByRequestId error, member field is null";
+        winston.error(err);
+        return reject(err);
+      }
+
+      return Request       
+      .findOne({request_id: request_id, id_project: id_project})     
+      // qui cache         
+      .exec( function(err, request) {
+        if (err){
+          winston.error("Error adding follower ", err);
+          return reject(err);
+        }
+        if (!request) {
+          winston.error('Request not found for request_id '+ request_id + ' and id_project '+ id_project);
+          return reject('Request not found for request_id '+ request_id + ' and id_project '+ id_project);
+        }
+
+        winston.debug("assigned_operator here1");
+
+      // return Request.findById(id).then(function (request) {
+        if (request.followers.indexOf(member)==-1){
+          request.followers.push(member);
+
+          request.save(function(err, savedRequest) {
+            if (err) {
+              winston.error(err);
+              return reject(err);
+            }
+
+            winston.debug("saved", savedRequest);
+
+            return savedRequest
+            .populate('lead')
+            .populate('department')
+            .populate('participatingBots')
+            .populate('participatingAgents') 
+            // .populate('followers')  
+            .populate({path:'requester',populate:{path:'id_user'}})
+            .execPopulate( function(err, requestComplete) {
+
+              if (err) {
+                winston.error("Error getting addFollowerByRequestId", err);
+                return reject(err);
+              }
+
+
+              winston.debug("populated", requestComplete);
+           
+              requestEvent.emit('request.update', requestComplete);
+              requestEvent.emit("request.update.comment", {comment:"FOLLOWER_ADD",request:requestComplete});//Deprecated
+              requestEvent.emit("request.updated", {comment:"FOLLOWER_ADD",request:requestComplete, patch:  {member:member}});
+              requestEvent.emit('request.followers.join', {member:member, request: requestComplete});
+                       
+              return resolve(requestComplete);
+          });
+        });
+          // qui assignetat
+        } else {
+          winston.debug('Request member '+ member+ ' already added for request_id '+ request_id + ' and id_project '+ id_project);
+          return request
+          .populate('lead')
+          .populate('department')
+          .populate('participatingBots')
+          .populate('participatingAgents')  
+          // .populate('followers')  
+          .populate({path:'requester',populate:{path:'id_user'}})
+          .execPopulate( function(err, requestComplete) {
+            return resolve(requestComplete);
+          });
+        }
+                       
+      });
+   });
+  }
+
+
+
+
+
+  setFollowersByRequestId(request_id, id_project, newfollowers) {
+    
+    //TODO validate participants
+    // validate if array of string newparticipants
+    return new Promise(function (resolve, reject) {
+      
+      var isArray = Array.isArray(newfollowers);
+
+      if(isArray==false) {
+        winston.error('setFollowersByRequestId error  newfollowers is not an array for request_id '+ request_id + ' and id_project '+ id_project);
+        return reject('setFollowersByRequestId error  newfollowers is not an array for request_id '+ request_id + ' and id_project '+ id_project);
+      }
+
+      return Request
+       
+      .findOne({request_id: request_id, id_project: id_project})     
+      // qui cache ok
+      .exec( function(err, request) {
+        if (err) {
+          winston.error("Error setFollowersByRequestId", err);
+          return reject(err);
+        }       
+        if (!request) {
+          winston.error('Request not found for request_id '+ request_id + ' and id_project '+ id_project);
+          return reject('Request not found for request_id '+ request_id + ' and id_project '+ id_project);
+        }
+        var oldfollowers = request.followers;
+        winston.debug('oldParticipants', oldfollowers);
+        winston.debug('newparticipants', newfollowers);
+        
+        if (requestUtil.arraysEqual(oldfollowers, newfollowers)){
+        //if (oldParticipants === newparticipants) {
+          winston.verbose('Request members '+ oldfollowers+ ' already equal to ' + newfollowers + ' for request_id '+ request_id + ' and id_project '+ id_project);
+          return request
+          .populate('lead')
+          .populate('department')
+          .populate('participatingBots')
+          .populate('participatingAgents')  
+          .populate({path:'requester',populate:{path:'id_user'}})
+          .execPopulate( function(err, requestComplete) {
+            return resolve(requestComplete);
+          });
+
+        }
+
+        request.followers = newfollowers;
+
+          //cacheinvalidation
+        return request.save(function(err, updatedRequest) {
+          // dopo save non aggiorna participating
+          if (err) {
+            winston.error("Error setFollowersByRequestId", err);
+            return reject(err);
+          }
+        
+         return updatedRequest
+          .populate('lead')
+          .populate('department')
+          .populate('participatingBots')
+          .populate('participatingAgents')  
+          .populate({path:'requester',populate:{path:'id_user'}})
+          .execPopulate( function(err, requestComplete) {
+
+
+            if (err) {
+              winston.error("Error getting setFollowersByRequestId", err);
+              return reject(err);
+            }
+
+            winston.debug("oldfollowers ", oldfollowers);
+
+            requestEvent.emit('request.update', requestComplete);
+            requestEvent.emit("request.update.comment", {comment:"FOLLOWERS_SET",request:requestComplete});//Deprecated
+            requestEvent.emit("request.updated", {comment:"FOLLOWERS_SET",request:requestComplete, patch:  {}});            
+
+            // requestEvent.emit('request.followers.update', {beforeRequest:request, 
+            //             removedParticipants:removedParticipants, 
+            //             addedParticipants:addedParticipants,
+            //             request:requestComplete});
+
+            return resolve(requestComplete);
+           });
+        });
+       
+      });
+
+
+    });
+  }
+
+
+
+
+
+
+  removeFollowerByRequestId(request_id, id_project, member) {
+    winston.debug("request_id", request_id);
+    winston.debug("id_project", id_project);
+    winston.debug("member", member);
+
+    return new Promise(function (resolve, reject)  {
+
+
+
+      if (member==undefined) {
+        var err = "removeFollowerByRequestId error, member field is null";
+        winston.error(err);
+        return reject(err);
+      }
+
+    
+      return Request        
+        .findOne({request_id: request_id, id_project: id_project})
+        // .populate('participatingAgents')  //for abandoned_by_project_users
+        // qui cache    
+        .exec( async (err, request) => {
+        
+        if (err){
+          winston.error("Error removing follower ", err);
+          return reject(err);
+        }
+
+        if (!request) {
+          winston.error('Request not found for request_id '+ request_id + ' and id_project '+ id_project);
+          return reject('Request not found for request_id '+ request_id + ' and id_project '+ id_project);
+        }
+
+        var index = request.followers.indexOf(member);
+        winston.debug("index", index);
+
+        if (index > -1) {
+          request.followers.splice(index, 1);
+          // winston.debug(" request.participants",  request.participants);
+         
+
+          // winston.debug(" request",  request);
+         //cacheinvalidation
+         return request.save(function(err, savedRequest) {
+            if (err){
+              winston.error("Error saving removed follower ", err);
+              return reject(err);
+            }
+            
+            return savedRequest
+            .populate('lead')
+            .populate('department')
+            .populate('participatingBots')
+            .populate('participatingAgents')  
+            // .populate('followers')  
+            .populate({path:'requester',populate:{path:'id_user'}})
+            .execPopulate( function(err, requestComplete) {
+
+            if (err){
+              winston.error("Error getting removed follower ", err);
+              return reject(err);
+            }
+
+            
+            requestEvent.emit('request.update', requestComplete);
+            requestEvent.emit("request.update.comment", {comment:"FOLLOWER_REMOVE",request:requestComplete});//Deprecated
+            requestEvent.emit("request.updated", {comment:"FOLLOWER_REMOVE",request:requestComplete, patch:  {member:member}});
+            requestEvent.emit('request.followers.leave', {member:member, request: requestComplete});
+            
+
+            return resolve(requestComplete);
+
+          });
+        });
+
+
+        }else {
+          winston.verbose('Request member '+ member+ ' already not found for request_id '+ request_id + ' and id_project '+ id_project);
+
+          return request
+          .populate('lead')
+          .populate('department')
+          .populate('participatingBots')
+          .populate('participatingAgents') 
+          // .populate('followers')   
+          .populate({path:'requester',populate:{path:'id_user'}})
+          .execPopulate( function(err, requestComplete) {
+            return resolve(requestComplete);
+          });
+        }
+                          
+      });
+    });
+  }
+
+
+
+
+
+
+
+
 }
 
 

package/test/messageRoute.js

@@ -720,6 +720,75 @@ it('createWithPriority', function (done) {
 
 
 
+
+// mocha test/messageRoute.js  --grep 'createSimpleWithFollowers'
+
+it('createSimpleWithFollowers', function (done) {
+  // this.timeout(10000);
+
+  var email = "test-message-create-" + Date.now() + "@email.com";
+  var pwd = "pwd";
+
+  userService.signup( email ,pwd, "Test Firstname", "Test lastname").then(function(savedUser) {
+   projectService.createAndReturnProjectAndProjectUser("message-create", savedUser._id).then(function(savedProjectAndPU) {
+   
+    var savedProject = savedProjectAndPU.project;
+
+        chai.request(server)
+          .post('/'+ savedProject._id + '/requests/req123-createSimpleWithFollowers/messages')
+          .auth(email, pwd)
+          .set('content-type', 'application/json')
+          .send({"text":"text", "followers": [savedProjectAndPU.project_user._id.toString()]})
+          .end(function(err, res) {
+              //console.log("res",  res);
+              console.log("res.body",  JSON.stringify(res.body));
+              res.should.have.status(200);
+              res.body.should.be.a('object');                          
+
+              expect(res.body.sender).to.equal(savedUser._id.toString());
+              // expect(res.body.sender).to.equal(savedProjectAndPU.project_user._id.toString());
+              // expect(res.body.senderFullname).to.equal("senderFullname");
+              expect(res.body.recipient).to.equal("req123-createSimpleWithFollowers");
+              expect(res.body.text).to.equal("text");
+              expect(res.body.id_project).to.equal(savedProject._id.toString());
+              expect(res.body.createdBy).to.equal(savedUser._id.toString());
+              expect(res.body.status).to.equal(0);
+
+              expect(res.body.request.request_id).to.equal("req123-createSimpleWithFollowers");
+              expect(res.body.request.requester._id).to.equal(savedProjectAndPU.project_user._id.toString());
+              // expect(res.body.request.requester_id).to.equal("sender");
+              expect(res.body.request.first_text).to.equal("text");
+              expect(res.body.request.id_project).to.equal(savedProject._id.toString());
+              expect(res.body.request.createdBy).to.equal(savedUser._id.toString());
+
+              // expect(res.body.request.messages_count).to.equal(1);
+
+              expect(res.body.request.status).to.equal(200);                                
+              expect(res.body.request.snapshot.agents.length).to.equal(1);
+              expect(res.body.request.participants.length).to.equal(1);
+              expect(res.body.request.department).to.not.equal(null);
+              expect(res.body.request.lead).to.not.equal(null);               
+                          
+              expect(res.body.channel_type).to.equal("group");
+              expect(res.body.channel.name).to.equal("chat21");
+              expect(res.body.request.channel.name).to.equal("chat21");
+
+
+              expect(res.body.request.location).to.equal(undefined);
+
+              expect(res.body.request.followers[0]).to.equal(savedProjectAndPU.project_user._id.toString());
+             
+        
+             done();
+          });
+  });
+});
+});
+
+
+
+
+
 it('getall', function (done) {
   // this.timeout(10000);
 

package/test/requestService.js

@@ -686,13 +686,15 @@ describe('RequestService', function () {
             savedProject._id, "5badfe5d553d1844ad654072"),
             messageService.create("5badfe5d553d1844ad654072", "test sender", savedRequest.request_id, "hello2",
             savedProject._id, "5badfe5d553d1844ad654072")]).then(function(all) {
-              requestService.closeRequestByRequestId(savedRequest.request_id, savedProject._id).then(function(closedRequest) {
+              // closeRequestByRequestId(request_id, id_project, skipStatsUpdate, notify, closed_by)
+              requestService.closeRequestByRequestId(savedRequest.request_id, savedProject._id, false, true, "user1").then(function(closedRequest) {
                     winston.debug("resolve closedRequest", closedRequest.toObject());
                     expect(closedRequest.status).to.equal(1000);
                     expect(closedRequest.closed_at).to.not.equal(null);
                     expect(closedRequest.transcript).to.contains("hello1");
                     expect(closedRequest.transcript).to.contains("hello2");
                     expect(closedRequest.snapshot.agents).to.equal(undefined);
+                    expect(closedRequest.closed_by).to.equal("user1");
 
                     done();                         
                   }).catch(function(err){

package/models/subscriptionEvent.js

@@ -1,11 +0,0 @@
-const EventEmitter = require('events');
-
-class SubscriptionEvent extends EventEmitter {}
-var winston = require('../config/winston');
-
-
-const subscriptionEvent = new SubscriptionEvent();
-
-
-
-module.exports = subscriptionEvent;