@tiledesk/tiledesk-server 2.19.13 → 2.19.14

package/services/requestService.js

@@ -10,6 +10,7 @@ const leadEvent = require('../event/leadEvent');
 var winston = require('../config/winston');
 var RequestConstants = require("../models/requestConstants");
 var requestUtil = require("../utils/requestUtil");
+var assignmentContextUtil = require("../utils/assignmentContextUtil");
 var cacheUtil = require("../utils/cacheUtil");
 var arrayUtil = require("../utils/arrayUtil");
 var cacheEnabler = require("../services/cacheEnabler");
@@ -245,7 +246,7 @@ class RequestService {
 
   // TODO  changePreflightByRequestId se un agente entra in request freflight true disabilitare add agente e reassing ma mettere un bottone removePreflight???
   // usalo no_populate
-  async route(request_id, departmentid, id_project, nobot, no_populate) {
+  async route(request_id, departmentid, id_project, nobot, no_populate, options) {
 
     try {
       winston.debug("request_id:" + request_id);
@@ -324,7 +325,13 @@ class RequestService {
         this.emitParticipantsEvents(
           request,
           requestComplete,
-          beforeParticipants
+          beforeParticipants,
+          options,
+          beforeDepartmentId !== afterDepartmentId ? {
+            previousDepartmentId: beforeDepartmentId,
+            departmentId: afterDepartmentId,
+            departmentName: requestComplete.department && requestComplete.department.name
+          } : undefined
         );
   
         return requestComplete;
@@ -379,10 +386,18 @@ class RequestService {
         .execPopulate();
 
 
+      const departmentChange = beforeDepartmentId !== afterDepartmentId ? {
+        previousDepartmentId: beforeDepartmentId,
+        departmentId: afterDepartmentId,
+        departmentName: requestComplete.department && requestComplete.department.name
+      } : undefined;
+
       this.emitParticipantsEvents(
         request,
         requestComplete,
-        beforeParticipants
+        beforeParticipants,
+        options,
+        departmentChange
       );
 
       requestEvent.emit("request.department.update", requestComplete);
@@ -396,9 +411,14 @@ class RequestService {
   }
 
 
-  reroute(request_id, id_project, nobot) {
+  reroute(request_id, id_project, nobot, options) {
     var that = this;
     var startDate = new Date();
+    const assignmentOptions = options || {
+      actor: assignmentContextUtil.systemActor(),
+      source: 'queue',
+      assignmentType: 'auto'
+    };
     return new Promise(function (resolve, reject) {
       // winston.debug("request_id", request_id);
       // winston.debug("newstatus", newstatus);
@@ -432,7 +452,7 @@ class RequestService {
         }
 
 
-        return that.route(request_id, request.department.toString(), id_project, nobot).then(function (routedRequest) {
+        return that.route(request_id, request.department.toString(), id_project, nobot, undefined, assignmentOptions).then(function (routedRequest) {
 
           var endDate = new Date();
           winston.verbose("Performance Request reroute in millis: " + endDate - startDate);
@@ -1528,10 +1548,11 @@ class RequestService {
 
 
 
-  setParticipantsByRequestId(request_id, id_project, newparticipants) {
+  setParticipantsByRequestId(request_id, id_project, newparticipants, options) {
 
     //TODO validate participants
     // validate if array of string newparticipants
+    var that = this;
     return new Promise(function (resolve, reject) {
 
       var isArray = Array.isArray(newparticipants);
@@ -1677,6 +1698,14 @@ class RequestService {
                   request: requestComplete
                 });
 
+                that.emitAssignedEvent(requestComplete, {
+                  assignmentType: options && options.assignmentType,
+                  actor: options && options.actor,
+                  source: options && options.source,
+                  addedParticipants: addedParticipants,
+                  removedParticipants: removedParticipants
+                });
+
                 // TODO allora neanche qui participatingAgent è ok?
                 return resolve(requestComplete);
               });
@@ -1688,12 +1717,12 @@ class RequestService {
     });
   }
 
-  addParticipantByRequestId(request_id, id_project, member) {
+  addParticipantByRequestId(request_id, id_project, member, options) {
     winston.debug("request_id: " + request_id);
     winston.debug("id_project: " + id_project);
     winston.debug("addParticipantByRequestId member: " + member);
 
-
+    var that = this;
 
     //TODO control if member is a valid project_user of the project
     // validate member is string
@@ -1776,6 +1805,14 @@ class RequestService {
                   requestEvent.emit("request.updated", { comment: "PARTICIPANT_ADD", request: requestComplete, patch: { member: member } });
                   requestEvent.emit('request.participants.join', { member: member, request: requestComplete });
 
+                  that.emitAssignedEvent(requestComplete, {
+                    assignmentType: options && options.assignmentType,
+                    actor: options && options.actor,
+                    source: options && options.source,
+                    addedParticipants: [member],
+                    removedParticipants: []
+                  });
+
                   return resolve(requestComplete);
                 });
             });
@@ -1797,7 +1834,7 @@ class RequestService {
     });
   }
 
-  removeParticipantByRequestId(request_id, id_project, member) {
+  removeParticipantByRequestId(request_id, id_project, member, options) {
     winston.debug("request_id", request_id);
     winston.debug("id_project", id_project);
     winston.debug("member", member);
@@ -1923,7 +1960,13 @@ class RequestService {
                   requestEvent.emit('request.update', requestComplete);
                   requestEvent.emit("request.update.comment", { comment: "PARTICIPANT_REMOVE", request: requestComplete });//Deprecated
                   requestEvent.emit("request.updated", { comment: "PARTICIPANT_REMOVE", request: requestComplete, patch: { member: member } });
-                  requestEvent.emit('request.participants.leave', { member: member, request: requestComplete });
+                  requestEvent.emit('request.participants.leave', {
+                    member: member,
+                    request: requestComplete,
+                    actor: options && options.actor,
+                    source: options && options.source,
+                    trackLeave: options && options.trackLeave
+                  });
 
 
                   return resolve(requestComplete);
@@ -2487,7 +2530,8 @@ class RequestService {
     })
   }
 
-  emitParticipantsEvents(beforeRequest, requestComplete, oldParticipants) {
+  emitParticipantsEvents(beforeRequest, requestComplete, oldParticipants, options, departmentChange) {
+    const that = this;
     const newParticipants = requestComplete.participants;
   
     const removedParticipants = oldParticipants.filter(
@@ -2510,6 +2554,110 @@ class RequestService {
       addedParticipants,
       request: requestComplete
     });
+
+    that.emitAssignedEvent(requestComplete, {
+      assignmentType: options && options.assignmentType,
+      actor: options && options.actor,
+      source: options && options.source,
+      addedParticipants,
+      removedParticipants,
+      departmentChange
+    });
+  }
+
+  emitAssignedEvent(requestComplete, context) {
+    const {
+      assignmentType,
+      actor,
+      source,
+      addedParticipants = [],
+      removedParticipants = [],
+      departmentChange
+    } = context || {};
+
+    const humanAdded = assignmentContextUtil.filterHumanParticipants(addedParticipants);
+    const humanRemoved = assignmentContextUtil.filterHumanParticipants(removedParticipants);
+    const botAdded = assignmentContextUtil.filterBotParticipants(addedParticipants);
+    const resolvedActor = actor || assignmentContextUtil.systemActor();
+    const resolvedSource = source || 'system';
+
+    if (
+      assignmentType === 'manual_reassign_department' &&
+      departmentChange &&
+      departmentChange.departmentId &&
+      String(departmentChange.departmentId) !== String(departmentChange.previousDepartmentId || '')
+    ) {
+      requestEvent.emit('request.assigned', {
+        request: requestComplete,
+        assigneeId: String(departmentChange.departmentId),
+        assigneeName: departmentChange.departmentName || assignmentContextUtil.resolveDepartmentName(requestComplete),
+        assigneeType: 'department',
+        assignmentType: 'manual_reassign_department',
+        actor: resolvedActor,
+        source: resolvedSource,
+        previousAssigneeId: humanRemoved.length > 0 ? String(humanRemoved[0]) : null,
+        removedParticipants: humanRemoved
+      });
+      return;
+    }
+
+    if (assignmentType === 'manual_reassign_bot' && botAdded.length > 0) {
+      const botId = assignmentContextUtil.botIdFromParticipant(botAdded[0]);
+      requestEvent.emit('request.assigned', {
+        request: requestComplete,
+        assigneeId: botId,
+        assigneeName: assignmentContextUtil.resolveBotName(requestComplete, botId),
+        assigneeType: 'bot',
+        assignmentType: 'manual_reassign_bot',
+        actor: resolvedActor,
+        source: resolvedSource,
+        previousAssigneeId: humanRemoved.length > 0 ? String(humanRemoved[0]) : null,
+        removedParticipants: humanRemoved
+      });
+      return;
+    }
+
+    if (assignmentType === 'unassign' || (humanAdded.length === 0 && humanRemoved.length > 0)) {
+      humanRemoved.forEach((assigneeId) => {
+        requestEvent.emit('request.assigned', {
+          request: requestComplete,
+          assigneeId: String(assigneeId),
+          assignmentType: 'unassign',
+          actor: resolvedActor,
+          source: resolvedSource,
+          removedParticipants: humanRemoved,
+          previousAssigneeId: String(assigneeId)
+        });
+      });
+      return;
+    }
+
+    if (humanAdded.length === 0) {
+      return;
+    }
+
+    const resolvedType = assignmentType || assignmentContextUtil.deriveAssignmentType({
+      actor: resolvedActor,
+      assigneeIds: humanAdded,
+      isUnassign: false
+    });
+
+    if (!resolvedType) {
+      return;
+    }
+
+    humanAdded.forEach((assigneeId) => {
+      requestEvent.emit('request.assigned', {
+        request: requestComplete,
+        assigneeId: String(assigneeId),
+        assigneeType: 'user',
+        assignmentType: resolvedType,
+        actor: resolvedActor,
+        source: resolvedSource,
+        removedParticipants: humanRemoved,
+        previousAssigneeId: humanRemoved.length > 0 ? String(humanRemoved[0]) : null
+      });
+    });
   }
 
 

package/test/faqkbRoute.js

@@ -1217,6 +1217,7 @@ describe('FaqKBRoute', () => {
                                     if (err) { console.error("err: ", err); }
                                     if (log) { console.log("res.body", res.body); }
 
+                                    console.log("chatbot trashed: ", res.body);
                                     res.should.have.status(200);
                                     res.body.should.be.a('object');
                                     expect(res.body.trashed).to.equal(true);

package/test/kbRoute.js

@@ -9,6 +9,7 @@ process.env.PINECONE_INDEX_HYBRID = "test-index-hybrid";
 process.env.PINECONE_TYPE_HYBRID = "serverless";
 process.env.ADMIN_EMAIL = "admin@tiledesk.com";
 process.env.KB_ENDPOINT_TRAIN = "http://kb-train.test";
+process.env.ACTIVITY_HISTORY_ENABLED = true;
 
 var userService = require('../services/userService');
 var projectService = require('../services/projectService');
@@ -792,6 +793,64 @@ describe('KbRoute', () => {
             });
         }).timeout(10000)
 
+        it('delete-content', (done) => {
+
+            var email = "test-signup-" + Date.now() + "@email.com";
+            var pwd = "pwd";
+
+            userService.signup(email, pwd, "Test Firstname", "Test lastname").then(function (savedUser) {
+                projectService.create("test-faqkb-create", savedUser._id).then(function (savedProject) {
+                
+                    chai.request(server)
+                        .get('/' + savedProject._id + '/kb/namespace/all')
+                        .auth(email, pwd)
+                        .end((err, res) => {
+                            if (err) { console.error("err: ", err); }
+                            if (log) { console.log("get namespaces res.body: ", res.body); }
+
+                            res.should.have.status(200);
+
+                            let namespace_id = res.body[0].id;
+
+                            let kb = {
+                                name: "example_text_delete",
+                                type: "text",
+                                source: "example_text_delete",
+                                content: "Example text",
+                                namespace: namespace_id
+                            }
+
+                            chai.request(server)
+                                .post('/' + savedProject._id + '/kb')
+                                .auth(email, pwd)
+                                .send(kb)
+                                .end((err, res) => {
+                                    if (err) { console.error("err: ", err); }
+                                    if (log) { console.log("create kb res.body: ", res.body); }
+
+                                    res.should.have.status(200);
+
+                                    let kb_id = res.body.data.value._id;
+                                    
+                                    chai.request(server)
+                                        .delete('/' + savedProject._id + '/kb/' + kb_id)
+                                        .auth(email, pwd)
+                                        .end((err, res) => {
+                                            if (err) { console.error("err: ", err); }
+                                            if (log) { console.log("delete kb res.body: ", res.body); }
+                                            
+                                            res.should.have.status(200);
+                                            expect(res.body.success).to.equal(true);
+                                            expect(res.body.message).to.equal("Content deleted successfully");
+
+                                            done();
+                                        })
+                                })
+                        })
+                })
+            })
+        })
+
         it('get-content-chunks', (done) => {
 
             var email = "test-signup-" + Date.now() + "@email.com";

package/utils/activityActorUtil.js

@@ -0,0 +1,167 @@
+'use strict';
+
+const User = require('../models/user');
+const winston = require('../config/winston');
+const projectUserUpdateContextUtil = require('./projectUserUpdateContextUtil');
+
+function actorFromReq(req) {
+  if (!req || !req.user) {
+    return { type: 'system', id: 'system', name: 'System' };
+  }
+  return projectUserUpdateContextUtil.actorFromPrincipal(req.user);
+}
+
+function actorFromUserId(userId) {
+  if (!userId) {
+    return { type: 'system', id: 'system', name: 'System' };
+  }
+  const id = String(userId);
+  return { type: 'user', id: id, name: id };
+}
+
+function resolveId(value) {
+  if (!value) {
+    return null;
+  }
+  if (value._id) {
+    return String(value._id);
+  }
+  return String(value);
+}
+
+function resolveUserFromParticipatingAgents(agents, userId) {
+  if (!Array.isArray(agents) || !userId) {
+    return null;
+  }
+
+  for (const agent of agents) {
+    const id = agent._id || agent.id;
+    if (id && String(id) === String(userId)) {
+      return agent;
+    }
+  }
+
+  return null;
+}
+
+function resolveUserFromSnapshotAgents(agents, userId) {
+  if (!Array.isArray(agents) || !userId) {
+    return null;
+  }
+
+  for (const projectUser of agents) {
+    const user = projectUser.id_user || projectUser;
+    const id = (user && (user._id || user.id)) || projectUser._id;
+    if (id && String(id) === String(userId)) {
+      return user;
+    }
+  }
+
+  return null;
+}
+
+function isSystemClosedBy(closedBy) {
+  if (!closedBy) {
+    return true;
+  }
+  const value = String(closedBy).toLowerCase();
+  return value === 'system' || value === '_trigger';
+}
+
+function actorFromClosedBy(request) {
+  if (!request) {
+    return { type: 'system', id: 'system', name: 'System' };
+  }
+
+  const closedBy = request.closed_by;
+  if (isSystemClosedBy(closedBy)) {
+    return { type: 'system', id: 'system', name: 'System' };
+  }
+
+  const userId = String(closedBy);
+  let user = resolveUserFromParticipatingAgents(request.participatingAgents, userId);
+  if (!user && request.snapshot) {
+    user = resolveUserFromSnapshotAgents(request.snapshot.agents, userId);
+  }
+
+  const name = (user && projectUserUpdateContextUtil.userDisplayName(user)) ||
+    request.closed_by_name ||
+    userId;
+
+  return {
+    type: 'user',
+    id: userId,
+    name: name
+  };
+}
+
+function actorFromRequestCreate(request) {
+  const requesterId = request && request.requester_id;
+  const lead = request && request.lead;
+  const leadId = lead && (lead._id || lead.id);
+  const leadFullname = lead && (lead.fullname || lead.fullName);
+  const participantsBots = (request && request.participantsBots) || [];
+  const participatingBotIds = (request && request.participatingBots || []).map(function (bot) {
+    return String((bot && (bot._id || bot.id)) || bot);
+  });
+
+  winston.info('ActivityArchiver REQUEST_CREATE actor resolution', {
+    request_id: request && request.request_id,
+    request_mongo_id: request && request._id && String(request._id),
+    requester_id: requesterId != null ? String(requesterId) : null,
+    requester_name: request && request.requester_name,
+    createdBy: request && request.createdBy,
+    lead_id: leadId != null ? String(leadId) : null,
+    lead_fullname: leadFullname,
+    participantsBots: participantsBots,
+    participatingBotIds: participatingBotIds,
+    hasBot: request && request.hasBot,
+    note: 'REQUEST_CREATE actor is always type=user with id=requester_id (lead virtual). JWT/token is not used here.'
+  });
+
+  const actor = {
+    type: 'user',
+    id: requesterId != null ? String(requesterId) : undefined,
+    name: (request && request.requester_name) || leadFullname || undefined
+  };
+
+  if (participantsBots.length > 0 || participatingBotIds.length > 0) {
+    winston.info('ActivityArchiver REQUEST_CREATE bot participants present (not used as actor)', {
+      request_id: request && request.request_id,
+      actor: actor,
+      participantsBots: participantsBots,
+      participatingBotIds: participatingBotIds
+    });
+  }
+
+  return actor;
+}
+
+async function resolveActorFromClosedBy(request) {
+  const actor = actorFromClosedBy(request);
+
+  if (actor.type !== 'user' || actor.name !== actor.id) {
+    return actor;
+  }
+
+  try {
+    const user = await User.findById(actor.id).select('firstname lastname email').lean().exec();
+    const displayName = user && projectUserUpdateContextUtil.userDisplayName(user);
+    if (displayName) {
+      return Object.assign({}, actor, { name: displayName });
+    }
+  } catch (err) {
+    // keep id fallback
+  }
+
+  return actor;
+}
+
+module.exports = {
+  actorFromReq,
+  actorFromUserId,
+  actorFromRequestCreate,
+  actorFromClosedBy,
+  resolveActorFromClosedBy,
+  resolveId
+};