@tiledesk/tiledesk-server 2.19.12 → 2.19.14

package/routes/dataTable.js

@@ -0,0 +1,280 @@
+const express = require('express');
+const router = express.Router();
+const winston = require('../config/winston');
+const dataTableService = require('../services/dataTableService');
+
+function getRowPayload(body) {
+  if (body && body.data && typeof body.data === 'object' && !Array.isArray(body.data)) {
+    return body.data;
+  }
+  return body;
+}
+
+function isValidationError(err) {
+  if (!err || !err.message) return false;
+  const msg = err.message;
+  return msg.indexOf('does not exist') !== -1 ||
+    msg.indexOf('required') !== -1 ||
+    msg.indexOf('Invalid') !== -1 ||
+    msg.indexOf('must be') !== -1 ||
+    msg.indexOf('already exists') !== -1 ||
+    msg.indexOf('Column id') !== -1 ||
+    msg.indexOf('not provided') !== -1 ||
+    msg.indexOf('Operator') !== -1 ||
+    msg.indexOf('id_row or conditions') !== -1 ||
+    msg.indexOf('data is required') !== -1 ||
+    msg.indexOf('valid JSON') !== -1;
+}
+
+function handleError(res, err, action) {
+  if (err && err.message === 'TABLE_SIZE_LIMIT_EXCEEDED') {
+    return res.status(413).send({ success: false, message: 'TABLE_SIZE_LIMIT_EXCEEDED' });
+  }
+  if (isValidationError(err)) {
+    const status = err.message.indexOf('already exists') !== -1 ? 409 : 400;
+    return res.status(status).send({ success: false, message: err.message });
+  }
+  if (err.message === 'Column not found' || err.message.indexOf('Column not found:') === 0) {
+    return res.status(404).send({ success: false, message: err.message });
+  }
+  winston.error('DataTable ' + action + ': ', err);
+  return res.status(500).send({ success: false, error: 'Error ' + action });
+}
+
+// --- Tables ---
+
+router.get('/', async function (req, res) {
+  try {
+    res.status(200).send(await dataTableService.listTables(req.projectid));
+  } catch (err) {
+    handleError(res, err, 'finding tables');
+  }
+});
+
+router.get('/:id', async function (req, res) {
+  try {
+    const table = await dataTableService.getTable(req.projectid, req.params.id);
+    if (!table) return res.status(404).send({ success: false, error: 'Table not found' });
+    res.status(200).send(table);
+  } catch (err) {
+    handleError(res, err, 'finding table');
+  }
+});
+
+router.post('/', async function (req, res) {
+  try {
+    const table = await dataTableService.createTable(
+      req.projectid,
+      req.body,
+      req.user.id || req.user._id
+    );
+    res.status(200).send(table);
+  } catch (err) {
+    handleError(res, err, 'creating table');
+  }
+});
+
+router.put('/:id', async function (req, res) {
+  try {
+    const table = await dataTableService.updateTable(req.projectid, req.params.id, req.body);
+    if (!table) return res.status(404).send({ success: false, error: 'Table not found' });
+    res.status(200).send(table);
+  } catch (err) {
+    handleError(res, err, 'updating table');
+  }
+});
+
+router.delete('/:id', async function (req, res) {
+  try {
+    const deleted = await dataTableService.deleteTable(req.projectid, req.params.id);
+    if (!deleted) return res.status(404).send({ success: false, error: 'Table not found' });
+    res.status(200).send({ success: true, message: 'Table deleted successfully' });
+  } catch (err) {
+    handleError(res, err, 'deleting table');
+  }
+});
+
+// --- Columns ---
+
+router.post('/:id/columns', async function (req, res) {
+  try {
+    const table = await dataTableService.addColumn(req.projectid, req.params.id, req.body);
+    if (!table) return res.status(404).send({ success: false, error: 'Table not found' });
+    res.status(200).send(table);
+  } catch (err) {
+    handleError(res, err, 'adding column');
+  }
+});
+
+router.patch('/:id/columns/:columnId', async function (req, res) {
+  try {
+    const table = await dataTableService.renameColumn(
+      req.projectid,
+      req.params.id,
+      req.params.columnId,
+      req.body.name
+    );
+    if (!table) return res.status(404).send({ success: false, error: 'Table not found' });
+    res.status(200).send(table);
+  } catch (err) {
+    handleError(res, err, 'renaming column');
+  }
+});
+
+router.delete('/:id/columns/:columnId', async function (req, res) {
+  try {
+    const table = await dataTableService.deleteColumn(
+      req.projectid,
+      req.params.id,
+      req.params.columnId
+    );
+    if (!table) return res.status(404).send({ success: false, error: 'Table not found' });
+    res.status(200).send(table);
+  } catch (err) {
+    handleError(res, err, 'deleting column');
+  }
+});
+
+// --- Rows (insert / update / upsert / delete by id_row or conditions) ---
+
+function getRowsListParams(req) {
+  var params = Object.assign({}, req.query);
+  if (req.body && typeof req.body === 'object' && !Array.isArray(req.body)) {
+    if (req.body.must_match !== undefined) params.must_match = req.body.must_match;
+    if (req.body.match !== undefined) params.match = req.body.match;
+    if (req.body.conditions !== undefined) params.conditions = req.body.conditions;
+  }
+  return params;
+}
+
+router.get('/:id/rows/list', async function (req, res) {
+
+  console.log("List rows")
+  try {
+    const rows = await dataTableService.listRowsWithFilter(
+      req.projectid,
+      req.params.id,
+      Object.assign({}, getRowsListParams(req), { sort: -1, limit: 200 })
+    );
+    if (rows === null) return res.status(404).send({ success: false, error: 'Table not found' });
+    res.status(200).send(rows);
+  } catch (err) {
+    handleError(res, err, 'listing rows');
+  }
+});
+
+router.post('/:id/row/insert', async function (req, res) {
+  console.log("Insert row")
+  try {
+    const row = await dataTableService.insertRowByBody(req.projectid, req.params.id, req.body);
+    if (!row) return res.status(404).send({ success: false, error: 'Table not found' });
+    res.status(200).send(row);
+  } catch (err) {
+    handleError(res, err, 'inserting row');
+  }
+});
+
+router.put('/:id/row/update', async function (req, res) {
+  try {
+    const row = await dataTableService.updateRowByBody(req.projectid, req.params.id, req.body);
+    if (row === null) return res.status(404).send({ success: false, error: 'Table not found' });
+    if (row === undefined) return res.status(404).send({ success: false, error: 'Row not found' });
+    res.status(200).send(row);
+  } catch (err) {
+    handleError(res, err, 'updating row');
+  }
+});
+
+router.put('/:id/row/upsert', async function (req, res) {
+  try {
+    const result = await dataTableService.upsertRowByBody(req.projectid, req.params.id, req.body);
+    if (result === null) return res.status(404).send({ success: false, error: 'Table not found' });
+    res.status(200).send(result);
+  } catch (err) {
+    if (err.message === 'Multiple rows match the conditions') {
+      return res.status(409).send({ success: false, message: err.message });
+    }
+    handleError(res, err, 'upserting row');
+  }
+});
+
+router.put('/:id/row/delete', async function (req, res) {
+  try {
+    const row = await dataTableService.deleteRowByBody(req.projectid, req.params.id, req.body);
+    if (row === null) return res.status(404).send({ success: false, error: 'Table not found' });
+    if (row === undefined) return res.status(404).send({ success: false, error: 'Row not found' });
+    res.status(200).send(row);
+  } catch (err) {
+    handleError(res, err, 'deleting row');
+  }
+});
+
+// --- Rows (REST) ---
+
+// router.get('/:id/rows', async function (req, res) {
+//   try {
+//     const rows = await dataTableService.listRows(req.projectid, req.params.id);
+//     if (rows === null) return res.status(404).send({ success: false, error: 'Table not found' });
+//     res.status(200).send(rows);
+//   } catch (err) {
+//     handleError(res, err, 'finding rows');
+//   }
+// });
+
+// router.get('/:id/rows/:rowId', async function (req, res) {
+//   try {
+//     const row = await dataTableService.getRow(req.projectid, req.params.id, req.params.rowId);
+//     if (!row) return res.status(404).send({ success: false, error: 'Row not found' });
+//     res.status(200).send(row);
+//   } catch (err) {
+//     handleError(res, err, 'finding row');
+//   }
+// });
+
+// router.post('/:id/rows', async function (req, res) {
+//   try {
+//     const row = await dataTableService.insertRow(req.projectid, req.params.id, getRowPayload(req.body));
+//     if (!row) return res.status(404).send({ success: false, error: 'Table not found' });
+//     res.status(200).send(row);
+//   } catch (err) {
+//     handleError(res, err, 'inserting row');
+//   }
+// });
+
+// router.put('/:id/rows/:rowId', async function (req, res) {
+//   try {
+//     const row = await dataTableService.updateRow(
+//       req.projectid,
+//       req.params.id,
+//       req.params.rowId,
+//       getRowPayload(req.body)
+//     );
+//     if (row === null) return res.status(404).send({ success: false, error: 'Table not found' });
+//     if (row === undefined) return res.status(404).send({ success: false, error: 'Row not found' });
+//     res.status(200).send(row);
+//   } catch (err) {
+//     handleError(res, err, 'updating row');
+//   }
+// });
+
+// router.delete('/:id/rows/:rowId', async function (req, res) {
+//   try {
+//     const row = await dataTableService.deleteRow(req.projectid, req.params.id, req.params.rowId);
+//     if (!row) return res.status(404).send({ success: false, error: 'Row not found' });
+//     res.status(200).send(row);
+//   } catch (err) {
+//     handleError(res, err, 'deleting row');
+//   }
+// });
+
+// router.post('/:id/rows/search', async function (req, res) {
+//   try {
+//     const rows = await dataTableService.searchRows(req.projectid, req.params.id, req.body);
+//     if (rows === null) return res.status(404).send({ success: false, error: 'Table not found' });
+//     res.status(200).send(rows);
+//   } catch (err) {
+//     handleError(res, err, 'searching rows');
+//   }
+// });
+
+module.exports = router;

package/routes/faq_kb.js

@@ -52,6 +52,9 @@ router.post('/', roleChecker.hasRole('admin'), async function (req, res) {
   }
 
   faqService.create(req.projectid, req.user.id, req.body).then((savedFaq_kb) => {
+    if (req.query.skip_activity !== 'true') {
+      botEvent.emit('faqbot.created', { req, chatbot: savedFaq_kb });
+    }
     res.status(200).send(savedFaq_kb);
   }).catch((err) => {
     res.status(500).send({ succes: false, error: err })
@@ -269,7 +272,7 @@ router.put('/:faq_kbid/publish', roleChecker.hasRole('admin'), async (req, res)
 
   try {
     //  fork(id_faq_kb, api_url, token, project_id)
-    let forked = await cs.fork(chatbot_id, api_url, token, current_project_id);
+    let forked = await cs.fork(chatbot_id, api_url, token, current_project_id, { forPublish: true });
     // winston.debug("forked: ", forked)
 
     let forkedChatBotId = forked.bot_id;
@@ -294,6 +297,13 @@ router.put('/:faq_kbid/publish', roleChecker.hasRole('admin'), async (req, res)
 
     botEvent.emit('faqbot.update', updatedOriginalChabot);
 
+    botEvent.emit('faqbot.publish', {
+      req: req,
+      chatbot: updatedOriginalChabot,
+      publishedBotId: forkedChatBotId,
+      release_note: release_note
+    });
+
     return res.status(200).send({ message: "Chatbot published successfully", bot_id: forkedChatBotId });
 
   } catch (e) {
@@ -355,6 +365,13 @@ router.put('/:faq_kbid', roleChecker.hasRoleOrTypes('admin', ['bot', 'subscripti
     }
 
     botEvent.emit('faqbot.update', updatedFaq_kb);
+
+    // A soft-delete is performed via PUT by setting trashed: true (the schema applies a TTL).
+    // Emit faqbot.deleted so the deletion is tracked just like the hard-delete endpoint.
+    if (req.body.trashed === true || req.body.trashed === 'true') {
+      botEvent.emit('faqbot.deleted', { req, chatbot: updatedFaq_kb });
+    }
+
     res.json(updatedFaq_kb);
   });
 });
@@ -460,6 +477,7 @@ router.delete('/:faq_kbid', roleChecker.hasRole('admin'), function (req, res) {
      * WARNING: faq_kb is the operation result, not the faq_kb object. The event subscriber will not receive the object as expected.
      */
     botEvent.emit('faqbot.delete', faq_kb);
+    botEvent.emit('faqbot.deleted', { req, chatbot: faq_kb });
     res.status(200).send({ success: true, message: "Chatbot with id " + req.params.faq_kbid + " deleted successfully" })
   });
 });
@@ -707,6 +725,10 @@ router.post('/fork/:id_faq_kb', roleChecker.hasRole('admin'), async (req, res) =
     return res.status(500).send({ success: false, message: "Unable to import intents in the new chatbot" });
   }
 
+  if (req.query.for_publish !== 'true') {
+    botEvent.emit('faqbot.created', { req, chatbot: savedChatbot, id_project: landing_project_id });
+  }
+
   return res.status(200).send({ message: "Chatbot forked successfully", bot_id: savedChatbot._id });
 
 })
@@ -774,6 +796,7 @@ router.post('/importjson/:id_faq_kb', roleChecker.hasRole('admin'), upload.singl
     })
 
     botEvent.emit('faqbot.create', savedChatbot);
+    botEvent.emit('faqbot.created', { req, chatbot: savedChatbot });
 
     if (json.intents) {
 

package/routes/kb.js

@@ -894,7 +894,13 @@ router.delete('/deleteall', async (req, res) => {
 
   aiService.deleteNamespace(data).then((resp) => {
     winston.debug("delete namespace resp: ", resp.data);
-    kbEvent.emit('kb.contents.delete', { req, namespace_id, project_id });
+    kbEvent.emit('kb.contents.delete', {
+      req,
+      namespace_id,
+      project_id,
+      namespace_name: namespace.name,
+      deleteMode: 'contents_only'
+    });
     res.status(200).send(resp.data);
   }).catch((err) => {
     winston.error("delete namespace err: ", err);
@@ -1443,7 +1449,14 @@ router.delete('/namespace/:id', async (req, res) => {
       })
       winston.debug("delete all contents response: ", deleteResponse);
 
-      kbEvent.emit('kb.contents.delete', { req, namespace_id, project_id, deletedCount: deleteResponse?.deletedCount });
+      kbEvent.emit('kb.contents.delete', {
+        req,
+        namespace_id,
+        project_id,
+        namespace_name: namespace.name,
+        deletedCount: deleteResponse?.deletedCount,
+        deleteMode: 'contents_only'
+      });
 
       return res.status(200).send({ success: true, message: "All contents deleted successfully" })
 
@@ -1485,6 +1498,14 @@ router.delete('/namespace/:id', async (req, res) => {
       })
       winston.debug("delete namespace response: ", deleteNamespaceResponse);
 
+      kbEvent.emit('kb.namespace.delete', {
+        req,
+        namespace_id,
+        project_id,
+        namespace_name: namespace.name,
+        deletedCount: deleteResponse?.deletedCount
+      });
+
       return res.status(200).send({ success: true, message: "Namespace deleted succesfully" })
 
     }).catch((err) => {
@@ -1757,6 +1778,18 @@ router.post('/', async (req, res) => {
       }
 
       aiManager.scheduleScrape([json], namespace.hybrid);
+
+      kbEvent.emit('kb.contents.add', {
+        req,
+        project_id: id_project,
+        namespace_id: namespace_id,
+        namespace_name: namespace.name,
+        contentAddType: 'content',
+        count: 1,
+        type: saved_kb.type,
+        source: saved_kb.source || saved_kb.name
+      });
+
       return res.status(200).send(raw_content);
 
     }
@@ -1825,6 +1858,14 @@ router.post('/multi', upload.single('uploadFile'), async (req, res) => {
 
   try {
     const result = await aiManager.addMultipleUrls(namespace, list, options);
+    kbEvent.emit('kb.contents.add', {
+      req,
+      project_id: id_project,
+      namespace_id: namespace_id,
+      namespace_name: namespace.name,
+      contentAddType: 'url_list',
+      count: list.length
+    });
     return res.status(200).send(result);
   } catch (err) {
     winston.error("addMultipleUrls error: ", err)
@@ -1931,6 +1972,16 @@ router.post('/csv', upload.single('uploadFile'), async (req, res) => {
         }
 
         aiManager.scheduleScrape(resources, hybrid);
+
+        kbEvent.emit('kb.contents.add', {
+          req,
+          project_id: project_id,
+          namespace_id: namespace_id,
+          namespace_name: namespace.name,
+          contentAddType: 'csv',
+          count: kbs.length
+        });
+
         return res.status(200).send(result);
 
       }).catch((err) => {
@@ -2068,6 +2119,18 @@ router.post('/sitemap/import', async (req, res) => {
       return res.status(200).send(result);
     }
     result.push(saved_content);
+
+    kbEvent.emit('kb.contents.add', {
+      req,
+      project_id: id_project,
+      namespace_id: namespace_id,
+      namespace_name: namespace.name,
+      contentAddType: 'sitemap',
+      count: urls.length,
+      type: 'sitemap',
+      source: source
+    });
+
     return res.status(200).send(result);
   } catch (err) {
     return res.status(500).send({ success: false, error: "Unable to add multiple urls from sitemap due to an error." });
@@ -2279,6 +2342,29 @@ router.delete('/:kb_id', async (req, res) => {
   data.engine = namespace.engine || default_engine;
   winston.verbose("/:delete_id data: ", data);
 
+  const emitKbContentDelete = (deletedKb) => {
+    const content = deletedKb || kb;
+    const contentSnapshot = content.toObject ? content.toObject() : content;
+    kbEvent.emit('kb.content.delete', {
+      req,
+      kb_id,
+      project_id,
+      namespace_id,
+      namespace_name: namespace.name,
+      kb: {
+        _id: contentSnapshot._id,
+        name: contentSnapshot.name,
+        source: contentSnapshot.source,
+        type: contentSnapshot.type
+      }
+    });
+  };
+
+  if (process.env.NODE_ENV === 'test') {
+    emitKbContentDelete(kb);
+    return res.status(200).send({ success: true, message: "Content deleted successfully" });
+  }
+
   aiService.deleteIndex(data).then((resp) => {
     winston.debug("delete resp: ", resp.data);
     if (resp.data.success === true) {
@@ -2288,6 +2374,7 @@ router.delete('/:kb_id', async (req, res) => {
           winston.error("Delete kb error: ", err);
           return res.status(500).send({ success: false, error: err });
         }
+        emitKbContentDelete(deletedKb);
         res.status(200).send(deletedKb);
       })
 
@@ -2303,6 +2390,7 @@ router.delete('/:kb_id', async (req, res) => {
           winston.verbose("Unable to delete the content in indexing status")
           return res.status(500).send({ success: false, error: "Unable to delete the content in indexing status" })
         } else {
+          emitKbContentDelete(deletedKb);
           res.status(200).send(deletedKb);
         }
       })

package/routes/project_user.js

@@ -18,6 +18,25 @@ var validtoken = require('../middleware/valid-token')
 var roleChecker = require('../middleware/has-role');
 const puEvent = require('../event/projectUserEvent');
 const { track } = require('../lib/analyticsClient');
+const projectUserUpdateContextUtil = require('../utils/projectUserUpdateContextUtil');
+
+function emitProjectUserDeleteActivity(req, project_user, deleteType) {
+  if (!project_user) {
+    return;
+  }
+  project_user.populate({ path: 'id_user', select: { firstname: 1, lastname: 1, email: 1 } }, function (populateErr, project_userPopulated) {
+    if (populateErr) {
+      winston.error('Error populating project_user for delete activity', populateErr);
+    }
+    const pu = project_userPopulated || project_user;
+    const payload = pu.toJSON ? pu.toJSON() : pu;
+    authEvent.emit('project_user.delete', {
+      req: req,
+      project_userPopulated: payload,
+      deleteType: deleteType
+    });
+  });
+}
 
 
 router.post('/invite', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], function (req, res) {
@@ -111,15 +130,19 @@ router.post('/invite', [passport.authenticate(['basic', 'jwt'], { session: false
 
             emailService.sendYouHaveBeenInvited(email, req.user.firstname, req.user.lastname, req.project.name, id_project, user.firstname, user.lastname, req.body.role)
 
-            updatedPuser.populate({path:'id_user', select:{'firstname':1, 'lastname':1, 'email': 1}},function (err, updatedPuserPopulated){
-              var pu = updatedPuserPopulated.toJSON();
+            savedProject_user.populate({path:'id_user', select:{'firstname':1, 'lastname':1, 'email': 1}},function (err, savedProject_userPopulated){
+              if (err) {
+                winston.error("Error populating project user after re-invite", err);
+                return;
+              }
+              var pu = savedProject_userPopulated.toJSON();
               pu.isBusy = ProjectUserUtil.isBusy(savedProject_userPopulated, req.project.settings && req.project.settings.max_agent_assigned_chat);
-              var eventData = {req:req, updatedPuserPopulated: pu};
+              var eventData = {req:req, savedProject_userPopulated: pu};
               winston.debug("eventData",eventData);
               authEvent.emit('project_user.invite', eventData);
             });
 
-            return res.status(200).send(updatedPuser);
+            return res.status(200).send(savedProject_user);
           })
 
         } else {
@@ -220,6 +243,13 @@ router.put('/', [passport.authenticate(['basic', 'jwt'], { session: false }), va
   }
 
   const previousUserAvailable = req.projectuser.user_available;
+  const previousProfileStatus = req.projectuser.profileStatus;
+  const updateContext = projectUserUpdateContextUtil.buildProjectUserUpdateContext(
+    req,
+    previousUserAvailable,
+    previousProfileStatus,
+    projectUserUpdateContextUtil.resolveUserId(req.projectuser.id_user)
+  );
 
   Project_user.findByIdAndUpdate(req.projectuser.id, update,  { new: true, upsert: true }, function (err, updatedProject_user) {
     if (err) {
@@ -230,7 +260,13 @@ router.put('/', [passport.authenticate(['basic', 'jwt'], { session: false }), va
     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, previousUserAvailable: previousUserAvailable});
+      authEvent.emit('project_user.update', {
+        updatedProject_userPopulated: pu,
+        req: req,
+        previousUserAvailable: previousUserAvailable,
+        previousProfileStatus: previousProfileStatus,
+        updateContext: updateContext
+      });
     });
     
     res.json(updatedProject_user);
@@ -286,7 +322,14 @@ router.put('/:project_userid', [passport.authenticate(['basic', 'jwt'], { sessio
 
   winston.debug("project_userid update", update);
 
-  function _doUpdateProjectUser(previousUserAvailable) {
+  function _doUpdateProjectUser(previousUserAvailable, previousProfileStatus, targetUserId) {
+    const updateContext = projectUserUpdateContextUtil.buildProjectUserUpdateContext(
+      req,
+      previousUserAvailable,
+      previousProfileStatus,
+      targetUserId
+    );
+
     Project_user.findByIdAndUpdate(req.params.project_userid, update, { new: true, upsert: true }, function (err, updatedProject_user) {
       if (err) {
         winston.error("Error gettting project_user for update", err);
@@ -299,7 +342,13 @@ router.put('/:project_userid', [passport.authenticate(['basic', 'jwt'], { sessio
           var pu = updatedProject_userPopulated.toJSON();
           pu.isBusy = ProjectUserUtil.isBusy(updatedProject_user, req.project.settings && req.project.settings.max_agent_assigned_chat);
           
-            authEvent.emit('project_user.update', {updatedProject_userPopulated:pu, req: req, previousUserAvailable: previousUserAvailable});
+            authEvent.emit('project_user.update', {
+              updatedProject_userPopulated: pu,
+              req: req,
+              previousUserAvailable: previousUserAvailable,
+              previousProfileStatus: previousProfileStatus,
+              updateContext: updateContext
+            });
         });
       
 
@@ -307,12 +356,16 @@ router.put('/:project_userid', [passport.authenticate(['basic', 'jwt'], { sessio
     });
   }
 
-  if (update.user_available !== undefined && process.env.ANALYTICS_INGEST_URL) {
-    Project_user.findById(req.params.project_userid, 'user_available').lean().exec(function(err, currentPu) {
-      _doUpdateProjectUser(currentPu ? currentPu.user_available : null);
+  if (update.user_available !== undefined || update.profileStatus !== undefined) {
+    Project_user.findById(req.params.project_userid, 'user_available profileStatus id_user').lean().exec(function(err, currentPu) {
+      _doUpdateProjectUser(
+        currentPu ? currentPu.user_available : null,
+        currentPu ? currentPu.profileStatus : null,
+        currentPu ? currentPu.id_user : null
+      );
     });
   } else {
-    _doUpdateProjectUser(null);
+    _doUpdateProjectUser(null, null, null);
   }
 });
 
@@ -340,7 +393,7 @@ router.delete('/:project_userid', [passport.authenticate(['basic', 'jwt'], { ses
       }
 
       puEvent.emit('project_user.deleted', project_user);
-      // Event 'project_user.delete' not working - Check it and improve it to manage soft/hard delete
+      emitProjectUserDeleteActivity(req, project_user, 'soft');
       return res.status(200).send(project_user);
 
     })
@@ -360,11 +413,7 @@ router.delete('/:project_userid', [passport.authenticate(['basic', 'jwt'], { ses
 
       winston.debug("Hard deleted 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 });
-        });
-      }
+      emitProjectUserDeleteActivity(req, project_user, 'hard');
 
       puEvent.emit('project_user.deleted', project_user);
       return res.status(200).send(project_user);