@tiledesk/tiledesk-server 2.19.13 → 2.19.15

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/dataTableUtils.js

@@ -224,7 +224,7 @@ function validateRowData(data, schema) {
     const col = schema[j];
     if (!Object.prototype.hasOwnProperty.call(data, col.name)) continue;
     const raw = data[col.name];
-    if (raw === null || raw === undefined) continue;
+    if (raw === undefined) continue;
     result[col.name] = coerceValue(raw, col);
   }
   return result;

package/utils/projectUserUpdateContextUtil.js

@@ -0,0 +1,325 @@
+'use strict';
+
+const Subscription = require('../models/subscription');
+const Faq_kb = require('../models/faq_kb');
+
+function systemActor() {
+  return { type: 'system', id: 'system', name: 'System' };
+}
+
+function userDisplayName(user) {
+  if (!user) {
+    return undefined;
+  }
+
+  const fullName = user.fullName || user.fullname;
+  if (fullName && String(fullName).trim()) {
+    return String(fullName).trim();
+  }
+
+  const name = ((user.firstname || '') + ' ' + (user.lastname || '')).trim();
+  if (name) {
+    return name;
+  }
+
+  return undefined;
+}
+
+function resolveUserId(userRef) {
+  if (userRef === undefined || userRef === null) {
+    return '';
+  }
+
+  if (typeof userRef === 'string' || typeof userRef === 'number') {
+    return String(userRef);
+  }
+
+  if (userRef._id) {
+    return String(userRef._id);
+  }
+
+  if (userRef.id) {
+    return String(userRef.id);
+  }
+
+  return String(userRef);
+}
+
+function isBotActor(user) {
+  if (!user) {
+    return false;
+  }
+
+  if (user instanceof Faq_kb) {
+    return true;
+  }
+
+  if (user.constructor && user.constructor.modelName === 'faq_kb') {
+    return true;
+  }
+
+  if (user.sub === 'bot' || (typeof user.sub === 'string' && user.sub.endsWith('/bot'))) {
+    return true;
+  }
+
+  if (typeof user.aud === 'string' && user.aud.indexOf('/bots/') > -1) {
+    return true;
+  }
+
+  if (user.type === 'tilebot' || user.subtype === 'chatbot') {
+    return true;
+  }
+
+  // Cached/plain faq_kb payloads may miss type/subtype but still carry bot identity fields.
+  if (
+    user.slug &&
+    user.name &&
+    user.id_project &&
+    user.createdBy &&
+    !user.email &&
+    !user.firstname &&
+    !user.lastname
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+function botDisplayName(user) {
+  if (!user || !user.name) {
+    return undefined;
+  }
+  const name = String(user.name).trim();
+  return name || undefined;
+}
+
+function actorFromPrincipal(user) {
+  if (!user) {
+    return systemActor();
+  }
+
+  if (isSubscriptionActor(user)) {
+    return systemActor();
+  }
+
+  if (isBotActor(user)) {
+    const id = resolveUserId(user);
+    return {
+      type: 'bot',
+      id: id,
+      name: botDisplayName(user) || id
+    };
+  }
+
+  return {
+    type: 'user',
+    id: resolveUserId(user),
+    name: user.fullName || user.fullname || userDisplayName(user) || undefined
+  };
+}
+
+function isSubscriptionActor(user) {
+  if (!user) {
+    return false;
+  }
+
+  if (user instanceof Subscription) {
+    return true;
+  }
+
+  if (user.constructor && user.constructor.modelName === 'subscription') {
+    return true;
+  }
+
+  // Webhook subscription document (no user profile fields)
+  return Boolean(
+    user.event &&
+    user.target &&
+    user.id_project &&
+    user.createdBy &&
+    !user.email &&
+    !user.firstname &&
+    !user.lastname
+  );
+}
+
+function isSystemAvailabilityInitiator(req) {
+  if (!req || !req.body) {
+    return false;
+  }
+
+  return req.body.availabilityInitiator === 'system';
+}
+
+function isAvailabilityUpdate(body) {
+  if (!body) {
+    return false;
+  }
+  return body.user_available !== undefined || body.profileStatus !== undefined;
+}
+
+function buildProjectUserUpdateContext(req, previousUserAvailable, previousProfileStatus, targetUserId) {
+  const context = {
+    previousUserAvailable,
+    previousProfileStatus,
+    source: 'api',
+    updateType: 'admin'
+  };
+
+  if (!req || !req.user) {
+    context.source = 'system';
+    context.updateType = 'system';
+    return context;
+  }
+
+  if (isSubscriptionActor(req.user) || isSystemAvailabilityInitiator(req)) {
+    context.source = isSubscriptionActor(req.user) ? 'subscription' : 'api';
+    context.updateType = 'system';
+    return context;
+  }
+
+  const actorUserId = resolveUserId(req.user);
+  const targetId = resolveUserId(targetUserId);
+  const isSelfRoute = !req.params || !req.params.project_userid;
+
+  if (isSelfRoute) {
+    context.updateType = 'self';
+    return context;
+  }
+
+  if (actorUserId && targetId && actorUserId === targetId) {
+    context.updateType = 'self';
+  }
+
+  return context;
+}
+
+function actorFromUpdateContext(req, updateContext) {
+  if (
+    !req ||
+    !req.user ||
+    (updateContext && updateContext.updateType === 'system') ||
+    isSubscriptionActor(req.user) ||
+    isSystemAvailabilityInitiator(req)
+  ) {
+    return systemActor();
+  }
+
+  return {
+    type: 'user',
+    id: resolveUserId(req.user),
+    name: userDisplayName(req.user)
+  };
+}
+
+function actorFromProjectUserUpdate(event, verb, updateContext) {
+  const actor = actorFromUpdateContext(event.req, updateContext);
+
+  if (actor.name) {
+    return actor;
+  }
+
+  const project_user = event.updatedProject_userPopulated;
+  const targetUser = project_user && project_user.id_user;
+  const targetName = userDisplayName(targetUser);
+
+  if (
+    targetName &&
+    (verb === 'PROJECT_USER_AVAILABILITY_SELF' ||
+      resolveUserId(targetUser) === actor.id)
+  ) {
+    return Object.assign({}, actor, { name: targetName });
+  }
+
+  return actor;
+}
+
+function verbForProjectUserUpdate(body, updateContext) {
+  if (!isAvailabilityUpdate(body)) {
+    return 'PROJECT_USER_UPDATE';
+  }
+
+  if (updateContext && updateContext.updateType === 'system') {
+    return 'PROJECT_USER_AVAILABILITY_SYSTEM';
+  }
+
+  if (updateContext && updateContext.updateType === 'self') {
+    return 'PROJECT_USER_AVAILABILITY_SELF';
+  }
+
+  return 'PROJECT_USER_UPDATE';
+}
+
+function availabilityStatusLabel({ user_available, profileStatus }) {
+  if (profileStatus !== undefined && profileStatus !== null && profileStatus !== '') {
+    return String(profileStatus);
+  }
+  if (user_available === true) {
+    return 'available';
+  }
+  if (user_available === false) {
+    return 'unavailable';
+  }
+  return 'unknown';
+}
+
+function reconcileAvailabilityVerb(event, project_user, verb, updateContext) {
+  if (!isAvailabilityUpdate(event.req && event.req.body)) {
+    return { verb: verb, updateContext: updateContext, actor: null };
+  }
+
+  const context = Object.assign({}, updateContext);
+  let resolvedVerb = verb;
+  const targetUserId = resolveUserId(project_user && project_user.id_user);
+  const actorUserId = resolveUserId(event.req && event.req.user);
+
+  if (isSubscriptionActor(event.req && event.req.user) || isSystemAvailabilityInitiator(event.req)) {
+    context.updateType = 'system';
+    context.source = isSubscriptionActor(event.req.user) ? 'subscription' : (context.source || 'api');
+    resolvedVerb = 'PROJECT_USER_AVAILABILITY_SYSTEM';
+    return {
+      verb: resolvedVerb,
+      updateContext: context,
+      actor: systemActor()
+    };
+  }
+
+  if (resolvedVerb === 'PROJECT_USER_AVAILABILITY_SELF' && targetUserId && actorUserId && actorUserId !== targetUserId) {
+    context.updateType = 'admin';
+    resolvedVerb = 'PROJECT_USER_UPDATE';
+    return { verb: resolvedVerb, updateContext: context, actor: null };
+  }
+
+  return { verb: resolvedVerb, updateContext: context, actor: null };
+}
+
+function verbFromAvailabilityUpdateType(updateType) {
+  switch (updateType) {
+    case 'system':
+      return 'PROJECT_USER_AVAILABILITY_SYSTEM';
+    case 'self':
+      return 'PROJECT_USER_AVAILABILITY_SELF';
+    default:
+      return 'PROJECT_USER_UPDATE';
+  }
+}
+
+module.exports = {
+  systemActor,
+  userDisplayName,
+  resolveUserId,
+  isBotActor,
+  botDisplayName,
+  actorFromPrincipal,
+  isSubscriptionActor,
+  isSystemAvailabilityInitiator,
+  isAvailabilityUpdate,
+  buildProjectUserUpdateContext,
+  actorFromUpdateContext,
+  actorFromProjectUserUpdate,
+  verbForProjectUserUpdate,
+  availabilityStatusLabel,
+  reconcileAvailabilityVerb,
+  verbFromAvailabilityUpdateType
+};