@tiledesk/tiledesk-server 2.11.4 → 2.11.6

package/CHANGELOG.md

@@ -5,6 +5,16 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
+# 2.11.6
+- Added: possibility to enable/disable groups
+- Updated: delete project user endpoint to logical delete
+- Updated: tybot-connector to 2.0.23
+- Updated: get all namespace adding counter
+- Added: attributes field in groups model
+
+# 2.11.5
+- Added: log in requestService
+
 # 2.11.4
 - Added: authentication via Keycloak
 - Added: project settings fields for allowed_urls, allowed_urls_list, allow_send_emoji

package/models/group.js

@@ -18,10 +18,18 @@ var GroupSchema = new Schema({
     index: true
     // required: true
   },
+  enabled: {
+    type: Boolean,
+    default: true,
+    index: true
+  },
   trashed: {
     type: Boolean,
     index: true
   },
+  attributes: {
+    type: Object,
+  },
   createdBy: {
     type: String,
     required: true

package/models/project_user.js

@@ -69,6 +69,7 @@ var TagSchema = require("../models/tag");
     },
     status: {
       type: String,
+      enum: ['active', 'disabled'],
       default: "active",
       index: true,
       required: true

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.11.4",
+  "version": "2.11.6",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",
@@ -49,7 +49,7 @@
     "@tiledesk/tiledesk-rasa-connector": "^1.0.10",
     "@tiledesk/tiledesk-sms-connector": "^0.1.11",
     "@tiledesk/tiledesk-telegram-connector": "^0.1.14",
-    "@tiledesk/tiledesk-tybot-connector": "^2.0.21",
+    "@tiledesk/tiledesk-tybot-connector": "^2.0.23",
     "@tiledesk/tiledesk-voice-twilio-connector": "^0.1.22",
     "@tiledesk/tiledesk-vxml-connector": "^0.1.76",
     "@tiledesk/tiledesk-whatsapp-connector": "^0.1.84",

package/routes/group.js

@@ -3,6 +3,7 @@ var router = express.Router();
 var Group = require("../models/group");
 var groupEvent = require("../event/groupEvent");
 var winston = require('../config/winston');
+const departmentService = require('../services/departmentService');
 
 
 
@@ -44,6 +45,9 @@ router.put('/:groupid', function (req, res) {
   if (req.body.trashed!=undefined) {
     update.trashed = req.body.trashed;
   }
+  if (req.body.attributes!=undefined) {
+    update.attributes = req.body.attributes;
+  }
   
 
   Group.findByIdAndUpdate(req.params.groupid, update, { new: true, upsert: true }, function (err, updatedGroup) {
@@ -57,6 +61,49 @@ router.put('/:groupid', function (req, res) {
   });
 });
 
+router.put('/enable/:groupid', async (req, res) => {
+
+  let group_id = req.params.groupid;
+
+  Group.findByIdAndUpdate(group_id, { enabled: true }, { new: true, upsert: true }, (err, updatedGroup) => {
+    if (err) {
+      winston.error("Error enabling the group: ", err);
+      return res.status(500).send({ success: false, error: "Error enabling group" })
+    }
+
+    groupEvent.emit('group.update', updatedGroup);
+    res.status(200).send(updatedGroup);
+  })
+
+})
+
+router.put('/disable/:groupid', async (req, res) => {
+
+  let id_project = req.projectid;
+  let group_id = req.params.groupid;
+
+  const isInDepartment = await departmentService.isGroupInProjectDepartment(id_project, group_id).catch((err) => {
+    winston.error("Error checking if group belongs to the department: ", err);
+    return res.status(500).send({ success: false, error: "Unable to verify group-department association due to an error" })
+  })
+
+  if (isInDepartment) {
+    winston.verbose("The group " + group_id + " belongs to a department and cannot be disabled");
+    return res.status(403).send({ success: false, error: "Unable to disabled a group associated with a department" })
+  }
+
+  Group.findByIdAndUpdate(group_id, { enabled: false }, { new: true, upsert: true }, (err, updatedGroup) => {
+    if (err) {
+      winston.error("Error disabling the group: ", err);
+      return res.status(500).send({ success: false, error: "Error disabling group" })
+    }
+
+    groupEvent.emit('group.update', updatedGroup);
+    res.status(200).send(updatedGroup);
+  })
+
+})
+
 // router.put('/:groupid', function (req, res) {
 
 //   winston.debug(req.body);
@@ -79,21 +126,51 @@ router.put('/:groupid', function (req, res) {
 //   });
 // });
 
-router.delete('/:groupid', function (req, res) {
+router.delete('/:groupid', async (req, res) => {
 
-  winston.debug(req.body);
+  let id_project = req.projectid;
+  let group_id = req.params.groupid;
 
-  Group.findOneAndRemove({_id: req.params.groupid}, function (err, group) {
-    // Group.remove({ _id: req.params.groupid }, function (err, group) {
-    if (err) {
-      winston.error('Error removing the group ', err);
-      return res.status(500).send({ success: false, msg: 'Error deleting object.' });
-    }
-// nn funziuona perchje nn c'è id_project
-    groupEvent.emit('group.delete', group);
+  const isInDepartment = await departmentService.isGroupInProjectDepartment(id_project, group_id).catch((err) => {
+    winston.error("Error checking if group belongs to the department: ", err);
+    return res.status(500).send({ success: false, error: "Unable to verify group-department association due to an error" })
+  })
+
+  if (isInDepartment) {
+    winston.verbose("The group " + group_id + " belongs to a department and cannot be deleted");
+    return res.status(403).send({ success: false, error: "Unable to delete a group associated with a department" })
+  }
+
+  if (req.query.force === "true") {
+    
+    Group.findByIdAndRemove(group_id, function (err, group) {
+      if (err) {
+        winston.error('Error removing the group ', err);
+        return res.status(500).send({ success: false, msg: 'Error deleting group' });
+      }
+      winston.debug("Physically removed group", group);
+      // nn funziuona perchje nn c'è id_project
+      groupEvent.emit('group.delete', group);
+      res.status(200).send(group);
+    });
+
+  } else {
+
+    Group.findByIdAndUpdate(group_id, { enabled: false, trashed: true }, { new: true }, function (err, group) {
+        if (err) {
+          winston.error('Error removing the group ', err);
+          return res.status(500).send({ success: false, msg: 'Error deleting group' });
+        }
+
+        winston.debug("Group logical deleted", group);
+
+        groupEvent.emit('group.update', group);
+
+        res.status(200).send({ success: true, message: "Group successfully deleted"})
+      }
+    );
+  }
 
-    res.json(group);
-  });
 });
 
 

package/routes/kb.js

@@ -321,9 +321,8 @@ router.post('/qa', async (req, res) => {
 
   let ns = namespaces.find(n => n.id === data.namespace);
   data.engine = ns.engine || default_engine;
-  data.hybrid = ns.hybrid;
 
-  if (data.engine.type === 'serverless') {
+  if (ns.hybrid === true) {
     data.search_type = 'hybrid';
   }
 
@@ -463,7 +462,7 @@ router.get('/namespace/all', async (req, res) => {
 
   let project_id = req.projectid;
 
-  Namespace.find({ id_project: project_id }).lean().exec((err, namespaces) => {
+  Namespace.find({ id_project: project_id }).lean().exec( async (err, namespaces) => {
 
     if (err) {
       winston.error("find namespaces error: ", err);
@@ -500,7 +499,18 @@ router.get('/namespace/all', async (req, res) => {
 
     } else {
 
-      const namespaceObjArray = namespaces.map(({ _id, __v, ...keepAttrs }) => keepAttrs)
+      let namespaceObjArray = [];
+      if (req.query.count) {
+        namespaceObjArray = await Promise.all(
+          namespaces.map(async ({ _id, __v, ...keepAttrs }) => {
+            const count = await KB.countDocuments({ id_project: keepAttrs.id_project, namespace: keepAttrs.id });
+            return { ...keepAttrs, count };
+          })
+        );
+      } else {
+        namespaceObjArray = namespaces.map(({ _id, __v, ...keepAttrs }) => keepAttrs)
+      }
+        
       winston.debug("namespaceObjArray: ", namespaceObjArray);
       return res.status(200).send(namespaceObjArray);
     }

package/routes/project.js

@@ -1059,6 +1059,11 @@ router.get('/:projectid/users/availables', async  (req, res) => {
         return res.status(404).send({ success: false, error: "Group " + group_id + " not found" })
       }
 
+      if (group.enabled === false) {
+        winston.error("(Users Availables) group disabled")
+        return res.status(403).send({ success: false, error: "Group " + group_id + " is currently disabled" })
+      }
+
       query.id_user = { $in: group.members.map(id => mongoose.Types.ObjectId(id) )}
     }
   } 

package/routes/project_user.js

@@ -248,23 +248,18 @@ router.put('/', [passport.authenticate(['basic', 'jwt'], { session: false }), va
     update.tags = req.body.tags;
   }
 
-
-
-
   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);
       return res.status(500).send({ success: false, msg: 'Error updating object.' });
     }
-      updatedProject_user.populate({path:'id_user', select:{'firstname':1, 'lastname':1}},function (err, updatedProject_userPopulated){    
-
-        var pu = updatedProject_userPopulated.toJSON();
-        pu.isBusy = ProjectUserUtil.isBusy(updatedProject_userPopulated, req.project.settings && req.project.settings.max_agent_assigned_chat);
-        
-        authEvent.emit('project_user.update', {updatedProject_userPopulated:pu, req: req});
-      });
     
-
+    updatedProject_user.populate({ path:'id_user', select: { 'firstname': 1, 'lastname': 1 }}, function (err, updatedProject_userPopulated) {    
+      var pu = updatedProject_userPopulated.toJSON();
+      pu.isBusy = ProjectUserUtil.isBusy(updatedProject_userPopulated, req.project.settings && req.project.settings.max_agent_assigned_chat);
+      authEvent.emit('project_user.update', {updatedProject_userPopulated:pu, req: req});
+    });
+    
     res.json(updatedProject_user);
   });
 });
@@ -300,8 +295,9 @@ router.put('/:project_userid', [passport.authenticate(['basic', 'jwt'], { sessio
     update.attributes = req.body.attributes;
   }
 
-  if (req.body.status!=undefined) {
-    update.status = req.body.status;
+  const allowedStatuses = ['active', 'disabled'];
+  if (req.body.status !== undefined && allowedStatuses.includes(req.body.status)) {
+      update.status = req.body.status;
   }
 
   if (req.body["settings.email.notification.conversation.assigned.toyou"]!=undefined) {
@@ -345,21 +341,45 @@ router.put('/:project_userid', [passport.authenticate(['basic', 'jwt'], { sessio
 router.delete('/:project_userid', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], function (req, res) {
 
   winston.debug(req.body);
+  
+  if (req.query.force === "true") {
 
-  Project_user.findByIdAndRemove(req.params.project_userid, { new: false}, function (err, project_user) {
-    if (err) {
-      winston.error("Error gettting project_user for delete", err);
-      return res.status(500).send({ success: false, msg: 'Error deleting object.' });
-    }
+    Project_user.findByIdAndRemove(req.params.project_userid, { new: false }, function (err, project_user) {
+      if (err) {
+        winston.error("Error gettting project_user for delete", err);
+        return res.status(500).send({ success: false, msg: 'Error deleting object.' });
+      }
 
-    winston.debug("Removed project_user", project_user);
+      winston.debug("Physically removed project_user", project_user);
 
-    project_user.populate({path:'id_user', select:{'firstname':1, 'lastname':1}},function (err, project_userPopulated){   
-      authEvent.emit('project_user.delete', {req: req, project_userPopulated: project_userPopulated});
+      if (project_user) {
+        project_user.populate({ path: 'id_user', select: { 'firstname': 1, 'lastname': 1 } }, function (err, project_userPopulated) {
+          authEvent.emit('project_user.delete', { req: req, project_userPopulated: project_userPopulated });
+        });
+      }
+
+      res.json(project_user);
     });
-    
-    res.json(project_user);
-  });
+  } else {
+
+    Project_user.findByIdAndUpdate(req.params.project_userid, { status: "disabled", user_available: false }, { new: true }, function (err, project_user) {
+        if (err) {
+          winston.error("Error gettting project_user for logical delete", err);
+          return res.status(500).send({ success: false, msg: 'Error disabling object.' });
+        }
+
+        winston.debug("Logically disabled project_user", project_user);
+
+        if (project_user) {
+          project_user.populate({ path: 'id_user', select: { 'firstname': 1, 'lastname': 1 } }, function (err, project_userPopulated) {
+            authEvent.emit('project_user.delete', { req: req, project_userPopulated: project_userPopulated });
+          });
+        }
+
+        res.json(project_user);
+      }
+    );
+  }
 });
 
 router.get('/:project_userid', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('agent', ['subscription'])], function (req, res) {
@@ -498,7 +518,7 @@ router.get('/', [passport.authenticate(['basic', 'jwt'], { session: false }), va
   }
   winston.debug("role", role);
 
-  var query =  {id_project: req.projectid, role: { $in : role } };
+  var query = { id_project: req.projectid, role: { $in : role } }; //, status: 'active'
 
   if (req.query.presencestatus) {
     query["presence.status"] = req.query.presencestatus;
@@ -506,6 +526,10 @@ router.get('/', [passport.authenticate(['basic', 'jwt'], { session: false }), va
 
   winston.debug("query", query);
 
+  if (req.query.status) {
+    query["status"] = req.query.status;
+  }
+
   Project_user.find(query).
     populate('id_user').
     // lean().                   

package/services/departmentService.js

@@ -360,7 +360,7 @@ getOperators(departmentid, projectid, nobot, disableWebHookCall, context) {
 
   return new Promise(function (resolve, reject) {
 
-    return Group.find({ _id: department.id_group }).exec(function (err, group) {
+    return Group.find({ _id: department.id_group, enabled: true }).exec(function (err, group) {
       if (err) {
         winston.error('D-2 GROUP -> [ FIND PROJECT USERS: ALL and AVAILABLE (with OH) ] -> ERR ', err)
         return reject(err);
@@ -603,6 +603,21 @@ getDefaultDepartment(projectid) {
   }
 }
 
+  /**
+   * Checks if the group belongs to a department of the project
+   * @param {String} projectId
+   * @param {String} groupId
+   * @returns {Promise<Boolean>} true if the group belongs to a department of the project, otherwise false
+   */
+  async isGroupInProjectDepartment(projectId, groupId) {
+    try {
+      const department = await Department.findOne({ id_project: projectId, id_group: groupId });
+      return !!department;
+    } catch (err) {
+      winston.error('Error in isGroupInProjectDepartment', err);
+      return false;
+    }
+  }
 
 
 }

package/services/requestService.js

@@ -1757,7 +1757,7 @@ class RequestService {
 
 
           if (err) {
-            winston.error("Error getting closing request ", err);
+            winston.error("Error getting closing request with request_id: " + request_id, err);
             return reject(err);
           }
           if (!request) {