@tiledesk/tiledesk-server 2.3.6 → 2.3.7-1.2

package/routes/faqpub.js

@@ -27,6 +27,11 @@ router.get('/', function (req, res, next) {
 
   // query.$text = {"$search": "question"};
 
+  // TODO ORDER BY SCORE
+  // return Faq.find(query,  {score: { $meta: "textScore" } }) 
+  // .sort( { score: { $meta: "textScore" } } ) //https://docs.mongodb.com/manual/reference/operator/query/text/#sort-by-text-search-score
+
+  
   return Faq.find(query).
     populate({path:'faq_kb'}).//, match: { trashed: { $in: [null, false] } }}).
     exec(function (err, faq) {

package/routes/lead.js

@@ -88,11 +88,67 @@ router.put('/:leadid', function (req, res) {
     if (req.body.email!=undefined) {
       leadEvent.emit('lead.email.update', updatedLead);
     }
+
+    if (req.body.email!=undefined || req.body.fullname!=undefined) {
+      leadEvent.emit('lead.fullname.email.update', updatedLead);
+    }
   
     res.json(updatedLead);
   });
 });
 
+
+
+router.patch('/:leadid/attributes',  function (req, res) {
+  var data = req.body;
+
+  // TODO use service method
+
+  Lead.findById(req.params.leadid, function (err, lead) {
+    if (err) {
+      winston.error('--- > ERROR ', err);
+      return res.status(500).send({ success: false, msg: 'Error updating object.' });
+    }
+
+     if (!lead) {
+        return res.status(404).send({ success: false, msg: 'Object not found.' });
+      }
+      
+      if (!lead.attributes) {
+        winston.debug("empty attributes")
+        lead.attributes = {};
+      }
+
+      winston.debug(" lead attributes", lead.attributes)
+        
+        Object.keys(data).forEach(function(key) {
+          var val = data[key];
+          winston.debug("data attributes "+key+" " +val)
+          lead.attributes[key] = val;
+        });     
+        
+        winston.debug(" lead attributes", lead.attributes)
+
+        // https://stackoverflow.com/questions/24054552/mongoose-not-saving-nested-object
+        lead.markModified('attributes');
+
+          //cacheinvalidation
+          lead.save(function (err, savedLead) {
+          if (err) {
+            winston.error("error saving lead attributes",err)
+            return res.status(500).send({ success: false, msg: 'Error getting object.' });
+          }
+          winston.verbose(" saved lead attributes",savedLead.toObject())
+          leadEvent.emit('lead.update', savedLead);
+
+            res.json(savedLead);
+        });
+  });
+  
+});
+
+
+
 // router.put('/:leadid', function (req, res) {
 //   winston.debug(req.body);
 //   var update = {};

package/routes/message.js

@@ -13,12 +13,15 @@ var leadService = require('../services/leadService');
 var winston = require('../config/winston');
 
 var MessageConstants = require("../models/messageConstants");
+
 var cacheUtil = require('../utils/cacheUtil');
+var cacheEnabler = require("../services/cacheEnabler");
 
 const { check, validationResult } = require('express-validator');
 
 var Project_user = require("../models/project_user");
 var mongoose = require('mongoose');
+var PromiseUtil = require("../utils/promiseUtil");
 
 csv = require('csv-express');
 csv.separator = ';';
@@ -46,12 +49,20 @@ async (req, res)  => {
   winston.debug('req.params: ', req.params);
   winston.debug('req.params.request_id: ' + req.params.request_id);
 
-  const errors = validationResult(req);
-  if (!errors.isEmpty()) {
-    return res.status(422).json({ errors: errors.array() });
-  }
+  // sponz: 4/01/23 disable it
+  // if (!req.body.text &&  (!req.body.type || req.body.type=="text") ) {
+  //   return res.status(422).json({ errors: ["text field is required"] });
+  // } 
+  // const errors = validationResult(req);
+  // if (!errors.isEmpty()) {
+  //   return res.status(422).json({ errors: errors.array() });
+  // }
+
+
+
   
- 
+  // TODO se sei agent non puoi cambiare sender
+  // verificare validazione invio immagine senza caption 
   var project_user = req.projectuser;
   var sender = req.body.sender;
   var fullname = req.body.senderFullname || req.user.fullName;
@@ -60,15 +71,19 @@ async (req, res)  => {
   let messageStatus = req.body.status || MessageConstants.CHAT_MESSAGE_STATUS.SENDING;
   winston.debug('messageStatus: ' + messageStatus);
 
+      let q = Request.findOne({request_id: req.params.request_id, id_project: req.projectid}); 
+      if (cacheEnabler.request) {
+        q.cache(cacheUtil.defaultTTL, req.projectid+":requests:request_id:"+req.params.request_id+":simple") //request_cache
+        winston.debug('request cache enabled');
+      }
       // cacherequest       // requestcachefarequi nocachepopulatereqired
-      return Request.findOne({request_id: req.params.request_id, id_project: req.projectid})
+      return q.exec(async(err, request) => {
         // .populate('lead')
         // .populate('department')
         // .populate('participatingBots')
         // .populate('participatingAgents')  
         // .populate({path:'requester',populate:{path:'id_user'}})
-       //@DISABLED_CACHE  .cache(cacheUtil.defaultTTL, req.projectid+":requests:request_id:"+req.params.request_id)
-        .exec(async(err, request) => {
+        
 
         if (err) {
           winston.log({
@@ -236,7 +251,7 @@ async (req, res)  => {
                      
                     if (request.participants && request.participants.indexOf(sender) > -1) { //update waiitng time if write an  agent (member of participants)
                       winston.debug("updateWaitingTimeByRequestId");
-                      return requestService.updateWaitingTimeByRequestId(request.request_id, request.id_project).then(function(upRequest) {
+                      return requestService.updateWaitingTimeByRequestId(request.request_id, request.id_project, true).then(function(upRequest) {
                           let message = savedMessage.toJSON();
                           message.request = upRequest;
 
@@ -246,13 +261,26 @@ async (req, res)  => {
                     }else {
                       let message = savedMessage.toJSON();
 
-                      request.populate('lead')
+                      winston.debug("getting request for response");
+
+                      let q =
+                      Request.findOne({request_id:  request.request_id, id_project: request.id_project})
+                      // request
+                      .populate('lead')
                       .populate('department')
                       .populate('participatingBots')
                       .populate('participatingAgents')  
                       // .populate('followers')  
-                      .populate({path:'requester',populate:{path:'id_user'}})
-                      .execPopulate(function (err, requestPopulated){    
+                      .populate({path:'requester',populate:{path:'id_user'}});
+
+
+                      if (cacheEnabler.request) {
+                        q.cache(cacheUtil.defaultTTL, request.id_project+":requests:request_id:"+request.request_id)
+                        winston.debug('request cache enabled for messages');
+                      }
+
+                      q.exec(function (err, requestPopulated){    
+                        // q.execPopulate(function (err, requestPopulated){    
 
                         if (err) {
                           return winston.error("Error gettting savedRequestPopulated for send Message", err);
@@ -268,10 +296,10 @@ async (req, res)  => {
                 }).catch(function(err){
                   winston.log({
                     level: 'error',
-                    message: 'Error creating message: '+ JSON.stringify(err) + " " + JSON.stringify(req.body) ,
+                    message: 'Error creating message endpoint: '+ JSON.stringify(err) + " " + JSON.stringify(req.body) ,
                     label: req.projectid
                   });
-                  // winston.error("Error creating message", err);
+                  winston.error("Error creating message", err);
                   return res.status(500).send({success: false, msg: 'Error creating message', err:err });
                 });
 
@@ -290,6 +318,160 @@ async (req, res)  => {
 
 
 
+
+
+
+// router.post('/multi2', async (req, res, next)  => {
+
+//       if ( !req.body instanceof Array ) {
+//               return res.status(422).json({ errors: ["request body is not array"] });
+//       }
+//           req.url =  '/';
+//           winston.info('--- > req.url'+req.url);
+
+//           req.method = 'POST';  
+
+//           let promises = [];
+
+//           req.body.forEach(function(message,index) {
+//             promises.push(router.handle(req, res, next));
+//           });
+//           winston.info('--- >promises', promises);
+
+//           Promise.all(promises).then((values) => {
+//             console.log("finito",values);
+//             return res.status(200).json({ "success": true });
+//           }).catch((err) => {
+//             console.log("errore",err);
+//           });
+// });
+
+
+
+
+router.post('/multi', 
+async (req, res)  => {
+
+  winston.debug('req.body post message', req.body);
+  winston.debug('req.params: ', req.params);
+  winston.debug('req.params.request_id: ' + req.params.request_id);
+
+  const errors = validationResult(req);
+  if (!errors.isEmpty()) {
+    return res.status(422).json({ errors: errors.array() });
+  }
+  
+  var project_user = req.projectuser;
+
+  let q = Request.findOne({request_id: req.params.request_id, id_project: req.projectid}); 
+  // if (cacheEnabler.request) {
+  //   q.cache(cacheUtil.defaultTTL, req.projectid+":requests:request_id:"+req.params.request_id+":simple") //request_cache
+  //   winston.debug('request cache enabled');
+  // }
+  return q.exec(async(err, request) => {
+    
+
+    if (err) {
+      winston.log({
+          level: 'error',
+          message: 'Error getting the request: '+ JSON.stringify(err) + " " + JSON.stringify(req.body) ,
+          label: req.projectid
+        });
+      // winston.error('Error getting the request.', err);
+      return res.status(500).send({success: false, msg: 'Error getting the request.', err:err});
+    }
+
+    if (!request) { //the request doen't exists create it
+      return res.status(404).send({success: false, msg: 'Request doesn\'t exist.', err:err});
+    } else {
+
+  
+
+      winston.debug("request  exists", request.toObject());
+  
+      
+      let promises = [];
+
+      let sender;
+      let fullname;
+      let email;
+      let text;
+      let attributes;
+      let type;
+      let metadata;
+      let language;
+      let channel;
+      let messageStatus;
+      
+      req.body.forEach(function(message,index) {
+
+        sender = message.sender;
+        fullname = message.senderFullname || req.user.fullName;
+        email = message.email || req.user.email;
+
+        text = message.text;
+        attributes = message.attributes;
+        type = message.type;
+        metadata = message.metadata;
+        language = message.language;
+        channel = message.channel;
+        messageStatus = message.status || MessageConstants.CHAT_MESSAGE_STATUS.SENDING;
+            // create(sender, senderFullname, recipient, text, id_project, createdBy, status, attributes, type, metadata, language, channel_type, channel) {                 
+        let promise =  messageService.create(sender || req.user._id, fullname, req.params.request_id, text,
+                request.id_project, null, messageStatus, attributes, type, metadata, language, undefined, channel);
+
+          promises.push(promise);
+      });
+      winston.debug('--- >promises', promises);
+
+      //Promise.all(promises).then((values) => {
+      PromiseUtil.doAllSequentually(promises).then((values) => {
+        winston.info('Inserted multiple messages with values: ', values);
+        return res.status(200).json(values);
+      }).catch((err) => {
+        winston.error('Error inserting multiple messages.', err);
+        return res.status(500).send({success: false, msg: 'Error inserting multiple messages.', err:err});
+
+      });
+
+      
+
+
+
+
+    }
+  
+
+
+  });
+
+
+
+
+});
+
+
+
+
+
+
+
+
+
+
+// router.patch('/:messageid', function(req, res) {
+  
+//   winston.info(req.body);
+  
+//   Message.findByIdAndUpdate(req.params.messageid, req.body, {new: true, upsert:true}, function(err, updatedMessage) {
+//     if (err) {
+//       return res.status(500).send({success: false, msg: 'Error updating object.'});
+//     }
+//     res.json(updatedMessage);
+//   });
+// });
+
+
 // router.put('/:messageid', function(req, res) {
   
 //     console.log(req.body);

package/routes/messagesRoot.js

@@ -5,6 +5,7 @@ var router = express.Router({mergeParams: true});
 
 var MessageConstants = require("../models/messageConstants");
 var Message = require("../models/message");
+var Request = require("../models/request");
 var messageService = require("../services/messageService");
 var winston = require('../config/winston');
 var fastCsv = require("fast-csv");
@@ -65,6 +66,44 @@ router.post('/',
 
 
 
+router.get('/',roleChecker.hasRoleOrTypes('owner'), function(req, res) {
+
+  const DEFAULT_LIMIT = 10;
+
+  var limit = DEFAULT_LIMIT; // Number of rows per page
+
+  // console.log("req.query.populate_request",req.query.populate_request);
+  if (req.query.limit) {
+    limit = parseInt(req.query.limit);
+  }
+  if (limit > 50) {
+    limit = DEFAULT_LIMIT;
+  }
+
+
+  var page = 0;
+
+  if (req.query.page) {
+    page = req.query.page;
+  }
+
+  var skip = page * limit;
+
+  return Message.find({id_project: req.projectid}).sort({createdAt: 'desc'}).
+    skip(skip).limit(limit).lean().exec(async (err, messages) => { 
+      if (err) return next(err);
+
+      if (req.query.populate_request) {  
+        // console.log("pupulate")
+        for (var i = 0; i < messages.length; i++) {
+          messages[i].request = await Request.findOne({request_id:messages[i].recipient, id_project: messages[i].id_project }).exec();
+        }
+      }
+
+      res.json(messages);
+    });
+});
+
 router.get('/csv', roleChecker.hasRoleOrTypes('owner'), function(req, res) {
 
 

package/routes/project.js

@@ -18,7 +18,7 @@ var validtoken = require('../middleware/valid-token')
 var RoleConstants = require("../models/roleConstants");
 var cacheUtil = require('../utils/cacheUtil');
 var orgUtil = require("../utils/orgUtil");
-
+var cacheEnabler = require("../services/cacheEnabler");
 
 router.post('/', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken], async (req, res) => {
   
@@ -213,6 +213,22 @@ router.put('/:projectid', [passport.authenticate(['basic', 'jwt'], { session: fa
     update.ipFilter = req.body.ipFilter;
   }
 
+  if (req.body.ipFilterDenyEnabled!=undefined) {
+    update.ipFilterDenyEnabled = req.body.ipFilterDenyEnabled;
+  }
+
+  if (req.body.ipFilterDeny!=undefined) {
+    update.ipFilterDeny = req.body.ipFilterDeny;
+  }
+
+  if (req.body.bannedUsers!=undefined) {
+    update.bannedUsers = req.body.bannedUsers;
+  }
+
+  
+
+  
+  
   
   // if (req.body.defaultLanguage!=undefined) {
   //   update.defaultLanguage = req.body.defaultLanguage; 
@@ -360,6 +376,19 @@ router.patch('/:projectid', [passport.authenticate(['basic', 'jwt'], { session:
   if (req.body.ipFilter!=undefined) {
     update.ipFilter = req.body.ipFilter;
   }
+
+  if (req.body.ipFilterDenyEnabled!=undefined) {
+    update.ipFilterDenyEnabled = req.body.ipFilterDenyEnabled;
+  }
+
+  if (req.body.ipFilterDeny!=undefined) {
+    update.ipFilterDeny = req.body.ipFilterDeny;
+  }
+
+  if (req.body.bannedUsers!=undefined) {
+    update.bannedUsers = req.body.bannedUsers;
+  }
+  
     
   // if (req.body.defaultLanguage!=undefined) {
   //   update.defaultLanguage = req.body.defaultLanguage; 
@@ -378,12 +407,55 @@ router.patch('/:projectid', [passport.authenticate(['basic', 'jwt'], { session:
   });
 });
 
+
+router.post('/:projectid/ban', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], function (req, res) {
+  winston.debug('PATCH PROJECT REQ BODY ', req.body);
+
+  var ban = {};
+  ban.id = req.body.id;
+  ban.ip = req.body.ip;
+
+  Project.findByIdAndUpdate(req.params.projectid, { $push: { bannedUsers: ban } }, { new: true, upsert: false }, function (err, updatedProject) {
+    if (err) {
+      winston.error('Error putting project ', err);
+      return res.status(500).send({ success: false, msg: 'Error patching object.' });
+    }
+    projectEvent.emit('project.update', updatedProject );
+    projectEvent.emit('project.update.user.ban', {banInfo: ban, project: updatedProject });
+    res.json(updatedProject);
+  });
+
+});
+router.delete('/:projectid/ban/:banid', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], function (req, res) {
+  
+  // winston.info('quiiiiii');
+  //cacheinvalidation
+
+  
+  // devi prendere id utente prima di eliminarlo
+Project.findByIdAndUpdate(req.params.projectid, { $pull: { bannedUsers: { "_id": req.params.banid }}}, { new: true, upsert: false }, function (err, updatedProject) {
+  if (err) {
+    winston.error('Error putting project ', err);
+    return res.status(500).send({ success: false, msg: 'Error patching object.' });
+  }
+  projectEvent.emit('project.update', updatedProject );
+  projectEvent.emit('project.update.user.unban', {banInfo: req.params.banid, project: updatedProject});
+  res.json(updatedProject);
+});
+
+});
+
+
+
 //roleChecker.hasRole('agent') works because req.params.projectid is valid using :projectid of this method
 router.get('/:projectid', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('agent', ['subscription'])], function (req, res) {
   winston.debug(req.body);
-  Project.findOne({_id: req.params.projectid, status:100})
-  //@DISABLED_CACHE .cache(cacheUtil.defaultTTL, "projects:id:"+req.params.projectid)
-  .exec(function (err, project) {
+  let q = Project.findOne({_id: req.params.projectid, status:100});
+  if (cacheEnabler.project) { 
+    q.cache(cacheUtil.longTTL, "projects:id:"+req.params.projectid)  //project_cache
+    winston.debug('project cache enabled');
+  }
+  q.exec(function (err, project) {
     if (err) {
       winston.error('Error getting project ', err);
       return res.status(500).send({ success: false, msg: 'Error getting object.' });

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;
   }
@@ -366,7 +375,8 @@ router.get('/:project_userid', [passport.authenticate(['basic', 'jwt'], { sessio
 });
 
 
-router.get('/users/search', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('agent', ['subscription'])], async (req, res, next) => {
+router.get('/users/search', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('user', ['subscription'])], async (req, res, next) => { //changed for smtp 
+  // router.get('/users/search', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('agent', ['subscription'])], async (req, res, next) => {
   winston.debug("--> users search  ");
 
   if (!req.project) {

package/routes/project_user_test.js

@@ -0,0 +1,19 @@
+var express = require('express');
+var router = express.Router({mergeParams: true});
+
+var passport = require('passport');
+require('../middleware/passport')(passport);
+var validtoken = require('../middleware/valid-token')
+var roleChecker = require('../middleware/has-role');
+
+
+
+router.get('/test', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('agent', ['subscription'])], function (req, res) {
+      // console.log("req.projectuser",req.projectuser);      
+      res.json(req.projectuser);
+
+});
+
+
+
+module.exports = router;