Checklist (#9234) (#9284)

(cherry picked from commit be5b6c1)

Co-authored-by: Guillermo Vayá <[email protected]>

Author: mattermost-build

app/components/navigation_header/header.tsx

@@ -17,7 +17,7 @@ export type HeaderRightButton = {
     buttonType?: 'native' | 'opacity' | 'highlight';
     color?: string;
     iconName: string;
-    count?: number;
+    count?: number | string;
     onPress: () => void;
     rippleRadius?: number;
     testID?: string;

app/database/migration/server/index.ts

@@ -25,6 +25,17 @@ const {
 const {PLAYBOOK_RUN, PLAYBOOK_CHECKLIST, PLAYBOOK_CHECKLIST_ITEM, PLAYBOOK_RUN_ATTRIBUTE, PLAYBOOK_RUN_ATTRIBUTE_VALUE} = PLAYBOOK_TABLES;
 
 export default schemaMigrations({migrations: [
+    {
+        toVersion: 15,
+        steps: [
+            addColumns({
+                table: PLAYBOOK_RUN,
+                columns: [
+                    {name: 'type', type: 'string'},
+                ],
+            }),
+        ],
+    },
     {
         toVersion: 14,
         steps: [

app/database/schema/server/index.ts

@@ -45,7 +45,7 @@ import {
 } from './table_schemas';
 
 export const serverSchema: AppSchema = appSchema({
-    version: 14,
+    version: 15,
     tables: [
         CategorySchema,
         CategoryChannelSchema,

app/database/schema/server/test.ts

@@ -52,7 +52,7 @@ const {PLAYBOOK_RUN, PLAYBOOK_CHECKLIST, PLAYBOOK_CHECKLIST_ITEM, PLAYBOOK_RUN_A
 describe('*** Test schema for SERVER database ***', () => {
     it('=> The SERVER SCHEMA should strictly match', () => {
         expect(serverSchema).toEqual({
-            version: 14,
+            version: 15,
             unsafeSql: undefined,
             tables: {
                 [CATEGORY]: {
@@ -463,6 +463,7 @@ describe('*** Test schema for SERVER database ***', () => {
                         items_order: {name: 'items_order', type: 'string'},
                         previous_reminder: {name: 'previous_reminder', type: 'number', isOptional: true},
                         update_at: {name: 'update_at', type: 'number'},
+                        type: {name: 'type', type: 'string'},
                     },
                     columnArray: [
                         {name: 'playbook_id', type: 'string'},
@@ -489,6 +490,7 @@ describe('*** Test schema for SERVER database ***', () => {
                         {name: 'previous_reminder', type: 'number', isOptional: true},
                         {name: 'items_order', type: 'string'},
                         {name: 'update_at', type: 'number'},
+                        {name: 'type', type: 'string'},
                     ],
                 },
                 [PLAYBOOK_CHECKLIST]: {

app/products/playbooks/actions/local/checklist.test.ts

@@ -2,10 +2,11 @@
 // See LICENSE.txt for license information.
 
 import DatabaseManager from '@database/manager';
+import {getPlaybookChecklistById} from '@playbooks/database/queries/checklist';
 import {getPlaybookChecklistItemById} from '@playbooks/database/queries/item';
 import TestHelper from '@test/test_helper';
 
-import {updateChecklistItem, setChecklistItemCommand, setAssignee, setDueDate} from './checklist';
+import {updateChecklistItem, setChecklistItemCommand, setAssignee, setDueDate, renameChecklist} from './checklist';
 
 import type ServerDataOperator from '@database/operator/server_data_operator';
 
@@ -264,3 +265,109 @@ describe('setDueDate', () => {
         expect(updated!.dueDate).toBe(0);
     });
 });
+
+describe('renameChecklist', () => {
+    it('should handle not found database', async () => {
+        const {error} = await renameChecklist('foo', 'checklistid', 'New Title');
+        expect(error).toBeTruthy();
+        expect((error as Error).message).toContain('foo database not found');
+    });
+
+    it('should handle checklist not found', async () => {
+        const {error} = await renameChecklist(serverUrl, 'nonexistent', 'New Title');
+        expect(error).toBe('Checklist not found: nonexistent');
+    });
+
+    it('should handle database write errors', async () => {
+        const runId = 'runid';
+        const checklist = {
+            ...TestHelper.createPlaybookChecklist(runId, 0, 0),
+            run_id: runId,
+            order: 0,
+        };
+        await operator.handlePlaybookChecklist({checklists: [checklist], prepareRecordsOnly: false});
+
+        const originalWrite = operator.database.write;
+        operator.database.write = jest.fn().mockRejectedValue(new Error('Database write failed'));
+
+        const {error} = await renameChecklist(serverUrl, checklist.id, 'New Title');
+        expect(error).toBeTruthy();
+
+        operator.database.write = originalWrite;
+    });
+
+    it('should rename checklist successfully', async () => {
+        const runId = 'runid';
+        const checklist = {
+            ...TestHelper.createPlaybookChecklist(runId, 0, 0),
+            run_id: runId,
+            order: 0,
+        };
+        await operator.handlePlaybookChecklist({checklists: [checklist], prepareRecordsOnly: false});
+
+        const newTitle = 'Updated Checklist Title';
+        const {data, error} = await renameChecklist(serverUrl, checklist.id, newTitle);
+        expect(error).toBeUndefined();
+        expect(data).toBe(true);
+
+        const updated = await getPlaybookChecklistById(operator.database, checklist.id);
+        expect(updated).toBeDefined();
+        expect(updated!.title).toBe(newTitle);
+    });
+
+    it('should handle empty title string', async () => {
+        const runId = 'runid';
+        const checklist = {
+            ...TestHelper.createPlaybookChecklist(runId, 0, 0),
+            run_id: runId,
+            order: 0,
+        };
+        await operator.handlePlaybookChecklist({checklists: [checklist], prepareRecordsOnly: false});
+
+        const {data, error} = await renameChecklist(serverUrl, checklist.id, '');
+        expect(error).toBeUndefined();
+        expect(data).toBe(true);
+
+        const updated = await getPlaybookChecklistById(operator.database, checklist.id);
+        expect(updated).toBeDefined();
+        expect(updated!.title).toBe('');
+    });
+
+    it('should handle whitespace-only title', async () => {
+        const runId = 'runid';
+        const checklist = {
+            ...TestHelper.createPlaybookChecklist(runId, 0, 0),
+            run_id: runId,
+            order: 0,
+        };
+        await operator.handlePlaybookChecklist({checklists: [checklist], prepareRecordsOnly: false});
+
+        const whitespaceTitle = '   ';
+        const {data, error} = await renameChecklist(serverUrl, checklist.id, whitespaceTitle);
+        expect(error).toBeUndefined();
+        expect(data).toBe(true);
+
+        const updated = await getPlaybookChecklistById(operator.database, checklist.id);
+        expect(updated).toBeDefined();
+        expect(updated!.title).toBe(whitespaceTitle);
+    });
+
+    it('should handle very long titles', async () => {
+        const runId = 'runid';
+        const checklist = {
+            ...TestHelper.createPlaybookChecklist(runId, 0, 0),
+            run_id: runId,
+            order: 0,
+        };
+        await operator.handlePlaybookChecklist({checklists: [checklist], prepareRecordsOnly: false});
+
+        const longTitle = 'A'.repeat(300); // 300 characters
+        const {data, error} = await renameChecklist(serverUrl, checklist.id, longTitle);
+        expect(error).toBeUndefined();
+        expect(data).toBe(true);
+
+        const updated = await getPlaybookChecklistById(operator.database, checklist.id);
+        expect(updated).toBeDefined();
+        expect(updated!.title).toBe(longTitle);
+    });
+});

app/products/playbooks/actions/local/checklist.ts

@@ -2,6 +2,7 @@
 // See LICENSE.txt for license information.
 
 import DatabaseManager from '@database/manager';
+import {getPlaybookChecklistById} from '@playbooks/database/queries/checklist';
 import {getPlaybookChecklistItemById} from '@playbooks/database/queries/item';
 import {logError} from '@utils/log';
 
@@ -88,3 +89,24 @@ export async function setDueDate(serverUrl: string, itemId: string, date?: numbe
         return {error};
     }
 }
+
+export async function renameChecklist(serverUrl: string, checklistId: string, title: string) {
+    try {
+        const {database} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
+        const checklist = await getPlaybookChecklistById(database, checklistId);
+        if (!checklist) {
+            return {error: `Checklist not found: ${checklistId}`};
+        }
+
+        await database.write(async () => {
+            checklist.update((c) => {
+                c.title = title;
+            });
+        });
+
+        return {data: true};
+    } catch (error) {
+        logError('failed to rename checklist', error);
+        return {error};
+    }
+}

app/products/playbooks/actions/local/run.test.ts

@@ -5,7 +5,7 @@ import DatabaseManager from '@database/manager';
 import {PLAYBOOK_TABLES} from '@playbooks/constants/database';
 import TestHelper from '@test/test_helper';
 
-import {handlePlaybookRuns, setOwner} from './run';
+import {handlePlaybookRuns, setOwner, renamePlaybookRun} from './run';
 
 import type {Database} from '@nozbe/watermelondb';
 import type PlaybookRunModel from '@playbooks/types/database/models/playbook_run';
@@ -80,7 +80,7 @@ describe('setOwner', () => {
 
         const {data, error} = await setOwner(serverUrl, nonExistentRunId, newOwnerId);
 
-        expect(error).toBe('Run not found');
+        expect(error).toBe('Checklist not found');
         expect(data).toBeUndefined();
     });
 
@@ -153,3 +153,100 @@ describe('setOwner', () => {
         expect(updatedRun.ownerUserId).toBe(emptyOwnerId);
     });
 });
+
+describe('renamePlaybookRun', () => {
+    let database: Database;
+    beforeEach(() => {
+        database = DatabaseManager.getServerDatabaseAndOperator(serverUrl).database;
+    });
+
+    it('should handle not found database', async () => {
+        const {error} = await renamePlaybookRun('foo', 'runid', 'New Name');
+        expect(error).toBeTruthy();
+        expect((error as Error).message).toContain('foo database not found');
+    });
+
+    it('should handle playbook run not found', async () => {
+        const {error} = await renamePlaybookRun(serverUrl, 'nonexistent', 'New Name');
+        expect(error).toBe('Playbook run not found: nonexistent');
+    });
+
+    it('should handle database write errors', async () => {
+        const runs = TestHelper.createPlaybookRuns(1, 0, 0);
+        await handlePlaybookRuns(serverUrl, runs, false, false);
+
+        const playbookRunId = runs[0].id;
+
+        const originalWrite = database.write;
+        database.write = jest.fn().mockRejectedValue(new Error('Database write failed'));
+
+        const {error} = await renamePlaybookRun(serverUrl, playbookRunId, 'New Name');
+        expect(error).toBeTruthy();
+        expect((error as Error).message).toBe('Database write failed');
+
+        database.write = originalWrite;
+    });
+
+    it('should rename playbook run successfully', async () => {
+        const runs = TestHelper.createPlaybookRuns(1, 0, 0);
+        await handlePlaybookRuns(serverUrl, runs, false, false);
+
+        const playbookRunId = runs[0].id;
+        const newName = 'Updated Run Name';
+
+        const {data, error} = await renamePlaybookRun(serverUrl, playbookRunId, newName);
+
+        expect(error).toBeUndefined();
+        expect(data).toBe(true);
+
+        const updatedRun = await database.get<PlaybookRunModel>(PLAYBOOK_TABLES.PLAYBOOK_RUN).find(playbookRunId);
+        expect(updatedRun.name).toBe(newName);
+    });
+
+    it('should handle empty name string', async () => {
+        const runs = TestHelper.createPlaybookRuns(1, 0, 0);
+        await handlePlaybookRuns(serverUrl, runs, false, false);
+
+        const playbookRunId = runs[0].id;
+
+        const {data, error} = await renamePlaybookRun(serverUrl, playbookRunId, '');
+
+        expect(error).toBeUndefined();
+        expect(data).toBe(true);
+
+        const updatedRun = await database.get<PlaybookRunModel>(PLAYBOOK_TABLES.PLAYBOOK_RUN).find(playbookRunId);
+        expect(updatedRun.name).toBe('');
+    });
+
+    it('should handle whitespace-only name', async () => {
+        const runs = TestHelper.createPlaybookRuns(1, 0, 0);
+        await handlePlaybookRuns(serverUrl, runs, false, false);
+
+        const playbookRunId = runs[0].id;
+        const whitespaceName = '   ';
+
+        const {data, error} = await renamePlaybookRun(serverUrl, playbookRunId, whitespaceName);
+
+        expect(error).toBeUndefined();
+        expect(data).toBe(true);
+
+        const updatedRun = await database.get<PlaybookRunModel>(PLAYBOOK_TABLES.PLAYBOOK_RUN).find(playbookRunId);
+        expect(updatedRun.name).toBe(whitespaceName);
+    });
+
+    it('should handle very long names', async () => {
+        const runs = TestHelper.createPlaybookRuns(1, 0, 0);
+        await handlePlaybookRuns(serverUrl, runs, false, false);
+
+        const playbookRunId = runs[0].id;
+        const longName = 'A'.repeat(300); // 300 characters
+
+        const {data, error} = await renamePlaybookRun(serverUrl, playbookRunId, longName);
+
+        expect(error).toBeUndefined();
+        expect(data).toBe(true);
+
+        const updatedRun = await database.get<PlaybookRunModel>(PLAYBOOK_TABLES.PLAYBOOK_RUN).find(playbookRunId);
+        expect(updatedRun.name).toBe(longName);
+    });
+});

app/products/playbooks/actions/local/run.ts

@@ -15,7 +15,7 @@ export async function handlePlaybookRuns(serverUrl: string, runs: PlaybookRun[],
         });
         return {data};
     } catch (error) {
-        logError('failed to handle playbook runs', error);
+        logError('failed to handle playbook checklist', error);
         return {error};
     }
 }
@@ -25,7 +25,7 @@ export async function setOwner(serverUrl: string, playbookRunId: string, ownerId
         const {database} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
         const run = await getPlaybookRunById(database, playbookRunId);
         if (!run) {
-            return {error: 'Run not found'};
+            return {error: 'Checklist not found'};
         }
 
         await database.write(async () => {
@@ -40,3 +40,24 @@ export async function setOwner(serverUrl: string, playbookRunId: string, ownerId
         return {error};
     }
 }
+
+export async function renamePlaybookRun(serverUrl: string, playbookRunId: string, name: string) {
+    try {
+        const {database} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
+        const run = await getPlaybookRunById(database, playbookRunId);
+        if (!run) {
+            return {error: `Playbook run not found: ${playbookRunId}`};
+        }
+
+        await database.write(async () => {
+            run.update((r) => {
+                r.name = name;
+            });
+        });
+
+        return {data: true};
+    } catch (error) {
+        logError('failed to rename playbook run', error);
+        return {error};
+    }
+}