Create scheduled post api integration

app/actions/remote/scheduled_post.test.ts

@@ -0,0 +1,72 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import DatabaseManager from '@database/manager';
+import NetworkManager from '@managers/network_manager';
+
+import {createScheduledPost} from './scheduled_post';
+
+import type ServerDataOperator from '@database/operator/server_data_operator';
+
+const serverUrl = 'baseHandler.test.com';
+let operator: ServerDataOperator;
+
+const user1 = {id: 'userid1', username: 'user1', email: '[email protected]', roles: ''} as UserProfile;
+const scheduledPost = {
+    id: 'scheduledPostId1',
+    root_id: '',
+    update_at: 0,
+    channel_id: 'channelid1',
+    message: 'Test message',
+    scheduled_at: Date.now() + 10000,
+} as ScheduledPost;
+
+const throwFunc = () => {
+    throw Error('error');
+};
+
+const mockClient = {
+    createScheduledPost: jest.fn(() => ({...scheduledPost})),
+};
+
+beforeAll(() => {
+    // eslint-disable-next-line
+    // @ts-ignore
+    NetworkManager.getClient = () => mockClient;
+});
+
+beforeEach(async () => {
+    await DatabaseManager.init([serverUrl]);
+    operator = DatabaseManager.serverDatabases[serverUrl]!.operator;
+});
+
+afterEach(async () => {
+    await DatabaseManager.destroyServerDatabase(serverUrl);
+});
+
+describe('scheduled_post', () => {
+    it('createScheduledPost - handle not found database', async () => {
+        const result = await createScheduledPost('foo', scheduledPost);
+        expect(result).toBeDefined();
+        expect(result.error).toBeDefined();
+    });
+
+    it('createScheduledPost - base case', async () => {
+        await operator.handleUsers({users: [user1], prepareRecordsOnly: false});
+        const result = await createScheduledPost(serverUrl, scheduledPost);
+        expect(result).toBeDefined();
+        expect(result.error).toBeUndefined();
+        expect(result.data).toBe(true);
+        expect(result.response).toBeDefined();
+        if (result.response) {
+            expect(result.response.id).toBe(scheduledPost.id);
+        }
+    });
+
+    it('createScheduledPost - request error', async () => {
+        mockClient.createScheduledPost.mockImplementationOnce(jest.fn(throwFunc));
+        const result = await createScheduledPost(serverUrl, scheduledPost);
+        expect(result).toBeDefined();
+        expect(result.error).toBeDefined();
+    });
+});

app/actions/remote/scheduled_post.ts

@@ -2,26 +2,28 @@
 // See LICENSE.txt for license information.
 
 import {forceLogoutIfNecessary} from '@actions/remote/session';
+import DatabaseManager from '@database/manager';
 import NetworkManager from '@managers/network_manager';
-import websocketManager from '@managers/websocket_manager';
 import {getFullErrorMessage} from '@utils/errors';
 import {logError} from '@utils/log';
 
-export async function createScheduledPost(serverUrl: string, schedulePost: ScheduledPost, connectionId?: string, fetchOnly = false) {
+import type {CreateResponse} from '@hooks/handle_send_message';
+
+export async function createScheduledPost(serverUrl: string, schedulePost: ScheduledPost, connectionId?: string): Promise<CreateResponse> {
+    const operator = DatabaseManager.serverDatabases[serverUrl]?.operator;
+    if (!operator) {
+        return {error: `${serverUrl} database not found`};
+    }
+
     try {
         const client = NetworkManager.getClient(serverUrl);
-        const ws = websocketManager.getClient(serverUrl);
-
-        const created = await client.createScheduledPost(schedulePost, ws?.getConnectionId());
+        const response = await client.createScheduledPost(schedulePost, connectionId);
 
-        if (!fetchOnly) {
-            // TODO - to be implemented later once DB tables are ready
-            // await operator.handleScheduledPost({scheduledPosts: [created], prepareRecordsOnly: false});
-        }
-        return {scheduledPost: created};
+        // TODO - record scheduled post in database here
+        return {data: true, response};
     } catch (error) {
         logError('error on createScheduledPost', getFullErrorMessage(error));
         forceLogoutIfNecessary(serverUrl, error);
-        return {error};
+        return {error: getFullErrorMessage(error)};
     }
 }

app/components/post_draft/draft_input/draft_input.tsx

@@ -48,7 +48,7 @@ type Props = {
     cursorPosition: number;
 
     // Send Handler
-    sendMessage: () => void;
+    sendMessage: (schedulingInfo?: SchedulingInfo) => Promise<void | {data?: boolean; error?: unknown}>;
     canSend: boolean;
     maxMessageLength: number;
 
@@ -164,13 +164,16 @@ function DraftInput({
         postPriority,
     });
 
-    const handleSendMessage = useCallback(async () => {
+    const handleSendMessage = useCallback(async (schedulingInfoParam?: SchedulingInfo) => {
+        const schedulingInfo = (schedulingInfoParam && 'scheduled_at' in schedulingInfoParam) ? schedulingInfoParam : undefined;
+
         if (persistentNotificationsEnabled) {
-            persistentNotificationsConfirmation(serverUrl, value, mentionsList, intl, sendMessage, persistentNotificationMaxRecipients, persistentNotificationInterval, currentUserId, channelName, channelType);
-        } else {
-            sendMessage();
+            // const sendMessageWithScheduledPost = () => sendMessage(schedulingInfo);
+            await persistentNotificationsConfirmation(serverUrl, value, mentionsList, intl, sendMessage, persistentNotificationMaxRecipients, persistentNotificationInterval, currentUserId, channelName, channelType);
+            return Promise.resolve();
         }
-    }, [serverUrl, mentionsList, persistentNotificationsEnabled, persistentNotificationMaxRecipients, sendMessage, value, channelType]);
+        return sendMessage(schedulingInfo);
+    }, [persistentNotificationsEnabled, serverUrl, value, mentionsList, intl, sendMessage, persistentNotificationMaxRecipients, persistentNotificationInterval, currentUserId, channelName, channelType]);
 
     const handleShowScheduledPostOptions = useCallback(() => {
         if (!scheduledPostsEnabled) {
@@ -187,9 +190,10 @@ function DraftInput({
             title,
             props: {
                 closeButtonId: SCHEDULED_POST_PICKER_BUTTON,
+                onSchedule: handleSendMessage,
             },
         });
-    }, [intl, isTablet, scheduledPostsEnabled, theme]);
+    }, [handleSendMessage, intl, isTablet, scheduledPostsEnabled, theme]);
 
     const sendActionDisabled = !canSend || noMentionsError;
 

app/components/post_draft/send_action/index.tsx

@@ -7,6 +7,7 @@ import {View} from 'react-native';
 import CompassIcon from '@components/compass_icon';
 import TouchableWithFeedback from '@components/touchable_with_feedback';
 import {useTheme} from '@context/theme';
+import {usePreventDoubleTap} from '@hooks/utils';
 import {changeOpacity, makeStyleSheetFromTheme} from '@utils/theme';
 
 type Props = {
@@ -55,10 +56,12 @@ function SendButton({
 
     const buttonColor = disabled ? changeOpacity(theme.buttonColor, 0.5) : theme.buttonColor;
 
+    const sendMessageWithDoubleTapPrevention = usePreventDoubleTap(sendMessage);
+
     return (
         <TouchableWithFeedback
             testID={sendButtonTestID}
-            onPress={sendMessage}
+            onPress={sendMessageWithDoubleTapPrevention}
             style={style.sendButtonContainer}
             type={'opacity'}
             disabled={disabled}

app/constants/snack_bar.ts

@@ -19,6 +19,7 @@ export const SNACK_BAR_TYPE = keyMirror({
     UNFAVORITE_CHANNEL: null,
     UNMUTE_CHANNEL: null,
     UNFOLLOW_THREAD: null,
+    SCHEDULED_POST_CREATION_ERROR: null,
 });
 
 export const MESSAGE_TYPE = {
@@ -27,7 +28,7 @@ export const MESSAGE_TYPE = {
     DEFAULT: 'default',
 };
 
-type SnackBarConfig = {
+export type SnackBarConfig = {
     id: string;
     defaultMessage: string;
     iconName: string;

app/hooks/handle_send_message.test.tsx

@@ -141,22 +141,6 @@ describe('useHandleSendMessage', () => {
         expect(DeviceEventEmitter.emit).toHaveBeenCalledWith(Events.POST_LIST_SCROLL_TO_BOTTOM, Screens.THREAD);
     });
 
-    it('should not allow sending while already sending', async () => {
-        const {result} = renderHook(() => useHandleSendMessage(defaultProps), {wrapper});
-
-        // Trigger first send
-        await act(async () => {
-            result.current.handleSendMessage();
-        });
-
-        // Try to send again immediately
-        await act(async () => {
-            result.current.handleSendMessage();
-        });
-
-        expect(createPost).toHaveBeenCalledTimes(1);
-    });
-
     it('should not allow sending with uploading files', () => {
         const props = {
             ...defaultProps,

app/hooks/handle_send_message.ts

@@ -9,6 +9,7 @@ import {getChannelTimezones} from '@actions/remote/channel';
 import {executeCommand, handleGotoLocation} from '@actions/remote/command';
 import {createPost} from '@actions/remote/post';
 import {handleReactionToLatestPost} from '@actions/remote/reactions';
+import {createScheduledPost} from '@actions/remote/scheduled_post';
 import {setStatus} from '@actions/remote/user';
 import {handleCallsSlashCommand} from '@calls/actions';
 import {Events, Screens} from '@constants';
@@ -18,11 +19,17 @@ import DraftUploadManager from '@managers/draft_upload_manager';
 import * as DraftUtils from '@utils/draft';
 import {isReactionMatch} from '@utils/emoji/helpers';
 import {getFullErrorMessage} from '@utils/errors';
-import {preventDoubleTap} from '@utils/tap';
+import {scheduledPostFromPost} from '@utils/post';
 import {confirmOutOfOfficeDisabled} from '@utils/user';
 
 import type CustomEmojiModel from '@typings/database/models/servers/custom_emoji';
 
+export type CreateResponse = {
+    data?: boolean;
+    error?: unknown;
+    response?: Post | ScheduledPost;
+}
+
 type Props = {
     value: string;
     channelId: string;
@@ -86,7 +93,7 @@ export const useHandleSendMessage = ({
         setSendingMessage(false);
     }, [serverUrl, rootId, clearDraft]);
 
-    const doSubmitMessage = useCallback(() => {
+    const doSubmitMessage = useCallback(async (schedulingInfo?: SchedulingInfo): Promise<CreateResponse> => {
         const postFiles = files.filter((f) => !f.failed);
         const post = {
             user_id: currentUserId,
@@ -105,20 +112,31 @@ export const useHandleSendMessage = ({
             };
         }
 
-        createPost(serverUrl, post, postFiles);
+        let response: CreateResponse;
+        if (schedulingInfo) {
+            response = await createScheduledPost(serverUrl, scheduledPostFromPost(post, schedulingInfo, postPriority));
+        } else {
+            response = await createPost(serverUrl, post, postFiles);
+        }
 
         clearDraft();
         setSendingMessage(false);
         DeviceEventEmitter.emit(Events.POST_LIST_SCROLL_TO_BOTTOM, rootId ? Screens.THREAD : Screens.CHANNEL);
+
+        return response;
     }, [files, currentUserId, channelId, rootId, value, postPriority, serverUrl, clearDraft]);
 
-    const showSendToAllOrChannelOrHereAlert = useCallback((calculatedMembersCount: number, atHere: boolean) => {
+    const showSendToAllOrChannelOrHereAlert = useCallback((calculatedMembersCount: number, atHere: boolean, schedulingInfo?: SchedulingInfo) => {
         const notifyAllMessage = DraftUtils.buildChannelWideMentionMessage(intl, calculatedMembersCount, channelTimezoneCount, atHere);
         const cancel = () => {
             setSendingMessage(false);
         };
 
-        DraftUtils.alertChannelWideMention(intl, notifyAllMessage, doSubmitMessage, cancel);
+        // Creating a wrapper function to pass the schedulingInfo to the doSubmitMessage function as the accepted
+        // function signature causes conflict.\
+        // TODO for later - change alert message if this is a scheduled post
+        const doSubmitMessageScheduledPostWrapper = () => doSubmitMessage(schedulingInfo);
+        DraftUtils.alertChannelWideMention(intl, notifyAllMessage, doSubmitMessageScheduledPostWrapper, cancel);
     }, [intl, channelTimezoneCount, doSubmitMessage]);
 
     const sendCommand = useCallback(async () => {
@@ -167,31 +185,34 @@ export const useHandleSendMessage = ({
         }
     }, [value, userIsOutOfOffice, serverUrl, intl, channelId, rootId, clearDraft, channelType, currentUserId]);
 
-    const sendMessage = useCallback(() => {
+    const sendMessage = useCallback(async (schedulingInfo?: SchedulingInfo) => {
         const notificationsToChannel = enableConfirmNotificationsToChannel && useChannelMentions;
         const toAllOrChannel = DraftUtils.textContainsAtAllAtChannel(value);
         const toHere = DraftUtils.textContainsAtHere(value);
 
-        if (value.indexOf('/') === 0) {
+        if (value.indexOf('/') === 0 && !schedulingInfo) {
+            // Don't execute slash command when scheduling message
             sendCommand();
         } else if (notificationsToChannel && membersCount > NOTIFY_ALL_MEMBERS && (toAllOrChannel || toHere)) {
-            showSendToAllOrChannelOrHereAlert(membersCount, toHere && !toAllOrChannel);
+            showSendToAllOrChannelOrHereAlert(membersCount, toHere && !toAllOrChannel, schedulingInfo);
         } else {
-            doSubmitMessage();
+            return doSubmitMessage(schedulingInfo);
         }
+
+        return Promise.resolve();
     }, [enableConfirmNotificationsToChannel, useChannelMentions, value, membersCount, sendCommand, showSendToAllOrChannelOrHereAlert, doSubmitMessage]);
 
-    const handleSendMessage = useCallback(preventDoubleTap(() => {
+    const handleSendMessage = useCallback(async (schedulingInfo?: SchedulingInfo) => {
         if (!canSend) {
-            return;
+            return Promise.resolve();
         }
 
         setSendingMessage(true);
 
         const match = isReactionMatch(value, customEmojis);
         if (match && !files.length) {
             handleReaction(match.emoji, match.add);
-            return;
+            return Promise.resolve();
         }
 
         const hasFailedAttachments = files.some((f) => f.failed);
@@ -201,14 +222,16 @@ export const useHandleSendMessage = ({
             };
             const accept = () => {
                 // Files are filtered on doSubmitMessage
-                sendMessage();
+                sendMessage(schedulingInfo);
             };
 
             DraftUtils.alertAttachmentFail(intl, accept, cancel);
         } else {
-            sendMessage();
+            return sendMessage(schedulingInfo);
         }
-    }), [canSend, value, handleReaction, files, sendMessage, customEmojis]);
+
+        return Promise.resolve();
+    }, [canSend, value, customEmojis, files, handleReaction, intl, sendMessage]);
 
     useEffect(() => {
         getChannelTimezones(serverUrl, channelId).then(({channelTimezones}) => {

app/screens/convert_gm_to_channel/convert_gm_to_channel_form/convert_gm_to_channel_form.tsx

@@ -130,7 +130,7 @@ export const ConvertGMToChannelForm = ({
     const defaultUserDisplayNames = formatMessage({id: 'channel_info.convert_gm_to_channel.warning.body.yourself', defaultMessage: 'yourself'});
     const memberNames = profiles.length > 0 ? formatList(userDisplayNames) : defaultUserDisplayNames;
     const messageBoxBody = formatMessage({
-        id: 'channel_info.convert_gm_to_channel.warning.bodyXXXX',
+        id: 'channel_info.convert_gm_to_channel.warning.body',
         defaultMessage: 'You are about to convert the Group Message with {memberNames} to a Channel. This cannot be undone.',
     }, {
         memberNames,

app/screens/scheduled_post_options/core_options/core_options.tsx

@@ -63,12 +63,12 @@ export function ScheduledPostCoreOptions({userTimezone, isMilitaryTime, onSelect
         }
 
         if (selectedTime) {
-            onSelectOption(selectedTime.unix().toString());
+            onSelectOption(selectedTime.valueOf().toString());
         }
     }, [now, onSelectOption]);
 
     const handleCustomTimeChange = useCallback((selectedTime: Moment) => {
-        onSelectOption(selectedTime.unix().toString());
+        onSelectOption(selectedTime.valueOf().toString());
     }, [onSelectOption]);
 
     const nineAmTime = moment().