@tiledesk/tiledesk-server 2.17.3 → 2.18.1

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

@@ -67,7 +67,7 @@ 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({

package/routes/webhook.js

@@ -12,7 +12,7 @@ var ObjectId = require('mongoose').Types.ObjectId;
 const default_embedding = require('../config/kb/embedding');
 
 const port = process.env.PORT || '3000';
-let TILEBOT_ENDPOINT = "http://localhost:" + port + "/modules/tilebot/";;
+let TILEBOT_ENDPOINT = "http://localhost:" + port + "/modules/tilebot/";
 if (process.env.TILEBOT_ENDPOINT) {
     TILEBOT_ENDPOINT = process.env.TILEBOT_ENDPOINT + "/"
 }
@@ -69,18 +69,12 @@ router.post('/kb/reindex', async (req, res) => {
   
   let content_id = req.body.content_id;
 
-  let kb = await KB.findById(content_id).catch( async (err) => {
-    winston.error("(webhook) Error getting kb content: ", err);
-    return res.status(500).send({ success: false, error: "Error getting content with id " + content_id });
-  })
-
-  const namespace_id = kb.namespace;
-  let namespace;
+  let kb;
   try {
-    namespace = await aiManager.checkNamespace(kb.id_project, namespace_id);
+    kb = await KB.findById(content_id);
   } catch (err) {
-    let errorCode = err?.errorCode ?? 500;
-    return res.status(errorCode).send({ success: false, error: err.error });
+    winston.error("(webhook) Error getting kb content: ", err);
+    return res.status(500).send({ success: false, error: "Error getting content with id " + content_id });
   }
 
   if (!kb) {
@@ -99,8 +93,19 @@ router.post('/kb/reindex', async (req, res) => {
       winston.verbose("(webhook) delete response: ", deleteResponse);
       return;
     }, 10000);
-    
-  } else if (kb.type === 'sitemap') {
+    return;
+  }
+
+  const namespace_id = kb.namespace;
+  let namespace;
+  try {
+    namespace = await aiManager.checkNamespace(kb.id_project, namespace_id);
+  } catch (err) {
+    let errorCode = err?.errorCode ?? 500;
+    return res.status(errorCode).send({ success: false, error: err.error });
+  }
+
+  if (kb.type === 'sitemap') {
 
     const urls = await aiManager.fetchSitemap(kb.source).catch((err) => {
       winston.error("(webhook) Error fetching sitemap: ", err);

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;
-        // }
+       
     }
 }
 

package/services/departmentService.js

@@ -272,9 +272,25 @@ getOperators(departmentid, projectid, nobot, disableWebHookCall, context) {
           // console.log('OPERATORS - »»»» BOT IS DEFINED - !!! DEPT HAS NOT GROUP ID')
           // console.log('OPERATORS - »»»» BOT IS DEFINED -> ID BOT', department.id_bot);
           // console.log('OPERATORS - »»»» nobot ', nobot)
-          var role = [RoleConstants.OWNER, RoleConstants.ADMIN,RoleConstants.SUPERVISOR, RoleConstants.AGENT];
-// attento indice
-          return Project_user.find({ id_project: projectid, role: { $in : role }, status: "active" }).exec(function (err, project_users) {
+          winston.debug("main_flow_cache_2 departmentService project users");
+          
+          
+          // rolequery
+          // var role = [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT];
+          // var qpu = Project_user.find({ id_project: projectid, role: { $in : role }, status: "active" });
+          var qpu = Project_user.find({ id_project: projectid, roleType: RoleConstants.TYPE_AGENTS, status: "active" });
+
+          
+          // use this. $in doesn't use index very well
+          // var qpu = Project_user.findOne({ id_project: projectid, $or: [{ "role": RoleConstants.AGENT }, { "role": RoleConstants.SUPERVISOR }, { "role":  RoleConstants.ADMIN }, { "role": RoleConstants.OWNER }], status: "active" })
+          
+          if (cacheEnabler.project_user) {
+            qpu.cache(cacheUtil.queryTTL, projectid+":project_users:query:teammates:available") //request_cache
+            winston.debug('project_user cache enabled');
+          }
+  
+  
+          return qpu.exec(function (err, project_users) {
             if (err) {
               winston.error('-- > 2 DEPT FIND BY ID ERR ', err)
               return reject(err);
@@ -369,12 +385,12 @@ getOperators(departmentid, projectid, nobot, disableWebHookCall, context) {
         // console.log('D-2 GROUP -> [ FIND PROJECT USERS: ALL and AVAILABLE (with OH) ] -> MEMBERS LENGHT: ', group[0].members.length);
         // console.log('D-2 GROUP -> [ FIND PROJECT USERS: ALL and AVAILABLE (with OH) ] -> MEMBERS ID: ', group[0].members);
 
-        // , user_available: true
-        //Project_user.findAllProjectUsersByProjectIdWhoBelongsToMembersOfGroup(id_prject, group[0]);
-        // riprodurre su v2
-         return Project_user.find({ id_project: projectid, id_user: { $in : group[0].members}, role: { $in : [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT]}, status: "active" }).exec(function (err, project_users) {          
-          // uni error round robin
-        //return Project_user.find({ id_project: projectid, id_user: group[0].members, role: { $in : [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.AGENT]} }).exec(function (err, project_users) {
+   
+
+        // rolequery
+        
+         return Project_user.find({ id_project: projectid, id_user: { $in : group[0].members}, roleType: RoleConstants.TYPE_AGENTS, status: "active" }).exec(function (err, project_users) {          
+        //  return Project_user.find({ id_project: projectid, id_user: { $in : group[0].members}, role: { $in : [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT]}, status: "active" }).exec(function (err, project_users) {         
 
           // console.log('D-2 GROUP -> [ FIND PROJECT USERS: ALL and AVAILABLE (with OH) ] -> PROJECT ID ', projectid);
           if (err) {
@@ -436,8 +452,20 @@ getOperators(departmentid, projectid, nobot, disableWebHookCall, context) {
 
   return new Promise(function (resolve, reject) {
 
-    var role = [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT];
-    return Project_user.find({ id_project: projectid , role: { $in : role }, status: "active" }).exec(function (err, project_users) {
+    // var role = [RoleConstants.OWNER, RoleConstants.ADMIN, RoleConstants.SUPERVISOR, RoleConstants.AGENT];
+// rolequery
+    var qpu = Project_user.find({ id_project: projectid, roleType: RoleConstants.TYPE_AGENTS, status: "active" });
+    // var qpu = Project_user.find({ id_project: projectid, role: { $in : role }, status: "active" });
+          
+    // use this. $in doesn't use index very well    
+    if (cacheEnabler.project_user) {
+      qpu.cache(cacheUtil.queryTTL, projectid+":project_users:query:teammates:available") //request_cache
+      winston.debug('project_user cache enabled');
+    }
+    // return Project_user.find({ id_project: projectid , role: { $in : role }, status: "active" }).exec(function (err, project_users) {
+    return qpu.exec(function (err, project_users) {
+
+
       if (err) {
         winston.error('D-3 NO GROUP -> [ FIND PROJECT USERS: ALL and AVAILABLE (with OH) ] -> ERR ', err)
         return reject(err);

package/services/emailService.js

@@ -282,7 +282,6 @@ class EmailService {
   // }
 
   async send(mail, quoteEnabled, project, quoteManager) {
-
     if (!this.enabled) {
       winston.info('EmailService is disabled. Not sending email');
       return 0;
@@ -339,7 +338,8 @@ class EmailService {
         if (mail.callback) {
           mail.callback(error, { info: info });
         }
-        return winston.error("Error sending email ", { error: error, mailConfig: mail.config, mailOptions: mailOptions });
+        //return winston.error("Error sending email ", { error: error, mailConfig: mail.config, mailOptions: mailOptions });
+        return winston.error("Error sending email ", { error: error, mailConfig: mail.config });
       }
       winston.verbose('Email sent:', { info: info });
       winston.debug('Email sent:', { info: info, mailOptions: mailOptions });

package/services/pendingInvitationService.js

@@ -4,6 +4,7 @@ var emailService = require("../services/emailService");
 var Project_user = require("../models/project_user");
 var mongoose = require('mongoose');
 var winston = require('../config/winston');
+var RoleConstants = require("../models/roleConstants");
 
 class Pending_Invitation {
 
@@ -91,6 +92,7 @@ class Pending_Invitation {
             id_project: invite.id_project,
             id_user: newUserId,
             role: invite.role,
+            roleType : RoleConstants.TYPE_AGENTS,   
             user_available: true,
             createdBy: invite.createdBy,
             updatedBy: invite.createdBy

package/services/projectService.js

@@ -8,6 +8,7 @@ var projectEvent = require("../event/projectEvent");
 var winston = require('../config/winston');
 const cacheEnabler = require("./cacheEnabler");
 const cacheUtil = require("../utils/cacheUtil");
+var RoleConstants = require("../models/roleConstants");
 
 class ProjectService {
 
@@ -33,7 +34,8 @@ class ProjectService {
           var newProject_user = new Project_user({
             id_project: savedProject._id,
             id_user: createdBy,
-            role: 'owner',
+            role: RoleConstants.OWNER,
+            roleType : RoleConstants.TYPE_AGENTS,   
             user_available: true,
             createdBy: createdBy,
             updatedBy: createdBy

package/services/projectUserService.js

@@ -1,11 +1,11 @@
 'use strict';
 
-var Project = require("../models/project");
 var Project_user = require("../models/project_user");
-var mongoose = require('mongoose');
-var User = require('../models/user');
 var winston = require('../config/winston');
-var pendinginvitation = require("../services/pendingInvitationService");
+
+var Role = require('../models/role');
+var cacheUtil = require('../utils/cacheUtil');
+var cacheEnabler = require("../services/cacheEnabler");
 
 class ProjectUserService {
 
@@ -42,6 +42,69 @@ class ProjectUserService {
 
     }
 
+     async getWithPermissions(id_user, id_project, user_sub) {       
+        var project_user = await this.get(id_user, id_project, user_sub);
+        winston.debug("getWithPermissions for id_user " + id_user + " project_user ", project_user);
+
+        if (project_user) {
+            winston.debug("getWithPermissions project_user role: " + project_user.role);
+
+            var role = await this.getPermissions(project_user.role, id_project);
+
+            if (role) {
+                project_user._doc.rolePermissions = role.permissions;   //https://github.com/Automattic/mongoose/issues/4614
+                // project_user.set("rolePermissions", role);
+            }
+            
+
+        }
+        
+        return project_user;
+    }
+
+    async getPermissions(role, id_project) {
+         //               var cacheManager = require('../utils/cacheManager');
+        //               cacheManager.getClient().get("find in cache")
+        let q = Role.findOne({"name":role, "id_project": id_project});
+
+        let cache_key = id_project+":roles:"+role;
+
+        if (cacheEnabler.role) { 
+            q.cache(cacheUtil.defaultTTL, cache_key);
+            winston.debug("cacheEnabler.role enabled");
+        }
+
+        var role = await q.exec();
+
+        if (role) 
+            winston.debug("getWithPermissions role ", role.toJSON());
+
+        return role;
+
+    }
+
+    async get(id_user, id_project, user_sub) {
+        // JWT_HERE
+        var query = { id_project: id_project, id_user: id_user, status: "active"};
+        let cache_key = id_project+":project_users:iduser:"+id_user;
+
+        if (user_sub && (user_sub=="userexternal" || user_sub=="guest")) {
+            query = { id_project: id_project, uuid_user: id_user, status: "active"};
+            cache_key = id_project+":project_users:uuid_user:"+id_user;
+        }
+        winston.debug("hasRoleOrType query " + JSON.stringify(query));
+
+        let q = Project_user.findOne(query);
+        if (cacheEnabler.project_user) { 
+            q.cache(cacheUtil.defaultTTL, cache_key);
+            winston.debug("cacheEnabler.project_user enabled");
+        }
+        var project_user = await q.exec();
+        winston.debug("ProjectUserUtil project_user", project_user);
+       
+        return project_user;
+    }
+
 }
 var projectUserService = new ProjectUserService();
 

package/services/subscriptionNotifierQueued.js

@@ -111,6 +111,14 @@ class SubscriptionNotifierQueued {
         winston.debug('SubscriptionNotifier project_user.update sent');     
       });
     });
+
+
+    authEvent.on("project_user.update.agent",  function(event) {  
+      setImmediate(() => {
+        subscriptionNotifier.subscribe('project_user.update.agent', event.updatedProject_userPopulated);     
+        winston.debug('SubscriptionNotifier project_user.update.agent sent');     
+      });
+    });
     
     winston.info('SubscriptionNotifierQueued started');
   }

package/services/updateRequestSnapshotQueued.js

@@ -25,12 +25,10 @@ class UpdateRequestSnapshotQueued {
     requestEvent.on(snapshotUpdateKey, function (data) {
       setImmediate(() => {
         winston.debug("updateRequestSnapshot on request.snapshot.update ", data);
-        console.log("updateRequestSnapshot on request.snapshot.update ", data);
 
         const request = data.request;
         const snapshot = data.snapshot;
         const agentsArray = snapshot?.agents || [];
-        console.log("(queue) updateRequestSnapshot snapshot agents length: ", agentsArray.length);
 
         if (!request || !request.request_id || !request.id_project) {
           winston.error("updateRequestSnapshot: Invalid request data", data);
@@ -57,7 +55,6 @@ class UpdateRequestSnapshotQueued {
               return;
             }
             if (updatedRequest) {
-              console.log("updateRequestSnapshot updated snapshot.agents for request " + updatedRequest.request_id, new Date());
               winston.debug("updateRequestSnapshot updated snapshot.agents for request " + updatedRequest.request_id);
             } else {
               winston.warn("updateRequestSnapshot: Request not found for " + request.request_id);