@tiledesk/tiledesk-server 2.19.12 → 2.19.14

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

package/utils/assignmentContextUtil.js

@@ -0,0 +1,283 @@
+'use strict';
+
+const projectUserUpdateContextUtil = require('./projectUserUpdateContextUtil');
+const winston = require('../config/winston');
+
+function systemActor() {
+  return { type: 'system', id: 'system', name: 'System' };
+}
+
+function actorFromUser(user) {
+  return projectUserUpdateContextUtil.actorFromPrincipal(user);
+}
+
+function assignmentActorContext(req, defaultSource) {
+  const source = defaultSource || 'api';
+
+  if (!req || !req.user) {
+    return { actor: systemActor(), source: 'system' };
+  }
+
+  if (projectUserUpdateContextUtil.isSubscriptionActor(req.user)) {
+    return { actor: systemActor(), source: 'subscription' };
+  }
+
+  const actor = actorFromUser(req.user);
+  const isBot = projectUserUpdateContextUtil.isBotActor(req.user);
+
+  if (isBot && actor.type !== 'bot') {
+    winston.warn('assignmentActorContext bot principal resolved as non-bot actor', {
+      actor: actor,
+      principal_id: projectUserUpdateContextUtil.resolveUserId(req.user),
+      principal_name: req.user && req.user.name,
+      principal_type: req.user && req.user.type,
+      principal_subtype: req.user && req.user.subtype,
+      principal_sub: req.user && req.user.sub,
+      principal_model: req.user && req.user.constructor && req.user.constructor.modelName,
+      source: source,
+      url: req.originalUrl
+    });
+  } else {
+    winston.info('assignmentActorContext actor resolution', {
+      actor: actor,
+      principal_id: projectUserUpdateContextUtil.resolveUserId(req.user),
+      principal_name: req.user && req.user.name,
+      principal_type: req.user && req.user.type,
+      principal_subtype: req.user && req.user.subtype,
+      principal_sub: req.user && req.user.sub,
+      principal_model: req.user && req.user.constructor && req.user.constructor.modelName,
+      isBotActor: isBot,
+      source: source,
+      url: req.originalUrl
+    });
+  }
+
+  return { actor: actor, source: source };
+}
+
+function reconcileAssignmentPayload(data) {
+  const source = (data && data.source) || 'system';
+  let actor = (data && data.actor) || systemActor();
+
+  if (source === 'subscription' || actor.type === 'system') {
+    return {
+      actor: systemActor(),
+      source: source === 'subscription' ? 'subscription' : source
+    };
+  }
+
+  return { actor: actor, source: source };
+}
+
+function isHumanParticipant(participantId) {
+  return participantId && !String(participantId).startsWith('bot_');
+}
+
+function filterHumanParticipants(participantIds) {
+  return (participantIds || []).filter(isHumanParticipant);
+}
+
+function isBotParticipant(participantId) {
+  return participantId && String(participantId).startsWith('bot_');
+}
+
+function filterBotParticipants(participantIds) {
+  return (participantIds || []).filter(isBotParticipant);
+}
+
+function botIdFromParticipant(participantId) {
+  return String(participantId).replace('bot_', '');
+}
+
+function resolveBotName(requestComplete, botParticipantOrId) {
+  const botId = isBotParticipant(botParticipantOrId)
+    ? botIdFromParticipant(botParticipantOrId)
+    : String(botParticipantOrId);
+  const bots = requestComplete && requestComplete.participatingBots;
+  if (Array.isArray(bots)) {
+    for (const bot of bots) {
+      const id = String(bot._id || bot.id);
+      if (id === botId) {
+        return bot.name || id;
+      }
+    }
+  }
+  return botId;
+}
+
+function resolveDepartmentName(requestComplete) {
+  const dep = requestComplete && requestComplete.department;
+  if (!dep) {
+    return undefined;
+  }
+  if (dep.name) {
+    return dep.name;
+  }
+  return dep._id ? String(dep._id) : undefined;
+}
+
+function deriveAssignmentType({ actor, assigneeIds, isUnassign }) {
+  if (isUnassign) {
+    return 'unassign';
+  }
+
+  const humanAssignees = filterHumanParticipants(assigneeIds);
+  if (humanAssignees.length === 0) {
+    return null;
+  }
+
+  if (!actor || actor.type === 'system') {
+    return 'auto';
+  }
+
+  const assigneeId = String(humanAssignees[0]);
+  if (String(actor.id) === assigneeId) {
+    return 'self_join';
+  }
+
+  return 'manual_reassign';
+}
+
+function verbFromAssignmentType(assignmentType) {
+  switch (assignmentType) {
+    case 'auto':
+      return 'REQUEST_ASSIGNED_AUTO';
+    case 'self_join':
+      return 'REQUEST_ASSIGNED_SELF';
+    case 'manual_reassign':
+    case 'manual_reassign_bot':
+    case 'manual_reassign_department':
+      return 'REQUEST_ASSIGNED_MANUAL';
+    case 'unassign':
+      return 'REQUEST_UNASSIGNED';
+    default:
+      return null;
+  }
+}
+
+function buildSetParticipantsOptions(req, participants) {
+  const { actor, source } = assignmentActorContext(req, 'api');
+
+  if (!participants || participants.length === 0) {
+    return {
+      actor,
+      source,
+      assignmentType: 'unassign'
+    };
+  }
+
+  const botParticipants = filterBotParticipants(participants);
+  const humanParticipants = filterHumanParticipants(participants);
+
+  if (botParticipants.length > 0 && humanParticipants.length === 0) {
+    return {
+      actor,
+      source,
+      assignmentType: 'manual_reassign_bot'
+    };
+  }
+
+  return {
+    actor,
+    source,
+    assignmentType: deriveAssignmentType({
+      actor,
+      assigneeIds: participants,
+      isUnassign: false
+    })
+  };
+}
+
+function buildAddParticipantOptions(req, member) {
+  const { actor, source } = assignmentActorContext(req, 'api');
+
+  return {
+    actor,
+    source,
+    assignmentType: deriveAssignmentType({
+      actor,
+      assigneeIds: [member],
+      isUnassign: false
+    })
+  };
+}
+
+function buildRemoveParticipantOptions(req, member) {
+  if (!isHumanParticipant(member)) {
+    return { trackLeave: false };
+  }
+
+  const { actor: reqActor, source } = assignmentActorContext(req, 'api');
+  const actor = req && req.user && String(reqActor.id) === String(member)
+    ? reqActor
+    : { type: 'user', id: String(member), name: String(member) };
+
+  return {
+    actor,
+    source,
+    member,
+    trackLeave: true
+  };
+}
+
+function buildLeaveParticipantOptions(source, member) {
+  if (!isHumanParticipant(member)) {
+    return { trackLeave: false };
+  }
+
+  return {
+    actor: { type: 'user', id: String(member), name: String(member) },
+    source: source || 'webhook',
+    member,
+    trackLeave: true
+  };
+}
+
+function buildAutoRouteOptions(req, source) {
+  const ctx = assignmentActorContext(req, source || 'api');
+  return {
+    actor: ctx.actor,
+    source: ctx.source,
+    assignmentType: 'auto'
+  };
+}
+
+function buildDepartmentRouteOptions(req, source) {
+  const ctx = assignmentActorContext(req, source || 'api');
+  return {
+    actor: ctx.actor,
+    source: ctx.source,
+    assignmentType: 'manual_reassign_department'
+  };
+}
+
+function buildInternalOptions(source, assignmentType) {
+  return {
+    actor: systemActor(),
+    source: source || 'system',
+    assignmentType: assignmentType || 'auto'
+  };
+}
+
+module.exports = {
+  systemActor,
+  actorFromUser,
+  assignmentActorContext,
+  reconcileAssignmentPayload,
+  isHumanParticipant,
+  filterHumanParticipants,
+  isBotParticipant,
+  filterBotParticipants,
+  botIdFromParticipant,
+  resolveBotName,
+  resolveDepartmentName,
+  deriveAssignmentType,
+  verbFromAssignmentType,
+  buildSetParticipantsOptions,
+  buildAddParticipantOptions,
+  buildRemoveParticipantOptions,
+  buildLeaveParticipantOptions,
+  buildAutoRouteOptions,
+  buildDepartmentRouteOptions,
+  buildInternalOptions
+};

package/utils/dataTableBsonUtils.js

@@ -0,0 +1,12 @@
+const BSON = require('bson');
+const bson = new BSON();
+
+function calculateBsonSize(document) {
+  if (document == null) return 0;
+  const plain = document.toObject ? document.toObject({ depopulate: true }) : document;
+  return bson.calculateObjectSize(plain);
+}
+
+module.exports = {
+  calculateBsonSize: calculateBsonSize,
+};