Unit test for mobile draft

app/actions/local/draft.test.ts

@@ -12,6 +12,7 @@ import {
     addFilesToDraft,
     removeDraft,
     updateDraftPriority,
+    updateDraftMarkdownImageMetadata,
 } from './draft';
 
 import type ServerDataOperator from '@database/operator/server_data_operator';
@@ -234,3 +235,41 @@ describe('updateDraftPriority', () => {
         expect(result.draft.metadata?.priority?.priority).toBe(postPriority.priority);
     });
 });
+
+describe('updateDraftMarkdownImageMetadata', () => {
+    const imageMetadata = {images: {width: 100, height: 100}};
+    it('handle not found database', async () => {
+        const {error} = await updateDraftMarkdownImageMetadata({
+            serverUrl: 'foo',
+            channelId,
+            rootId: '',
+            imageMetadata: {images: {width: 100, height: 100}},
+        });
+        expect(error).toBeTruthy();
+    });
+
+    it('handles no draft', async () => {
+        const result = await updateDraftMarkdownImageMetadata({
+            serverUrl,
+            channelId,
+            rootId: '',
+            imageMetadata,
+        });
+        expect(result.draft).toBeUndefined();
+    });
+
+    it('updates metadata for an existing draft', async () => {
+        await operator.handleDraft({drafts: [draft], prepareRecordsOnly: false});
+
+        const {draft: updatedDraft, error} = await updateDraftMarkdownImageMetadata({
+            serverUrl,
+            channelId,
+            rootId: '',
+            imageMetadata,
+        });
+
+        expect(error).toBeUndefined();
+        expect(updatedDraft).toBeDefined();
+        expect(updatedDraft?.metadata?.images).toEqual(imageMetadata);
+    });
+});

app/actions/local/draft.ts

@@ -1,10 +1,24 @@
 // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
 // See LICENSE.txt for license information.
 
+import {DeviceEventEmitter, Image} from 'react-native';
+
+import {Navigation, Screens} from '@constants';
 import DatabaseManager from '@database/manager';
 import {getDraft} from '@queries/servers/drafts';
+import {goToScreen} from '@screens/navigation';
+import {isTablet} from '@utils/helpers';
 import {logError} from '@utils/log';
 
+export const switchToGlobalDrafts = async () => {
+    const isTablelDevice = isTablet();
+    if (isTablelDevice) {
+        DeviceEventEmitter.emit(Navigation.NAVIGATION_HOME, Screens.GLOBAL_DRAFTS);
+    } else {
+        goToScreen(Screens.GLOBAL_DRAFTS, '', {}, {topBar: {visible: false}});
+    }
+};
+
 export async function updateDraftFile(serverUrl: string, channelId: string, rootId: string, file: FileInfo, prepareRecordsOnly = false) {
     try {
         const {database, operator} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
@@ -197,3 +211,83 @@ export async function updateDraftPriority(serverUrl: string, channelId: string,
         return {error};
     }
 }
+
+export async function updateDraftMarkdownImageMetadata({
+    serverUrl,
+    channelId,
+    rootId,
+    imageMetadata,
+    prepareRecordsOnly = false,
+}: {
+    serverUrl: string;
+    channelId: string;
+    rootId: string;
+    imageMetadata: Dictionary<PostImage | undefined>;
+    prepareRecordsOnly?: boolean;
+}) {
+    try {
+        const {database, operator} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
+        const draft = await getDraft(database, channelId, rootId);
+        if (draft) {
+            draft.prepareUpdate((d) => {
+                d.metadata = {
+                    ...d.metadata,
+                    images: imageMetadata,
+                };
+                d.updateAt = Date.now();
+            });
+            if (!prepareRecordsOnly) {
+                await operator.batchRecords([draft], 'updateDraftImageMetadata');
+            }
+        }
+        return {draft};
+    } catch (error) {
+        logError('Failed updateDraftImages', error);
+        return {error};
+    }
+}
+
+async function getImageMetadata(url: string) {
+    let height = 0;
+    let width = 0;
+    let format;
+    try {
+        await new Promise((resolve, reject) => {
+            Image.getSize(
+                url,
+                (imageWidth, imageHeight) => {
+                    width = imageWidth;
+                    height = imageHeight;
+                    resolve(null);
+                },
+                (error) => {
+                    logError('Failed to get image size', error);
+                    reject(error);
+                },
+            );
+        });
+    } catch (error) {
+        width = 0;
+        height = 0;
+    }
+    const match = url.match(/\.(\w+)(?=\?|$)/);
+    if (match) {
+        format = match[1];
+    }
+    return {
+        height,
+        width,
+        format,
+        frame_count: 1,
+    };
+}
+
+export async function parseMarkdownImages(markdown: string, imageMetadata: Dictionary<PostImage | undefined>) {
+    let match;
+    const imageRegex = /!\[.*?\]\((https:\/\/[^\s)]+)\)/g;
+    while ((match = imageRegex.exec(markdown)) !== null) {
+        const imageUrl = match[1];
+        // eslint-disable-next-line no-await-in-loop
+        imageMetadata[imageUrl] = await getImageMetadata(imageUrl);
+    }
+}