snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/server/lib/rooms/settings/index.ts

@@ -0,0 +1,2 @@
+export { saveRoomTopic } from './saveRoomTopic';
+export { saveRoomName } from './saveRoomName';

apps/meteor/server/lib/rooms/settings/saveReactWhenReadOnly.ts

@@ -0,0 +1,28 @@
+import { Message } from '@rocket.chat/core-services';
+import { Rooms } from '@rocket.chat/models';
+import { Match } from 'meteor/check';
+import { Meteor } from 'meteor/meteor';
+
+export const saveReactWhenReadOnly = async function (
+	rid: string,
+	allowReact: boolean,
+	user: {
+		_id: string;
+		username: string;
+	},
+	sendMessage = true,
+) {
+	if (!Match.test(rid, String)) {
+		throw new Meteor.Error('invalid-room', 'Invalid room', {
+			function: 'RocketChat.saveReactWhenReadOnly',
+		});
+	}
+
+	const result = await Rooms.setAllowReactingWhenReadOnlyById(rid, allowReact);
+
+	if (result && sendMessage) {
+		const type = allowReact ? 'room-allowed-reacting' : 'room-disallowed-reacting';
+
+		await Message.saveSystemMessage(type, rid, '', user);
+	}
+};

apps/meteor/server/lib/rooms/settings/saveRoomAnnouncement.ts

@@ -0,0 +1,34 @@
+import { Message } from '@rocket.chat/core-services';
+import type { IUser } from '@rocket.chat/core-typings';
+import { Rooms } from '@rocket.chat/models';
+import { Match } from 'meteor/check';
+import { Meteor } from 'meteor/meteor';
+import type { UpdateResult } from 'mongodb';
+
+export const saveRoomAnnouncement = async function (
+	rid: string,
+	roomAnnouncement: string,
+	user: IUser,
+	sendMessage = true,
+): Promise<UpdateResult> {
+	if (!Match.test(rid, String)) {
+		throw new Meteor.Error('invalid-room', 'Invalid room', {
+			function: 'RocketChat.saveRoomAnnouncement',
+		});
+	}
+
+	let message;
+	let announcementDetails;
+	if (typeof roomAnnouncement === 'string') {
+		message = roomAnnouncement;
+	} else {
+		({ message, ...announcementDetails } = roomAnnouncement);
+	}
+
+	const updated = await Rooms.setAnnouncementById(rid, message, announcementDetails);
+	if (updated && sendMessage) {
+		await Message.saveSystemMessage('room_changed_announcement', rid, message, user);
+	}
+
+	return updated;
+};

apps/meteor/server/lib/rooms/settings/saveRoomCustomFields.ts

@@ -0,0 +1,30 @@
+import { Rooms, Subscriptions } from '@rocket.chat/models';
+import { Match } from 'meteor/check';
+import { Meteor } from 'meteor/meteor';
+import type { UpdateResult } from 'mongodb';
+
+import { notifyOnSubscriptionChangedByRoomId } from '../../notifyListener';
+
+export const saveRoomCustomFields = async function (rid: string, roomCustomFields: Record<string, any>): Promise<UpdateResult> {
+	if (!Match.test(rid, String)) {
+		throw new Meteor.Error('invalid-room', 'Invalid room', {
+			function: 'RocketChat.saveRoomCustomFields',
+		});
+	}
+
+	if (!Match.test(roomCustomFields, Object)) {
+		throw new Meteor.Error('invalid-roomCustomFields-type', 'Invalid roomCustomFields type', {
+			function: 'RocketChat.saveRoomCustomFields',
+		});
+	}
+
+	const ret = await Rooms.setCustomFieldsById(rid, roomCustomFields);
+
+	// Update customFields of any user's Subscription related with this rid
+	const { modifiedCount } = await Subscriptions.updateCustomFieldsByRoomId(rid, roomCustomFields);
+	if (modifiedCount) {
+		void notifyOnSubscriptionChangedByRoomId(rid);
+	}
+
+	return ret;
+};

apps/meteor/server/lib/rooms/settings/saveRoomDescription.ts

@@ -0,0 +1,18 @@
+import { Message } from '@rocket.chat/core-services';
+import type { IUser } from '@rocket.chat/core-typings';
+import { Rooms } from '@rocket.chat/models';
+import { Match } from 'meteor/check';
+import { Meteor } from 'meteor/meteor';
+import type { UpdateResult } from 'mongodb';
+
+export const saveRoomDescription = async function (rid: string, roomDescription: string, user: IUser): Promise<UpdateResult> {
+	if (!Match.test(rid, String)) {
+		throw new Meteor.Error('invalid-room', 'Invalid room', {
+			function: 'RocketChat.saveRoomDescription',
+		});
+	}
+
+	const update = await Rooms.setDescriptionById(rid, roomDescription);
+	await Message.saveSystemMessage('room_changed_description', rid, roomDescription, user);
+	return update;
+};

apps/meteor/server/lib/rooms/settings/saveRoomEncrypted.ts

@@ -0,0 +1,38 @@
+import { Message } from '@rocket.chat/core-services';
+import type { IUser } from '@rocket.chat/core-typings';
+import { isRegisterUser } from '@rocket.chat/core-typings';
+import { Rooms, Subscriptions } from '@rocket.chat/models';
+import { Match } from 'meteor/check';
+import { Meteor } from 'meteor/meteor';
+import type { UpdateResult } from 'mongodb';
+
+import { notifyOnSubscriptionChangedByRoomId } from '../../notifyListener';
+
+export const saveRoomEncrypted = async function (rid: string, encrypted: boolean, user: IUser, sendMessage = true): Promise<UpdateResult> {
+	if (!Match.test(rid, String)) {
+		throw new Meteor.Error('invalid-room', 'Invalid room', {
+			function: 'RocketChat.saveRoomEncrypted',
+		});
+	}
+
+	if (!isRegisterUser(user)) {
+		throw new Meteor.Error('invalid-user', 'Invalid user', {
+			function: 'RocketChat.saveRoomEncrypted',
+		});
+	}
+
+	const update = await Rooms.saveEncryptedById(rid, encrypted);
+	if (update && sendMessage) {
+		const type = encrypted ? 'room_e2e_enabled' : 'room_e2e_disabled';
+
+		await Message.saveSystemMessage(type, rid, user.username, user);
+	}
+
+	if (encrypted) {
+		const { modifiedCount } = await Subscriptions.disableAutoTranslateByRoomId(rid);
+		if (modifiedCount) {
+			void notifyOnSubscriptionChangedByRoomId(rid);
+		}
+	}
+	return update;
+};

apps/meteor/server/lib/rooms/settings/saveRoomName.ts

@@ -0,0 +1,105 @@
+import { Message, Room } from '@rocket.chat/core-services';
+import type { IUser } from '@rocket.chat/core-typings';
+import { isRoomNativeFederated } from '@rocket.chat/core-typings';
+import { Integrations, Rooms, Subscriptions } from '@rocket.chat/models';
+import { Meteor } from 'meteor/meteor';
+import type { Document, UpdateResult } from 'mongodb';
+
+import { callbacks } from '../../callbacks';
+import { notifyOnIntegrationChangedByChannels, notifyOnSubscriptionChangedByRoomId } from '../../notifyListener';
+import { checkUsernameAvailability } from '../../users/checkUsernameAvailability';
+import { getValidRoomName } from '../../utils/lib/getValidRoomName';
+import { roomCoordinator } from '../roomCoordinator';
+
+const updateFName = async (rid: string, displayName: string): Promise<(UpdateResult | Document)[]> => {
+	const responses = await Promise.all([Rooms.setFnameById(rid, displayName), Subscriptions.updateFnameByRoomId(rid, displayName)]);
+
+	if (responses[1]?.modifiedCount) {
+		void notifyOnSubscriptionChangedByRoomId(rid);
+	}
+
+	return responses;
+};
+
+const updateRoomName = async (rid: string, displayName: string, slugifiedRoomName: string) => {
+	// Check if the name is available
+	if (!(await checkUsernameAvailability(slugifiedRoomName, 'room'))) {
+		throw new Meteor.Error('error-duplicate-handle', `A room, team or user with name '${slugifiedRoomName}' already exists`, {
+			function: 'RocketChat.updateRoomName',
+			handle: slugifiedRoomName,
+		});
+	}
+
+	const responses = await Promise.all([
+		Rooms.setNameById(rid, slugifiedRoomName, displayName),
+		Subscriptions.updateNameAndAlertByRoomId(rid, slugifiedRoomName, displayName),
+	]);
+
+	if (responses[1]?.modifiedCount) {
+		void notifyOnSubscriptionChangedByRoomId(rid);
+	}
+
+	return responses;
+};
+
+export async function saveRoomName(
+	rid: string,
+	displayName: string | undefined,
+	user: IUser,
+	sendMessage = true,
+): Promise<string | undefined> {
+	const room = await Rooms.findOneById(rid);
+	if (!room) {
+		throw new Meteor.Error('error-invalid-room', 'Invalid room', {
+			function: 'RocketChat.saveRoomdisplayName',
+		});
+	}
+
+	if (roomCoordinator.getRoomDirectives(room.t).preventRenaming()) {
+		throw new Meteor.Error('error-not-allowed', 'Not allowed', {
+			function: 'RocketChat.saveRoomdisplayName',
+		});
+	}
+
+	await Room.beforeNameChange(room);
+
+	if (isRoomNativeFederated(room)) {
+		displayName = `${displayName}:${room.federation.mrid.split(':').pop()}`;
+	}
+
+	if (displayName === room.name) {
+		return;
+	}
+
+	if (!displayName?.trim()) {
+		return;
+	}
+
+	const isDiscussion = Boolean(room?.prid);
+
+	const slugifiedRoomName = isDiscussion || isRoomNativeFederated(room) ? displayName : await getValidRoomName(displayName, rid);
+
+	let update;
+
+	if (isDiscussion || isRoomNativeFederated(room)) {
+		update = await updateFName(rid, displayName);
+	} else {
+		update = await updateRoomName(rid, displayName, slugifiedRoomName);
+	}
+
+	if (!update) {
+		return;
+	}
+
+	if (room.name && !isDiscussion) {
+		await Integrations.updateRoomName(room.name, slugifiedRoomName);
+		void notifyOnIntegrationChangedByChannels([slugifiedRoomName]);
+	}
+
+	if (sendMessage) {
+		await Message.saveSystemMessage('r', rid, displayName, user);
+	}
+
+	await callbacks.run('afterRoomNameChange', { room, name: displayName, oldName: room.name, user });
+	return displayName;
+}

apps/meteor/server/lib/rooms/settings/saveRoomReadOnly.ts

@@ -0,0 +1,29 @@
+import { Message } from '@rocket.chat/core-services';
+import type { IUser } from '@rocket.chat/core-typings';
+import { Rooms } from '@rocket.chat/models';
+import { Match } from 'meteor/check';
+import { Meteor } from 'meteor/meteor';
+
+export async function saveRoomReadOnly(
+	rid: string,
+	readOnly: boolean,
+	user: Required<Pick<IUser, '_id' | 'username' | 'name'>>,
+	sendMessage = true,
+) {
+	if (!Match.test(rid, String)) {
+		throw new Meteor.Error('invalid-room', 'Invalid room', {
+			function: 'RocketChat.saveRoomReadOnly',
+		});
+	}
+
+	const result = await Rooms.setReadOnlyById(rid, readOnly);
+
+	if (result && sendMessage) {
+		if (readOnly) {
+			await Message.saveSystemMessage('room-set-read-only', rid, '', user);
+		} else {
+			await Message.saveSystemMessage('room-removed-read-only', rid, '', user);
+		}
+	}
+	return result;
+}

apps/meteor/server/lib/rooms/settings/saveRoomSystemMessages.ts

@@ -0,0 +1,23 @@
+import type { MessageTypesValues } from '@rocket.chat/core-typings';
+import { Rooms } from '@rocket.chat/models';
+import { Match } from 'meteor/check';
+import { Meteor } from 'meteor/meteor';
+
+import { MessageTypesValues as messageTypesValues } from '../../../../app/lib/lib/MessageTypes';
+
+export const saveRoomSystemMessages = async function (rid: string, systemMessages: MessageTypesValues[]) {
+	if (!Match.test(rid, String)) {
+		throw new Meteor.Error('invalid-room', 'Invalid room', {
+			function: 'RocketChat.saveRoomSystemMessages',
+		});
+	}
+	if (
+		systemMessages &&
+		(!Match.test(systemMessages, [String]) || systemMessages.some((value) => !messageTypesValues.map(({ key }) => key).includes(value)))
+	) {
+		throw new Meteor.Error('invalid-room', 'Invalid option', {
+			function: 'RocketChat.saveRoomSystemMessages',
+		});
+	}
+	return Rooms.setSystemMessagesById(rid, systemMessages);
+};

apps/meteor/server/lib/rooms/settings/saveRoomTopic.ts

@@ -0,0 +1,31 @@
+import { Message, Room } from '@rocket.chat/core-services';
+import type { IUser } from '@rocket.chat/core-typings';
+import { Rooms } from '@rocket.chat/models';
+import { Match } from 'meteor/check';
+import { Meteor } from 'meteor/meteor';
+
+import { callbacks } from '../../callbacks';
+
+export const saveRoomTopic = async (
+	rid: string,
+	roomTopic: string | undefined,
+	user: Pick<IUser, 'username' | '_id' | 'federation' | 'federated'>,
+	sendMessage = true,
+) => {
+	if (!Match.test(rid, String)) {
+		throw new Meteor.Error('invalid-room', 'Invalid room', {
+			function: 'RocketChat.saveRoomTopic',
+		});
+	}
+
+	const room = await Rooms.findOneById(rid);
+
+	await Room.beforeTopicChange(room!);
+
+	const update = await Rooms.setTopicById(rid, roomTopic);
+	if (update && sendMessage) {
+		await Message.saveSystemMessage('room_changed_topic', rid, roomTopic || '', user);
+	}
+	await callbacks.run('afterRoomTopicChange', undefined, { room, topic: roomTopic, user });
+	return update;
+};

apps/meteor/server/lib/rooms/settings/saveRoomType.ts

@@ -0,0 +1,74 @@
+import { Message } from '@rocket.chat/core-services';
+import type { IRoom, IUser } from '@rocket.chat/core-typings';
+import { Rooms, Subscriptions } from '@rocket.chat/models';
+import { Match } from 'meteor/check';
+import { Meteor } from 'meteor/meteor';
+import type { UpdateResult, Document } from 'mongodb';
+
+import { RoomSettingsEnum } from '../../../../definition/IRoomTypeConfig';
+import { settings } from '../../../settings';
+import { i18n } from '../../i18n';
+import { notifyOnSubscriptionChangedByRoomId } from '../../notifyListener';
+import { roomCoordinator } from '../roomCoordinator';
+
+export const saveRoomType = async function (
+	rid: string,
+	roomType: IRoom['t'],
+	user: IUser,
+	sendMessage = true,
+): Promise<UpdateResult | Document> {
+	if (!Match.test(rid, String)) {
+		throw new Meteor.Error('invalid-room', 'Invalid room', {
+			function: 'RocketChat.saveRoomType',
+		});
+	}
+	if (roomType !== 'c' && roomType !== 'p') {
+		throw new Meteor.Error('error-invalid-room-type', 'error-invalid-room-type', {
+			function: 'RocketChat.saveRoomType',
+			type: roomType,
+		});
+	}
+	const room = await Rooms.findOneById(rid);
+	if (room == null) {
+		throw new Meteor.Error('error-invalid-room', 'error-invalid-room', {
+			function: 'RocketChat.saveRoomType',
+			_id: rid,
+		});
+	}
+
+	if (!(await roomCoordinator.getRoomDirectives(room.t)?.allowRoomSettingChange(room, RoomSettingsEnum.TYPE))) {
+		throw new Meteor.Error('error-direct-room', "Can't change type of direct rooms", {
+			function: 'RocketChat.saveRoomType',
+		});
+	}
+
+	const result = await Promise.all([Rooms.setTypeById(rid, roomType), Subscriptions.updateTypeByRoomId(rid, roomType)]);
+
+	if (!result) {
+		return result;
+	}
+
+	if (roomType === 'c' && room.abacAttributes?.length) {
+		await Rooms.unsetAbacAttributesById(rid);
+	}
+
+	if (result[1]?.modifiedCount) {
+		void notifyOnSubscriptionChangedByRoomId(rid);
+	}
+
+	if (sendMessage) {
+		let message;
+		if (roomType === 'c') {
+			message = i18n.t('public', {
+				lng: user?.language || settings.get('Language') || 'en',
+			});
+		} else {
+			message = i18n.t('private', {
+				lng: user?.language || settings.get('Language') || 'en',
+			});
+		}
+		await Message.saveSystemMessage('room_changed_privacy', rid, message, user);
+	}
+
+	return result;
+};