feat: Allow managing association to business units on departments' creation and update

.changeset/dirty-stingrays-beg.md

@@ -0,0 +1,7 @@
+---
+"@rocket.chat/meteor": minor
+"@rocket.chat/model-typings": minor
+"@rocket.chat/rest-typings": minor
+---
+
+Added support for specifying a unit on departments' creation and update

apps/meteor/app/livechat/imports/server/rest/departments.ts

@@ -57,10 +57,18 @@ API.v1.addRoute(
 			check(this.bodyParams, {
 				department: Object,
 				agents: Match.Maybe(Array),
+				departmentUnit: Match.Maybe({ _id: Match.Optional(String) }),
 			});
 
 			const agents = this.bodyParams.agents ? { upsert: this.bodyParams.agents } : {};
-			const department = await LivechatTs.saveDepartment(null, this.bodyParams.department as ILivechatDepartment, agents);
+			const { departmentUnit } = this.bodyParams;
+			const department = await LivechatTs.saveDepartment(
+				this.userId,
+				null,
+				this.bodyParams.department as ILivechatDepartment,
+				agents,
+				departmentUnit || {},
+			);
 
 			if (department) {
 				return API.v1.success({
@@ -112,17 +120,18 @@ API.v1.addRoute(
 			check(this.bodyParams, {
 				department: Object,
 				agents: Match.Maybe(Array),
+				departmentUnit: Match.Maybe({ _id: Match.Optional(String) }),
 			});
 
 			const { _id } = this.urlParams;
-			const { department, agents } = this.bodyParams;
+			const { department, agents, departmentUnit } = this.bodyParams;
 
 			if (!permissionToSave) {
 				throw new Error('error-not-allowed');
 			}
 
 			const agentParam = permissionToAddAgents && agents ? { upsert: agents } : {};
-			await LivechatTs.saveDepartment(_id, department, agentParam);
+			await LivechatTs.saveDepartment(this.userId, _id, department, agentParam, departmentUnit || {});
 
 			return API.v1.success({
 				department: await LivechatDepartment.findOneById(_id),

apps/meteor/app/livechat/server/lib/LivechatTyped.ts

@@ -1879,16 +1879,20 @@ class LivechatClass {
 	 * @param {string|null} _id - The department id
 	 * @param {Partial<import('@rocket.chat/core-typings').ILivechatDepartment>} departmentData
 	 * @param {{upsert?: { agentId: string; count?: number; order?: number; }[], remove?: { agentId: string; count?: number; order?: number; }}} [departmentAgents] - The department agents
+	 * @param {{_id?: string}} [departmentUnit] - The department's unit id
 	 */
 	async saveDepartment(
+		userId: string,
 		_id: string | null,
 		departmentData: LivechatDepartmentDTO,
 		departmentAgents?: {
 			upsert?: { agentId: string; count?: number; order?: number }[];
 			remove?: { agentId: string; count?: number; order?: number };
 		},
+		departmentUnit?: { _id?: string },
 	) {
 		check(_id, Match.Maybe(String));
+		check(departmentUnit, Match.Maybe({ _id: Match.Optional(String) }));
 
 		const department = _id ? await LivechatDepartment.findOneById(_id, { projection: { _id: 1, archived: 1, enabled: 1 } }) : null;
 
@@ -1977,6 +1981,10 @@ class LivechatClass {
 			await callbacks.run('livechat.afterDepartmentDisabled', departmentDB);
 		}
 
+		if (departmentUnit) {
+			await callbacks.run('livechat.manageDepartmentUnit', { userId, departmentId: departmentDB._id, unitId: departmentUnit._id });
+		}
+
 		return departmentDB;
 	}
 }

apps/meteor/app/livechat/server/methods/saveDepartment.ts

@@ -30,19 +30,20 @@ declare module '@rocket.chat/ui-contexts' {
 						order?: number | undefined;
 				  }[]
 				| undefined,
+			departmentUnit?: { _id?: string },
 		) => ILivechatDepartment;
 	}
 }
 
 Meteor.methods<ServerMethods>({
-	async 'livechat:saveDepartment'(_id, departmentData, departmentAgents) {
+	async 'livechat:saveDepartment'(_id, departmentData, departmentAgents, departmentUnit) {
 		const uid = Meteor.userId();
 		if (!uid || !(await hasPermissionAsync(uid, 'manage-livechat-departments'))) {
 			throw new Meteor.Error('error-not-allowed', 'Not allowed', {
 				method: 'livechat:saveDepartment',
 			});
 		}
 
-		return Livechat.saveDepartment(_id, departmentData, { upsert: departmentAgents });
+		return Livechat.saveDepartment(uid, _id, departmentData, { upsert: departmentAgents }, departmentUnit);
 	},
 });

apps/meteor/ee/app/livechat-enterprise/server/hooks/index.ts

@@ -26,3 +26,4 @@ import './afterInquiryQueued';
 import './sendPdfTranscriptOnClose';
 import './applyRoomRestrictions';
 import './afterTagRemoved';
+import './manageDepartmentUnit';

apps/meteor/ee/app/livechat-enterprise/server/hooks/manageDepartmentUnit.ts

@@ -0,0 +1,51 @@
+import type { ILivechatDepartment, IOmnichannelBusinessUnit } from '@rocket.chat/core-typings';
+import { LivechatDepartment, LivechatUnit } from '@rocket.chat/models';
+
+import { hasAnyRoleAsync } from '../../../../../app/authorization/server/functions/hasRole';
+import { callbacks } from '../../../../../lib/callbacks';
+import { getUnitsFromUser } from '../methods/getUnitsFromUserRoles';
+
+callbacks.add(
+	'livechat.manageDepartmentUnit',
+	async ({ userId, departmentId, unitId }) => {
+		const units = await getUnitsFromUser(userId);
+		const isLivechatManager = await hasAnyRoleAsync(userId, ['admin', 'livechat-manager']);
+		const department = await LivechatDepartment.findOneById<Pick<ILivechatDepartment, '_id' | 'ancestors' | 'parentId'>>(departmentId, {
+			projection: { ancestors: 1, parentId: 1 },
+		});
+
+		if (!department || (unitId && department.ancestors?.includes(unitId))) {
+			return;
+		}
+
+		const currentDepartmentUnitId = department.parentId;
+		const canManageNewUnit = !unitId || isLivechatManager || (Array.isArray(units) && units.includes(unitId));
+		const canManageCurrentUnit =
+			!currentDepartmentUnitId || isLivechatManager || (Array.isArray(units) && units.includes(currentDepartmentUnitId));
+		if (!canManageNewUnit || !canManageCurrentUnit) {
+			return;
+		}
+
+		if (currentDepartmentUnitId) {
+			await LivechatUnit.decrementDepartmentsCount(currentDepartmentUnitId);
+		}
+
+		if (unitId) {
+			const unit = await LivechatUnit.findOneById<Pick<IOmnichannelBusinessUnit, '_id' | 'ancestors'>>(unitId, {
+				projection: { ancestors: 1 },
+			});
+
+			if (!unit) {
+				return;
+			}
+
+			await LivechatDepartment.addDepartmentToUnit(departmentId, unitId, [unitId, ...(unit.ancestors || [])]);
+			await LivechatUnit.incrementDepartmentsCount(unitId);
+			return;
+		}
+
+		await LivechatDepartment.removeDepartmentFromUnit(departmentId);
+	},
+	callbacks.priority.HIGH,
+	'livechat-manage-department-unit',
+);

apps/meteor/ee/server/models/raw/LivechatUnit.ts

@@ -11,7 +11,6 @@ const addQueryRestrictions = async (originalQuery: Filter<IOmnichannelBusinessUn
 
 	const units = await getUnitsFromUser();
 	if (Array.isArray(units)) {
-		query.ancestors = { $in: units };
 		const expressions = query.$and || [];
 		const condition = { $or: [{ ancestors: { $in: units } }, { _id: { $in: units } }] };
 		query.$and = [condition, ...expressions];
@@ -109,28 +108,12 @@ export class LivechatUnitRaw extends BaseRaw<IOmnichannelBusinessUnit> implement
 		// remove other departments
 		for await (const departmentId of savedDepartments) {
 			if (!departmentsToSave.includes(departmentId)) {
-				await LivechatDepartment.updateOne(
-					{ _id: departmentId },
-					{
-						$set: {
-							parentId: null,
-							ancestors: null,
-						},
-					},
-				);
+				await LivechatDepartment.removeDepartmentFromUnit(departmentId);
 			}
 		}
 
 		for await (const departmentId of departmentsToSave) {
-			await LivechatDepartment.updateOne(
-				{ _id: departmentId },
-				{
-					$set: {
-						parentId: _id,
-						ancestors,
-					},
-				},
-			);
+			await LivechatDepartment.addDepartmentToUnit(departmentId, _id, ancestors);
 		}
 
 		await LivechatRooms.associateRoomsWithDepartmentToUnit(departmentsToSave, _id);
@@ -154,6 +137,14 @@ export class LivechatUnitRaw extends BaseRaw<IOmnichannelBusinessUnit> implement
 		return this.updateMany(query, update);
 	}
 
+	incrementDepartmentsCount(_id: string): Promise<UpdateResult | Document> {
+		return this.updateOne({ _id }, { $inc: { numDepartments: 1 } });
+	}
+
+	decrementDepartmentsCount(_id: string): Promise<UpdateResult | Document> {
+		return this.updateOne({ _id }, { $inc: { numDepartments: -1 } });
+	}
+
 	async removeById(_id: string): Promise<DeleteResult> {
 		await LivechatUnitMonitors.removeByUnitId(_id);
 		await this.removeParentAndAncestorById(_id);

apps/meteor/lib/callbacks.ts

@@ -217,6 +217,7 @@ type ChainedCallbackSignatures = {
 	'unarchiveRoom': (room: IRoom) => void;
 	'roomAvatarChanged': (room: IRoom) => void;
 	'beforeGetMentions': (mentionIds: string[], teamMentions: MessageMention[]) => Promise<string[]>;
+	'livechat.manageDepartmentUnit': (params: { userId: string; departmentId: string; unitId?: string }) => void;
 };
 
 export type Hook =
@@ -240,6 +241,7 @@ export type Hook =
 	| 'livechat.offlineMessage'
 	| 'livechat.onCheckRoomApiParams'
 	| 'livechat.onLoadConfigApi'
+	| 'livechat.manageDepartmentUnit'
 	| 'loginPageStateChange'
 	| 'mapLDAPUserData'
 	| 'onCreateUser'

apps/meteor/server/models/raw/LivechatDepartment.ts

@@ -222,6 +222,14 @@ export class LivechatDepartmentRaw extends BaseRaw<ILivechatDepartment> implemen
 		return this.updateOne({ _id }, { $set: { archived: true, enabled: false } });
 	}
 
+	addDepartmentToUnit(_id: string, unitId: string, ancestors: string[]): Promise<Document | UpdateResult> {
+		return this.updateOne({ _id }, { $set: { parentId: unitId, ancestors } });
+	}
+
+	removeDepartmentFromUnit(_id: string): Promise<Document | UpdateResult> {
+		return this.updateOne({ _id }, { $set: { parentId: null, ancestors: null } });
+	}
+
 	async createOrUpdateDepartment(
 		_id: string | null,
 		data: {

apps/meteor/tests/data/livechat/units.ts

@@ -57,3 +57,25 @@ export const createUnit = async (
 			});
 	});
 };
+
+export const deleteUnit = async (unit: IOmnichannelBusinessUnit): Promise<IOmnichannelBusinessUnit> => {
+	return new Promise((resolve, reject) => {
+		void request
+			.post(methodCall(`livechat:removeUnit`))
+			.set(credentials)
+			.send({
+				message: JSON.stringify({
+					method: 'livechat:removeUnit',
+					params: [unit._id],
+					id: '101',
+					msg: 'method',
+				}),
+			})
+			.end((err: Error, res: DummyResponse<string, 'wrapped'>) => {
+				if (err) {
+					return reject(err);
+				}
+				resolve(JSON.parse(res.body.message).result);
+			});
+	});
+};