feat: Adding scheduled messages

.changeset/rare-llamas-behave.md

@@ -0,0 +1,8 @@
+---
+'@rocket.chat/models': minor
+'@rocket.chat/meteor': minor
+'@rocket.chat/ui-composer': minor
+'@rocket.chat/i18n': minor
+---
+
+Implemented complete message scheduling functionality, allowing users to schedule messages to be sent at a specific date and time.

.changeset/tasty-hoops-try.md

@@ -0,0 +1,8 @@
+---
+'@rocket.chat/ui-composer': minor
+'@rocket.chat/models': minor
+'@rocket.chat/i18n': minor
+'@rocket.chat/meteor': minor
+---
+
+Added scheduled messages

apps/meteor/app/api/server/index.ts

@@ -11,6 +11,7 @@ import './v1/calendar';
 import './v1/call-history';
 import './v1/channels';
 import './v1/chat';
+import './v1/chat.scheduleMessage';
 import './v1/cloud';
 import './v1/commands';
 import './v1/e2e';

apps/meteor/app/api/server/v1/chat.scheduleMessage.ts

@@ -0,0 +1,185 @@
+import type { IMessage } from '@rocket.chat/core-typings';
+import { Messages } from '@rocket.chat/models';
+import { ajv, validateBadRequestErrorResponse, validateUnauthorizedErrorResponse } from '@rocket.chat/rest-typings';
+import { check, Match } from 'meteor/check';
+import { Meteor } from 'meteor/meteor';
+
+import { canSendMessageAsync } from '../../../authorization/server/functions/canSendMessage';
+import { API } from '../api';
+import { getPaginationItems } from '../helpers/getPaginationItems';
+
+API.v1.post(
+	'chat.scheduleMessage',
+	{
+		authRequired: true,
+		response: {
+			200: ajv.compile<{ message: IMessage }>({
+				type: 'object',
+				properties: {
+					message: { $ref: '#/components/schemas/IMessage' },
+					success: { type: 'boolean', enum: [true] },
+				},
+				required: ['message', 'success'],
+				additionalProperties: false,
+			}),
+			400: validateBadRequestErrorResponse,
+			401: validateUnauthorizedErrorResponse,
+		},
+	},
+	async function action(this: any) {
+		check(this.bodyParams, {
+			roomId: String,
+			message: String,
+			scheduledAt: String,
+			tmid: Match.Maybe(String),
+		});
+
+		const { roomId, message, scheduledAt, tmid } = this.bodyParams as {
+			roomId: string;
+			message: string;
+			scheduledAt: string;
+			tmid?: string;
+		};
+
+		const scheduledDate = new Date(scheduledAt);
+		if (isNaN(scheduledDate.getTime())) {
+			throw new Meteor.Error('error-invalid-date', 'Invalid date format', { method: 'chat.scheduleMessage' });
+		}
+
+		if (scheduledDate <= new Date()) {
+			throw new Meteor.Error('error-past-date', 'Scheduled date must be in the future', { method: 'chat.scheduleMessage' });
+		}
+
+		if (tmid) {
+			const parentMessage = await Messages.findOneById(tmid, { projection: { rid: 1 } });
+			if (!parentMessage || parentMessage.rid !== roomId) {
+				throw new Meteor.Error('error-invalid-tmid', 'Thread message does not belong to this room', { method: 'chat.scheduleMessage' });
+			}
+		}
+
+		await canSendMessageAsync(roomId, this.user);
+
+		const messageData = {
+			rid: roomId,
+			msg: message,
+			u: {
+				_id: this.user._id,
+				username: this.user.username,
+				name: this.user.name,
+			},
+			ts: new Date(),
+			scheduledAt: scheduledDate,
+			scheduled: true,
+			...(tmid && { tmid }),
+		};
+
+		const result = await Messages.insertOne(messageData as IMessage);
+
+		return API.v1.success({
+			message: {
+				...messageData,
+				_id: result.insertedId,
+				_updatedAt: new Date(),
+			},
+		});
+	},
+);
+
+API.v1.get(
+	'chat.getScheduledMessages',
+	{
+		authRequired: true,
+		response: {
+			200: ajv.compile<{ messages: IMessage[]; count: number; offset: number; total: number }>({
+				type: 'object',
+				properties: {
+					messages: { type: 'array', items: { $ref: '#/components/schemas/IMessage' } },
+					count: { type: 'number' },
+					offset: { type: 'number' },
+					total: { type: 'number' },
+					success: { type: 'boolean', enum: [true] },
+				},
+				required: ['messages', 'count', 'offset', 'total', 'success'],
+				additionalProperties: false,
+			}),
+			400: validateBadRequestErrorResponse,
+			401: validateUnauthorizedErrorResponse,
+		},
+	},
+	async function action(this: any) {
+		const { roomId } = this.queryParams;
+		const { offset, count } = await getPaginationItems(this.queryParams);
+
+		check(roomId, String);
+
+		await canSendMessageAsync(roomId, this.user);
+
+		const messages = await Messages.find(
+			{
+				rid: roomId,
+				'u._id': this.userId,
+				scheduled: true,
+				scheduledAt: { $exists: true },
+			},
+			{
+				sort: { scheduledAt: 1 },
+				skip: Number(offset),
+				limit: Number(count),
+			},
+		).toArray();
+
+		const total = await Messages.countDocuments({
+			rid: roomId,
+			'u._id': this.userId,
+			scheduled: true,
+			scheduledAt: { $exists: true },
+		});
+
+		return API.v1.success({
+			messages,
+			count: messages.length,
+			offset,
+			total,
+		});
+	},
+);
+
+API.v1.post(
+	'chat.cancelScheduledMessage',
+	{
+		authRequired: true,
+		response: {
+			200: ajv.compile<{ success: boolean }>({
+				type: 'object',
+				properties: {
+					success: { type: 'boolean', enum: [true] },
+				},
+				required: ['success'],
+				additionalProperties: false,
+			}),
+			400: validateBadRequestErrorResponse,
+			401: validateUnauthorizedErrorResponse,
+		},
+	},
+	async function action(this: any) {
+		check(this.bodyParams, {
+			messageId: String,
+		});
+
+		const { messageId } = this.bodyParams as { messageId: string };
+
+		const result = await Messages.deleteOne({
+			_id: messageId,
+			'u._id': this.userId,
+			scheduled: true,
+		});
+
+		if (result.deletedCount === 0) {
+			throw new Meteor.Error('error-message-not-found', 'Scheduled message not found or already sent', {
+				method: 'chat.cancelScheduledMessage',
+			});
+		}
+
+		return API.v1.success({ success: true });
+	},
+);

apps/meteor/client/lib/chats/flows/scheduleMessage.ts

@@ -0,0 +1,31 @@
+import type { IRoom } from '@rocket.chat/core-typings';
+
+import { t } from '../../../../app/utils/lib/i18n';
+import { sdk } from '../../../../app/utils/client/lib/SDKClient';
+import { dispatchToastMessage } from '../../../lib/toast';
+
+export const scheduleMessage = async ({
+	rid,
+	msg,
+	scheduledAt,
+	tmid,
+}: {
+	rid: IRoom['_id'];
+	msg: string;
+	scheduledAt: Date;
+	tmid?: string;
+}): Promise<void> => {
+	try {
+		await sdk.rest.post('/v1/chat.scheduleMessage', {
+			roomId: rid,
+			message: msg,
+			scheduledAt: scheduledAt.toISOString(),
+			...(tmid && { tmid }),
+		});
+
+		dispatchToastMessage({ type: 'success', message: t('Message_sent') });
+	} catch (error: any) {
+		dispatchToastMessage({ type: 'error', message: error.message || t('Error') });
+		throw error;
+	}
+};

apps/meteor/client/views/room/composer/messageBox/MessageBox.tsx

@@ -22,6 +22,7 @@ import MessageBoxHint from './MessageBoxHint';
 import MessageBoxReplies from './MessageBoxReplies';
 import MessageComposerFiles from './MessageComposerFiles';
 import { handleSelectionWrapping } from './wrapSelection';
+import { useScheduleMessageButton } from './hooks/useScheduleMessageButton';
 import { createComposerAPI } from '../../../../../app/ui-message/client/messageBox/createComposerAPI';
 import type { FormattingButton } from '../../../../../app/ui-message/client/messageBox/messageBoxFormatting';
 import { formattingButtons } from '../../../../../app/ui-message/client/messageBox/messageBoxFormatting';
@@ -148,6 +149,11 @@ const MessageBox = ({
 
 	const useEmojis = useUserPreference<boolean>('useEmojis');
 
+	const { scheduleMenu } = useScheduleMessageButton(
+		room._id,
+		tmid,
+	);
+
 	const handleOpenEmojiPicker = useEffectEvent((e: MouseEvent<HTMLElement>) => {
 		e.stopPropagation();
 		e.preventDefault();
@@ -496,6 +502,7 @@ const MessageBox = ({
 						{canSend && (
 							<>
 								{isEditing && <MessageComposerButton onClick={closeEditing}>{t('Cancel')}</MessageComposerButton>}
+								{!isEditing && scheduleMenu}
 								<MessageComposerAction
 									aria-label={t('Send')}
 									icon='send'

apps/meteor/client/views/room/composer/messageBox/MessageBoxActionsToolbar/MessageBoxActionsToolbar.tsx

@@ -15,6 +15,7 @@ import { useShareLocationAction } from './hooks/useShareLocationAction';
 import { useTimestampAction } from './hooks/useTimestampAction';
 import { useVideoMessageAction } from './hooks/useVideoMessageAction';
 import { useWebdavActions } from './hooks/useWebdavActions';
+import { useViewScheduledMessagesAction } from './hooks/useViewScheduledMessagesAction';
 import { messageBox } from '../../../../../../app/ui-utils/client';
 import { useMessageboxAppsActionButtons } from '../../../../../hooks/useMessageboxAppsActionButtons';
 import { useChat } from '../../../contexts/ChatContext';
@@ -64,6 +65,7 @@ const MessageBoxActionsToolbar = ({
 	const createDiscussionAction = useCreateDiscussionAction(room);
 	const shareLocationAction = useShareLocationAction(room, tmid);
 	const timestampAction = useTimestampAction(chatContext.composer);
+	const viewScheduledMessagesAction = useViewScheduledMessagesAction(rid);
 
 	const apps = useMessageboxAppsActionButtons();
 	const { composerToolbox: hiddenActions } = useLayoutHiddenActions();
@@ -76,6 +78,7 @@ const MessageBoxActionsToolbar = ({
 		...(!isHidden(hiddenActions, shareLocationAction) && { shareLocationAction }),
 		...(timestampAction && !isHidden(hiddenActions, timestampAction) && { timestampAction }),
 		...(!hiddenActions.includes('webdav-add') && webdavActions && { webdavActions }),
+		...(!isHidden(hiddenActions, viewScheduledMessagesAction) && { viewScheduledMessagesAction }),
 	};
 
 	const featured = [];
@@ -85,6 +88,10 @@ const MessageBoxActionsToolbar = ({
 
 	createNew.push(allActions.createDiscussionAction);
 
+	if (allActions.viewScheduledMessagesAction) {
+		createNew.push(allActions.viewScheduledMessagesAction);
+	}
+
 	if (allActions.timestampAction) {
 		insert.push(allActions.timestampAction);
 	}

apps/meteor/client/views/room/composer/messageBox/MessageBoxActionsToolbar/hooks/useViewScheduledMessagesAction.tsx

@@ -0,0 +1,24 @@
+import type { GenericMenuItemProps } from '@rocket.chat/ui-client';
+import { useSetModal } from '@rocket.chat/ui-contexts';
+import { useTranslation } from 'react-i18next';
+import { useMemo } from 'react';
+
+import { MessageBoxScheduledMessagesModal } from '../../MessageBoxScheduledMessagesModal';
+
+export const useViewScheduledMessagesAction = (roomId: string): GenericMenuItemProps => {
+	const { t } = useTranslation();
+	const setModal = useSetModal();
+
+	return useMemo<GenericMenuItemProps>(
+		() => ({
+			id: 'view-scheduled-messages',
+			content: t('View_Scheduled_Messages'),
+			icon: 'clock',
+			disabled: false,
+			onClick: () => {
+				setModal(<MessageBoxScheduledMessagesModal roomId={roomId} onClose={() => setModal(null)} />);
+			},
+		}),
+		[t, roomId, setModal],
+	);
+};

apps/meteor/client/views/room/composer/messageBox/MessageBoxScheduleMenu.tsx

@@ -0,0 +1,19 @@
+import type { GenericMenuItemProps } from '@rocket.chat/ui-client';
+import { useTranslation } from 'react-i18next';
+
+export const useScheduleMenuItems = (): GenericMenuItemProps[] => {
+	const { t } = useTranslation();
+
+	return [
+		{
+			id: 'schedule-new-message',
+			icon: 'clock',
+			content: t('Schedule_new_message'),
+		},
+		{
+			id: 'view-scheduled-messages',
+			icon: 'list',
+			content: t('View_scheduled_messages'),
+		},
+	];
+};