@tiledesk/tiledesk-server 2.17.4 → 2.18.3

package/routes/message.js

@@ -268,7 +268,10 @@ async (req, res)  => {
 
           // TOOD update also request attributes and sourcePage
           // return requestService.incrementMessagesCountByRequestId(request.request_id, request.id_project).then(function(savedRequest) {
-          // console.log("savedRequest.participants.indexOf(message.sender)", savedRequest.participants.indexOf(message.sender));
+          Request.findOneAndUpdate({request_id: request.request_id, id_project: request.id_project}, { "attributes.last_message": savedMessage}).catch((err) => {
+            winston.error("Create message - saved last message in request error: ", error);
+          })
+
               
           if (request.participants && request.participants.indexOf(sender) > -1) { //update waiitng time if write an  agent (member of participants)
             winston.debug("updateWaitingTimeByRequestId");

package/routes/project.js

@@ -900,8 +900,10 @@ router.get('/', [passport.authenticate(['basic', 'jwt'], { session: false }), va
   var sortQuery={};
   sortQuery[sortField] = direction;
 
+// rolequery
 
-  Project_user.find({ id_user: req.user._id , role: { $in : [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT]}, status: "active"}).
+  Project_user.find({ id_user: req.user._id , roleType: RoleConstants.TYPE_AGENTS, status: "active"}).
+  // Project_user.find({ id_user: req.user._id , role: { $in : [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT]}, status: "active"}).
     // populate('id_project').
     populate({
       path: 'id_project',
@@ -1037,8 +1039,10 @@ router.get('/:projectid/users/availables', async  (req, res) => {
   if (isOpen === false) {
     return res.json(available_agents_array);
   }
+// rolequery
+  let query = { id_project: projectid, user_available: true, roleType: RoleConstants.TYPE_AGENTS };
+  // let query = { id_project: projectid, user_available: true, role: { $in : [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT]} };
 
-  let query = { id_project: projectid, user_available: true, role: { $in : [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT]} };
 
   if (dep_id) {
     let department = await Department.findById(dep_id).catch((err) => {
@@ -1052,7 +1056,41 @@ router.get('/:projectid/users/availables', async  (req, res) => {
     }
 
     let group_id = department.id_group;
-    if (group_id) {
+    let groups = department.groups;
+
+    if (groups && Array.isArray(groups) && groups.length > 0) {
+      // Converti i group_id in ObjectId per la query
+      const groupIds = groups
+        .map(g => g.group_id)
+        .filter(id => !!id)
+        .map(id => mongoose.Types.ObjectId(id));
+    
+      if (groupIds.length > 0) {
+        const dbGroups = await Group.find({ _id: { $in: groupIds } }).catch((err) => {
+          winston.error("(Users Availables) find groups error: ", err);
+          return res.status(500).send({ success: false, error: err });
+        });
+    
+        if (!dbGroups || dbGroups.length === 0) {
+          winston.error("(Users Availables) no valid groups found");
+          return res.status(404).send({ success: false, error: "No valid groups found" });
+        }
+    
+        // Filtra i gruppi abilitati
+        const enabledGroups = dbGroups.filter(g => g.enabled !== false);
+    
+        if (enabledGroups.length === 0) {
+          winston.error("(Users Availables) all groups are disabled");
+          return res.status(403).send({ success: false, error: "All groups are currently disabled" });
+        }
+    
+        // Raccogli tutti i membri (stringhe) e rimuovi duplicati
+        const members = [...new Set(enabledGroups.flatMap(g => g.members))];
+    
+        query.id_user = { $in: members };
+      }
+    }
+    else if (group_id) {
       let group = await Group.findById(group_id).catch((err) => {
         winston.error("(Users Availables) find group error: ", err)
         return res.status(500).send({ success: false, error: err })

package/routes/project_user.js

@@ -16,6 +16,7 @@ var passport = require('passport');
 require('../middleware/passport')(passport);
 var validtoken = require('../middleware/valid-token')
 var roleChecker = require('../middleware/has-role');
+const puEvent = require('../event/projectUserEvent');
 
 
 router.post('/invite', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], function (req, res) {
@@ -56,18 +57,30 @@ router.post('/invite', [passport.authenticate(['basic', 'jwt'], { session: false
 
     } else {
 
-      let roles = [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT];
-
-      Project_user.findOne({ id_project: id_project, id_user: user._id, role: { $in: roles }}, (err, puser) => {
+      /**
+       * *** IT IS NOT ALLOWED TO INVITE A USER WHO IS ALREADY A MEMBER OF THE PROJECT *** 
+       * FIND THE PROJECT USERS FOR THE PROJECT ID PASSED BY THE CLIENT IN THE BODY OF THE REQUEST
+       * IF THE ID OF THE USER FOUND FOR THE EMAIL (PASSED IN THE BODY OF THE REQUEST - see above)
+       * MATCHES ONE OF THE USER ID CONTENTS IN THE PROJECTS USER OBJECT STOP THE WORKFLOW AND RETURN AN ERROR */
+      
+      // rolequery
+      // var role = [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT];     
+      // winston.debug("role", role);
+    
+      // winston.debug("PROJECT USER ROUTES - req projectid", req.projectid);
+      return Project_user.findOne({ id_project: req.projectid, id_user: user._id, roleType: RoleConstants.TYPE_AGENTS, status: "active"}, function (err, puser) {
+      // return Project_user.find({ id_project: req.projectid, role: { $in : role }, status: "active"}, function (err, projectuser) {
+        //puser = projectuser
+      
+        winston.debug('PRJCT-USERS FOUND (FILTERED FOR THE PROJECT ID) ', puser )
         if (err) {
           winston.error("Error inviting an already existing user: ", err);
           return res.status(500).send({ success: false, msg: "An error occurred on inviting user " + email + " on project " + id_project })
         }
 
-        if (!roles.includes(req.body.role)) {
-          return res.status(400).send({ success: false, msg: 'Invalid role specified: ' + req.body.role });
-        }
-        
+        // if (!roles.includes(req.body.role)) {
+        //   return res.status(400).send({ success: false, msg: 'Invalid role specified: ' + req.body.role });
+        // }
         let user_available = typeof req.body.user_available === 'boolean' ? req.body.user_available : true
 
         if (puser) {
@@ -76,7 +89,20 @@ router.post('/invite', [passport.authenticate(['basic', 'jwt'], { session: false
             return res.status(403).send({ success: false, msg: 'Forbidden. User is already a member', code: 4001 });
           }
 
-          Project_user.findByIdAndUpdate(puser._id, { role: req.body.role, user_available: user_available, trashed: false, status: 'active' }, { new: true}, (err, updatedPuser) => {
+          winston.debug('NO ERROR, SO CREATE AND SAVE A NEW PROJECT USER ')
+
+          var newProject_user = new Project_user({
+            // _id: new mongoose.Types.ObjectId(),
+            id_project: req.projectid,
+            id_user: user._id,
+            role: req.body.role,         
+            roleType : RoleConstants.TYPE_AGENTS,   
+            user_available: user_available, 
+            createdBy: req.user.id,
+            updatedBy: req.user.id
+          });
+
+          return newProject_user.save(function (err, savedProject_user) {
             if (err) {
               winston.error("Error update existing project user before inviting it ", err)
               return res.status(500).send({ success: false, msg: "An error occurred on inviting user " + email + " on project " + id_project })
@@ -101,6 +127,7 @@ router.post('/invite', [passport.authenticate(['basic', 'jwt'], { session: false
             id_project: id_project,
             id_user: user._id,
             role: req.body.role,
+            roleType : RoleConstants.TYPE_AGENTS,   
             user_available: user_available,
             createdBy: req.user.id,
             updatedBy: req.user.id
@@ -138,6 +165,7 @@ router.post('/', [passport.authenticate(['basic', 'jwt'], { session: false }), v
     // role: RoleConstants.USER,   
     // - Create project_user endpoint by agent (Ticketing) now is with Guest Role      
     role: RoleConstants.GUEST,
+    roleType : RoleConstants.TYPE_USERS,   
     user_available: false,
     tags: req.body.tags, 
     createdBy: req.user.id,
@@ -298,6 +326,7 @@ router.delete('/:project_userid', [passport.authenticate(['basic', 'jwt'], { ses
         return res.status(404).send({ success: false, error: 'Project user not found with id ' + pu_id });
       }
 
+      puEvent.emit('project_user.deleted', project_user);
       // Event 'project_user.delete' not working - Check it and improve it to manage soft/hard delete
       return res.status(200).send(project_user);
 
@@ -324,6 +353,7 @@ router.delete('/:project_userid', [passport.authenticate(['basic', 'jwt'], { ses
         });
       }
 
+      puEvent.emit('project_user.deleted', project_user);
       return res.status(200).send(project_user);
     });
   }
@@ -387,6 +417,20 @@ router.put('/:project_userid/restore', [passport.authenticate(['basic', 'jwt'],
   });
 });
 
+router.get('/me', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('agent', ['subscription'])], function (req, res, next) {
+  if (!req.project) {
+    return res.status(404).send({ success: false, msg: 'Project not found.' });
+  }
+  var project_user = req.projectuser;
+
+  var pu = project_user.toJSON();
+   
+  pu.isBusy = ProjectUserUtil.isBusy(project_user, req.project.settings && req.project.settings.max_agent_assigned_chat);
+  res.json([pu]);
+
+
+});
+
 router.get('/:project_userid', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('agent', ['subscription'])], function (req, res) {
   // router.get('/details/:project_userid', function (req, res) {
   // winston.debug("PROJECT USER ROUTES - req projectid", req.projectid);
@@ -513,18 +557,25 @@ router.get('/users/:user_id', [passport.authenticate(['basic', 'jwt'], { session
  */                                                                                       
 router.get('/', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('agent', ['bot', 'subscription'])], function (req, res) {
 
-  var role = [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT];
+  // rolequery
+  // var role = [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT];
 
+  var query;
   if (req.query.role) {
     role = req.query.role;
+    winston.debug("role", role);
+    query =  {id_project: req.projectid, role: { $in : role } };
+  } else {
+     query =  {id_project: req.projectid, roleType: RoleConstants.TYPE_AGENTS };
   }
-  winston.debug("role", role);
 
-  var query = { id_project: req.projectid, role: { $in : role } };
   if (!req.query.trashed || req.query.trashed === 'false' || req.query.trashed === false) {
     query.trashed = { $ne: true };
   }
 
+  // var query =  {id_project: req.projectid, role: { $in : role } };
+  
+
   if (req.query.presencestatus) {
     query["presence.status"] = req.query.presencestatus;
   }

package/routes/request.js

@@ -33,6 +33,7 @@ const RoleConstants = require('../models/roleConstants');
 const eventService = require('../pubmodules/events/eventService');
 const { Scheduler } = require('../services/Scheduler');
 const faq_kb = require('../models/faq_kb');
+
 const datesUtil = require('../utils/datesUtil');
 //const JobManager = require('../utils/jobs-worker-queue-manager-v2/JobManagerV2');
 
@@ -188,19 +189,7 @@ router.post('/',
         };
 
         return requestService.create(new_request).then(function (savedRequest) {
-          // createWithIdAndRequester(request_id, project_user_id, lead_id, id_project, first_text, departmentid, sourcePage, language, userAgent, status, createdBy, attributes) {
-          // return requestService.createWithIdAndRequester(request_id, req.projectuser._id, createdLead._id, req.projectid, 
-          //   req.body.text, req.body.departmentid, req.body.sourcePage, 
-          //   req.body.language, req.body.userAgent, null, req.user._id, req.body.attributes, req.body.subject).then(function (savedRequest) {
-
-
-          // return messageService.create(sender || req.user._id, fullname, request_id, req.body.text,
-          // req.projectid, req.user._id, messageStatus, req.body.attributes, req.body.type, req.body.metadata, req.body.language, undefined, req.body.channel).then(function(savedMessage){                    
-
-          // create(sender, senderFullname, recipient, text, id_project, createdBy, status, attributes, type, metadata) {
-          // return messageService.create(req.body.sender || req.user._id, req.body.senderFullname || req.user.fullName, request_id, req.body.text,
-          //   req.projectid, req.user._id, messageStatus, req.body.attributes, req.body.type, req.body.metadata).then(function(savedMessage){                    
-
+        
 
           winston.debug('res.json(savedRequest)');
           var endTimestamp = new Date();
@@ -377,7 +366,7 @@ router.put('/:requestid/close', async function (req, res) {
 
 // TODO make a synchronous chat21 version (with query parameter?) with request.support_group.created
 router.put('/:requestid/reopen', function (req, res) {
-  winston.debug(req.body);
+  winston.debug(req.body); 
   // reopenRequestByRequestId(request_id, id_project) {
   return requestService.reopenRequestByRequestId(req.params.requestid, req.projectid).then(function (reopenRequest) {
 
@@ -399,12 +388,13 @@ router.put('/:requestid/assignee', function (req, res) {
   //TODO change assignee
 });
 
+// curl -v -X POST -H 'Content-Type:application/json' -u andrea.leo@f21.it:123456 -d '{"member":"ciao"}' http://localhost:3000/68d4135a10e71f7bfa4dcf2f/requests/req123456/participants
 // TODO make a synchronous chat21 version (with query parameter?) with request.support_group.created
 router.post('/:requestid/participants',
   [
     check('member').notEmpty(),
   ],
-  function (req, res) {
+   async (req, res) => {
     winston.debug(req.body);
 
     const errors = validationResult(req);
@@ -432,7 +422,9 @@ error: uncaughtException: Cannot set property 'participants' of null
 2020-03-08T12:53:35.793660+00:00 app[web.1]:     at /app/services/requestService.js:672:30
 2020-03-08T12:53:35.793661+00:00 app[web.1]:     at /app/node_modules/mongoose/lib/model.js:4779:16
 */
-router.put('/:requestid/participants', function (req, res) {
+
+//  curl -v -X PUT -H 'Content-Type:application/json' -u andrea.leo@f21.it:123456 -d '{"member":"ciao"}' http://localhost:3000/68d4135a10e71f7bfa4dcf2f/requests/req123456/participants
+router.put('/:requestid/participants', async (req, res) => {
   winston.debug("req.body", req.body);
 
   var participants = [];
@@ -512,7 +504,7 @@ router.put('/:requestid/replace', async (req, res) => {
 })
 
 // TODO make a synchronous chat21 version (with query parameter?) with request.support_group.created
-router.delete('/:requestid/participants/:participantid', function (req, res) {
+router.delete('/:requestid/participants/:participantid', async (req, res) => {
   winston.debug(req.body);
   //removeParticipantByRequestId(request_id, id_project, member)
   return requestService.removeParticipantByRequestId(req.params.requestid, req.projectid, req.params.participantid).then(function (updatedRequest) {
@@ -775,6 +767,7 @@ router.post('/:requestid/notes', async function (req, res) {
     }
 
     // Check if the user is a participant
+    // disable this check?
     if (!request.participantsAgents.includes(req.user.id)) {
       winston.verbose("Trying to add a note from a non participating agent");
       return res.status(403).send({ success: false, error: "You are not participating in the conversation"})
@@ -821,6 +814,7 @@ router.delete('/:requestid/notes/:noteid', async function (req, res) {
     }
   
     // Check if the user is a participant
+    // disable this check?
     if (!request.participantsAgents.includes(req.user.id)) {
       winston.verbose("Trying to delete a note from a non participating agent");
       return res.status(403).send({ success: false, error: "You are not participating in the conversation"})
@@ -1052,8 +1046,8 @@ router.delete('/:requestid/tag/:tag_id', async (req, res) => {
   let id_project = req.projectid;
   let request_id = req.params.requestid;
   let tag_id = req.params.tag_id;
-
-
+  
+  
 
   Request.findOneAndUpdate({ id_project: id_project, request_id: request_id }, { $pull: { tags: { _id: tag_id } } }, { new: true }).then( async (updatedRequest) => {
     
@@ -1088,8 +1082,8 @@ router.delete('/:requestid', function (req, res) {
 
   var projectuser = req.projectuser;
 
-
-  if (projectuser.role != "owner") {
+  // request_role_check
+  if (!projectuser.hasPermissionOrRole('request_delete', 'owner')){
     return res.status(403).send({ success: false, msg: 'Unauthorized.' });
   }
 
@@ -1144,8 +1138,8 @@ router.delete('/id/:id', function (req, res) {
 
   var projectuser = req.projectuser;
 
-
-  if (projectuser.role != "owner") {
+  // request_role_check
+  if (!projectuser.hasPermissionOrRole('request_delete', 'owner')){
     return res.status(403).send({ success: false, msg: 'Unauthorized.' });
   }
 
@@ -1169,7 +1163,7 @@ router.delete('/id/:id', function (req, res) {
 });
 
 
-
+// curl -v -X GET -H 'Content-Type:application/json' -u andrea.leo@f21.it:123456 http://localhost:3000/68d4135a10e71f7bfa4dcf2f/requests
 
 router.get('/', function (req, res, next) {
 
@@ -1207,16 +1201,24 @@ router.get('/', function (req, res, next) {
 
   if (req.user instanceof Subscription) {
     // All request 
-  } else if (projectuser && (projectuser.role == "owner" || projectuser.role == "admin")) {
+    winston.debug("Subscription All request ");
+  } else if (projectuser.hasPermissionOrRole('request_read_all', ["owner", "admin"])) {
     // All request 
-    // Per uni mostrare solo quelle proprie quindi solo participants
-    if (req.query.mine) {
-      query["$or"] = [{ "snapshot.agents.id_user": req.user.id }, { "participants": req.user.id }];
-    }
-  } else {
+    winston.debug("hasPermissionOrRole All request ");
+  } else if (projectuser.hasPermissionOrRole('request_read_group', ["agent"])) {
+
     query["$or"] = [{ "snapshot.agents.id_user": req.user.id }, { "participants": req.user.id }];
+
+  } 
+  // else if (projectuser.hasPermissionOrRole('request_read_mine', ["????"])) {
+  //   query["participants"] = req.user.id;
+  // }
+  else {
+     query["participants"] = req.user.id;
+    // generate empty requests response
   }
 
+
   if (req.query.dept_id) {
     query.department = req.query.dept_id;
   }

package/routes/roles.js

@@ -0,0 +1,151 @@
+var express = require('express');
+var router = express.Router();
+var Role = require("../models/role");
+var winston = require('../config/winston');
+const roleEvent = require('../event/roleEvent');
+
+router.post('/', function (req, res) {
+
+  winston.debug(req.body);
+  winston.debug("req.user", req.user);
+
+  var newRole = new Role({
+              name: req.body.name,
+              permissions: req.body.permissions,              
+              id_project: req.projectid,
+              createdBy: req.user.id,
+              updatedBy: req.user.id
+            });
+          
+  newRole.save(function(err, savedRole) {
+      if (err) {
+        winston.error('Error saving the role '+ JSON.stringify(newRole), err)
+        return res.status(500).send({ success: false, msg: 'Error inserting object.' });
+      }            
+
+      roleEvent.emit('role.create', savedRole);
+      
+      return res.json(savedRole);
+  })
+
+
+});
+
+router.put('/:roleid', function (req, res) {
+  winston.debug(req.body);
+  var update = {};
+  
+  if (req.body.name!=undefined) {
+    update.name = req.body.name;
+  }
+  
+  if (req.body.permissions!=undefined) {
+    update.permissions = req.body.permissions;
+  }
+   
+  
+  Role.findByIdAndUpdate(req.params.roleid, update, { new: true, upsert: true }, function (err, updatedRole) {
+    if (err) {
+      winston.error('--- > ERROR ', err);
+      return res.status(500).send({ success: false, msg: 'Error updating object.' });
+    }
+    
+    roleEvent.emit('role.update', updatedRole);
+
+    res.json(updatedRole);
+  });
+});
+
+
+
+router.delete('/:roleid', function (req, res) {
+  winston.debug(req.body);
+
+  // Role.remove({ _id: req.params.roleid }, function (err, role) {
+  Role.findOneAndDelete({  _id: req.params.roleid }, (err, role) => {
+    if (err) {
+      winston.error('--- > ERROR ', err);
+      return res.status(500).send({ success: false, msg: 'Error deleting object.' });
+    }
+
+    roleEvent.emit('role.delete', role);
+
+    res.json(role);
+  });
+});
+
+
+router.get('/:roleid', function (req, res) {
+  winston.debug(req.body);
+
+  Role.findById(req.params.roleid, function (err, role) {
+    if (err) {
+      return res.status(500).send({ success: false, msg: 'Error getting object.' });
+    }
+    if (!role) {
+      return res.status(404).send({ success: false, msg: 'Object not found.' });
+    }
+    res.json(role);
+  });
+});
+
+
+router.get('/', async(req, res) => {
+
+  var limit = 40; // Number of request per page
+
+  if (req.query.limit) {    
+    limit = parseInt(req.query.limit);
+    winston.debug('LEAD ROUTE - limit: '+limit);
+  }
+
+  var page = 0;
+
+  if (req.query.page) {
+    page = req.query.page;
+  }
+
+  var skip = page * limit;
+  winston.debug('ROLE ROUTE - SKIP PAGE ', skip);
+
+
+  var query = {"id_project": req.projectid};
+
+
+
+  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 Role.find(query).
+    skip(skip).limit(limit).
+    sort(sortQuery).
+    exec(function (err, roles) {
+      if (err) {
+        winston.error('ROLE ROUTE - REQUEST FIND ERR ', err)
+        return (err);
+      }
+
+
+      return res.json(roles);
+      
+    });
+});
+
+
+
+
+module.exports = router;

package/routes/unanswered.js

@@ -6,7 +6,7 @@ var winston = require('../config/winston');
 // Add a new unanswered question
 router.post('/', async (req, res) => {
     try {
-        const { namespace, question } = req.body;
+        const { namespace, question, request_id, sender } = req.body;
         const id_project = req.projectid;
 
         if (!namespace || !question) {
@@ -28,7 +28,9 @@ router.post('/', async (req, res) => {
         const unansweredQuestion = new UnansweredQuestion({
             id_project,
             namespace,
-            question
+            question,
+            request_id,
+            sender
         });
 
         const savedQuestion = await unansweredQuestion.save();
@@ -67,21 +69,32 @@ router.get('/:namespace', async (req, res) => {
 
         const page = parseInt(req.query.page) || 0;
         const limit = parseInt(req.query.limit) || 20;
-        const sortField = req.query.sortField || 'created_at';
+        const sortField = req.query.sortField || 'createdAt';
         const direction = parseInt(req.query.direction) || -1;
 
-        const questions = await UnansweredQuestion.find({
-            id_project,
-            namespace
-        })
-        .sort({ [sortField]: direction })
-        .skip(page * limit)
-        .limit(limit);
+        const filter = { id_project, namespace };
 
-        const count = await UnansweredQuestion.countDocuments({
-            id_project,
-            namespace
-        });
+        let projection = undefined;
+
+        if (req.query.search) {
+            filter.$text = { $search: req.query.search };
+            // Add score to projection if it's a text search
+            projection = { score: { $meta: "textScore" } };
+        }
+
+        let sortObj;
+        if (projection && projection.score) {
+            sortObj = { score: { $meta: "textScore" } };
+        } else {
+            sortObj = { [sortField]: direction };
+        }
+
+        const questions = await UnansweredQuestion.find(filter, projection)
+            .sort(sortObj)
+            .skip(page * limit)
+            .limit(limit);
+
+        const count = await UnansweredQuestion.countDocuments(filter);
 
         res.status(200).json({
             count,
@@ -90,7 +103,8 @@ router.get('/:namespace', async (req, res) => {
                 page,
                 limit,
                 sortField,
-                direction
+                direction,
+                search: req.query.search || undefined
             }
         });
 
@@ -109,20 +123,19 @@ router.delete('/:id', async (req, res) => {
         const { id } = req.params;
         const id_project = req.projectid;
 
-        const question = await UnansweredQuestion.findOne({ _id: id, id_project });
-        if (!question) {
+        const deleted = await UnansweredQuestion.findOneAndDelete({ _id: id, id_project });
+        if (!deleted) {
             return res.status(404).json({
                 success: false,
                 error: "Question not found"
             });
         }
 
-        await UnansweredQuestion.deleteOne({ _id: id });
         res.status(200).json({
             success: true,
             message: "Question deleted successfully"
         });
-
+        
     } catch (error) {
         winston.error('Error deleting unanswered question:', error);
         res.status(500).json({

package/routes/widget.js

@@ -82,7 +82,9 @@ router.get('/', async (req, res, next) => {
       operatingHoursService.projectIsOpenNow(req.projectid, function (isOpen, err) {    
           winston.debug('isOpen:'+ isOpen);
           if (isOpen) {            
-            Project_user.find({ id_project: req.projectid, user_available: true, role: { $in : [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT]}, status: "active" }).
+            // rolequery
+            Project_user.find({ id_project: req.projectid, user_available: true, roleType: RoleConstants.TYPE_AGENTS, status: "active" }).
+            // Project_user.find({ id_project: req.projectid, user_available: true, role: { $in : [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT]}, status: "active" }).
               populate('id_user').
               exec(function (err, project_users) {
                 winston.debug('project_users:'+ project_users);

package/services/cacheEnabler.js

@@ -47,15 +47,12 @@ class CacheEnabler {
             this.integrations = false;
         }
 
-        // this.user = true;
-        // if (process.env.CACHE_USER_ENABLED=="false" || process.env.CACHE_USER_ENABLED==false) {
-        //     this.user = false;
-        // }
+        this.role = true;
+        if (process.env.CACHE_ROLE_ENABLED=="false" || process.env.CACHE_ROLE_ENABLED==false) {
+            this.role = false;
+        }
 
-        // this.message = true;
-        // if (process.env.CACHE_MESSAGE_ENABLED=="false" || process.env.CACHE_MESSAGE_ENABLED==false) {
-        //     this.message = false;
-        // }
+       
     }
 }