@cccsaurora/howler-ui 2.18.0-dev.704 → 2.18.0-dev.705

package/components/routes/cases/detail/sidebar/CaseFolderContextMenu.test.js

@@ -0,0 +1,351 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { act } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+vi.mock('components/elements/ContextMenu', () => ({
+    default: ({ items, children }) => (_jsxs("div", { children: [children, items.map((item) => {
+                if (item.kind === 'item') {
+                    return (_jsx("button", { id: item.id, onClick: item.onClick, children: item.label }, item.id));
+                }
+                if (item.kind === 'divider') {
+                    return _jsx("hr", {}, item.id);
+                }
+                return null;
+            })] }))
+}));
+const mockDispatchApi = vi.hoisted(() => vi.fn());
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+const mockDel = vi.hoisted(() => vi.fn());
+const mockPatch = vi.hoisted(() => vi.fn());
+vi.mock('api', () => ({
+    default: {
+        v2: {
+            case: {
+                items: {
+                    del: (...args) => mockDel(...args),
+                    patch: (...args) => mockPatch(...args)
+                }
+            }
+        }
+    }
+}));
+const mockShowModal = vi.hoisted(() => vi.fn());
+vi.mock('components/app/providers/ModalProvider', async () => {
+    const { createContext } = await import('react');
+    return {
+        ModalContext: createContext({ showModal: mockShowModal, close: vi.fn(), setContent: vi.fn() })
+    };
+});
+vi.mock('components/routes/cases/modals/RenameItemModal', () => ({
+    default: () => _jsx("div", { id: "rename-item-modal" })
+}));
+// ---------------------------------------------------------------------------
+// Imports (after mocks so that module registry picks up the stubs)
+// ---------------------------------------------------------------------------
+import CaseFolderContextMenu, { collectAllLeaves, getOpenUrl } from './CaseFolderContextMenu';
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+const mockCase = { case_id: 'case-1', title: 'Test Case', items: [] };
+const hitLeaf = { type: 'hit', value: 'hit-123', path: 'folder/hit-item' };
+const referenceLeaf = { type: 'reference', value: 'https://example.com', path: 'folder/ref-item' };
+const observableLeaf = { type: 'observable', value: 'obs-456', path: 'folder/obs-item' };
+const caseLeaf = { type: 'case', value: 'nested-case-id', path: 'folder/case-item' };
+const tableLeaf = { type: 'table', value: 'table-789', path: 'folder/table-item' };
+const leadLeaf = { type: 'lead', value: 'lead-999', path: 'folder/lead-item' };
+const renderMenu = (props) => render(_jsx(CaseFolderContextMenu, { _case: mockCase, ...props, children: _jsx("div", { id: "child", children: "child" }) }));
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+beforeEach(() => {
+    mockDel.mockClear();
+    mockPatch.mockClear();
+    mockDispatchApi.mockClear();
+    mockShowModal.mockClear();
+    mockDispatchApi.mockImplementation((p) => p);
+    mockDel.mockResolvedValue(mockCase);
+    mockPatch.mockResolvedValue(mockCase);
+    vi.spyOn(window, 'open').mockReturnValue(null);
+});
+// ---------------------------------------------------------------------------
+// Unit tests for exported utilities
+// ---------------------------------------------------------------------------
+describe('collectAllLeaves', () => {
+    it('returns leaves at the root level', () => {
+        const tree = { leaves: [hitLeaf, referenceLeaf] };
+        expect(collectAllLeaves(tree)).toEqual([hitLeaf, referenceLeaf]);
+    });
+    it('returns leaves from nested subfolders', () => {
+        const tree = {
+            leaves: [hitLeaf],
+            subfolder: { leaves: [referenceLeaf] }
+        };
+        expect(collectAllLeaves(tree)).toEqual([hitLeaf, referenceLeaf]);
+    });
+    it('returns leaves from deeply nested subfolders', () => {
+        const tree = {
+            leaves: [],
+            level1: {
+                leaves: [hitLeaf],
+                level2: { leaves: [referenceLeaf] }
+            }
+        };
+        const result = collectAllLeaves(tree);
+        expect(result).toContain(hitLeaf);
+        expect(result).toContain(referenceLeaf);
+    });
+    it('returns an empty array for an empty tree', () => {
+        expect(collectAllLeaves({ leaves: [] })).toEqual([]);
+    });
+});
+describe('getOpenUrl', () => {
+    it('returns the value directly for a reference item', () => {
+        expect(getOpenUrl(referenceLeaf)).toBe('https://example.com');
+    });
+    it('returns /hits/<id> for a hit item', () => {
+        expect(getOpenUrl(hitLeaf)).toBe('/hits/hit-123');
+    });
+    it('returns /observables/<id> for an observable item', () => {
+        expect(getOpenUrl(observableLeaf)).toBe('/observables/obs-456');
+    });
+    it('returns /cases/<id> for a case item', () => {
+        expect(getOpenUrl(caseLeaf)).toBe('/cases/nested-case-id');
+    });
+    it('returns null for a table item', () => {
+        expect(getOpenUrl(tableLeaf)).toBeNull();
+    });
+    it('returns null for a lead item', () => {
+        expect(getOpenUrl(leadLeaf)).toBeNull();
+    });
+    it('returns null when value is undefined', () => {
+        expect(getOpenUrl({ type: 'hit' })).toBeNull();
+    });
+    it('returns null when type is undefined', () => {
+        expect(getOpenUrl({ value: 'something' })).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// Component tests
+// ---------------------------------------------------------------------------
+describe('CaseFolderContextMenu', () => {
+    describe('renders children', () => {
+        it('renders children content', () => {
+            renderMenu({ leaf: hitLeaf });
+            expect(screen.getByTestId('child')).toBeInTheDocument();
+        });
+    });
+    describe('menu items for leaf types', () => {
+        it('shows "Open item" and "Remove item" for a hit leaf', () => {
+            renderMenu({ leaf: hitLeaf });
+            expect(screen.getByTestId('open-item')).toBeInTheDocument();
+            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
+        });
+        it('shows "Open item" and "Remove item" for a reference leaf', () => {
+            renderMenu({ leaf: referenceLeaf });
+            expect(screen.getByTestId('open-item')).toBeInTheDocument();
+            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
+        });
+        it('shows "Open item" and "Remove item" for an observable leaf', () => {
+            renderMenu({ leaf: observableLeaf });
+            expect(screen.getByTestId('open-item')).toBeInTheDocument();
+            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
+        });
+        it('shows "Open item" and "Remove item" for a case leaf', () => {
+            renderMenu({ leaf: caseLeaf });
+            expect(screen.getByTestId('open-item')).toBeInTheDocument();
+            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
+        });
+        it('shows only "Remove item" for a table leaf (no open URL)', () => {
+            renderMenu({ leaf: tableLeaf });
+            expect(screen.queryByTestId('open-item')).not.toBeInTheDocument();
+            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
+        });
+        it('shows only "Remove item" for a lead leaf (no open URL)', () => {
+            renderMenu({ leaf: leadLeaf });
+            expect(screen.queryByTestId('open-item')).not.toBeInTheDocument();
+            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
+        });
+        it('labels the remove button "Remove item" for a leaf', () => {
+            renderMenu({ leaf: hitLeaf });
+            expect(screen.getByTestId('remove-item')).toHaveTextContent('page.cases.sidebar.item.remove');
+        });
+        it('shows a divider for all leaf types (between leaf actions and remove)', () => {
+            const { container: withOpen } = renderMenu({ leaf: hitLeaf });
+            expect(withOpen.querySelector('hr')).not.toBeNull();
+            const { container: withoutOpen } = renderMenu({ leaf: tableLeaf });
+            expect(withoutOpen.querySelector('hr')).not.toBeNull();
+            const { container: withFolder } = renderMenu({ tree: { leaves: [hitLeaf] } });
+            expect(withFolder.querySelector('hr')).toBeNull();
+        });
+    });
+    describe('menu items for folders', () => {
+        const folderTree = { leaves: [hitLeaf, referenceLeaf] };
+        it('shows only "Remove folder" for a folder (no open URL)', () => {
+            renderMenu({ tree: folderTree });
+            expect(screen.queryByTestId('open-item')).not.toBeInTheDocument();
+            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
+        });
+        it('labels the remove button "Remove folder" for a tree', () => {
+            renderMenu({ tree: folderTree });
+            expect(screen.getByTestId('remove-item')).toHaveTextContent('page.cases.sidebar.folder.remove');
+        });
+    });
+    describe('"Open item" action', () => {
+        it('calls window.open with the hit URL', () => {
+            renderMenu({ leaf: hitLeaf });
+            act(() => {
+                fireEvent.click(screen.getByTestId('open-item'));
+            });
+            expect(window.open).toHaveBeenCalledWith('/hits/hit-123', '_blank', 'noopener noreferrer');
+        });
+        it('calls window.open with the reference URL directly', () => {
+            renderMenu({ leaf: referenceLeaf });
+            act(() => {
+                fireEvent.click(screen.getByTestId('open-item'));
+            });
+            expect(window.open).toHaveBeenCalledWith('https://example.com', '_blank', 'noopener noreferrer');
+        });
+        it('calls window.open with the observable URL', () => {
+            renderMenu({ leaf: observableLeaf });
+            act(() => {
+                fireEvent.click(screen.getByTestId('open-item'));
+            });
+            expect(window.open).toHaveBeenCalledWith('/observables/obs-456', '_blank', 'noopener noreferrer');
+        });
+        it('calls window.open with the case URL', () => {
+            renderMenu({ leaf: caseLeaf });
+            act(() => {
+                fireEvent.click(screen.getByTestId('open-item'));
+            });
+            expect(window.open).toHaveBeenCalledWith('/cases/nested-case-id', '_blank', 'noopener noreferrer');
+        });
+    });
+    describe('"Remove item" action for a leaf', () => {
+        it('calls dispatchApi with the delete call for the leaf', async () => {
+            renderMenu({ leaf: hitLeaf });
+            act(() => {
+                fireEvent.click(screen.getByTestId('remove-item'));
+            });
+            await waitFor(() => {
+                expect(mockDel).toHaveBeenCalledWith('case-1', ['hit-123']);
+            });
+        });
+        it('calls onUpdate with the updated case after the delete resolves', async () => {
+            const onUpdate = vi.fn();
+            renderMenu({ leaf: hitLeaf, onUpdate: onUpdate });
+            act(() => {
+                fireEvent.click(screen.getByTestId('remove-item'));
+            });
+            await waitFor(() => {
+                expect(onUpdate).toHaveBeenCalledWith(mockCase);
+            });
+        });
+        it('does not call the API when case_id is missing', () => {
+            renderMenu({ _case: { title: 'No ID' }, leaf: hitLeaf });
+            act(() => {
+                fireEvent.click(screen.getByTestId('remove-item'));
+            });
+            expect(mockDel).not.toHaveBeenCalled();
+        });
+        it('skips items with no value', async () => {
+            const noValueLeaf = { type: 'hit', path: 'folder/no-value' };
+            renderMenu({ leaf: noValueLeaf });
+            act(() => {
+                fireEvent.click(screen.getByTestId('remove-item'));
+            });
+            await waitFor(() => {
+                expect(mockDel).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe('"Rename item" action', () => {
+        it('shows "Rename item" entry for a hit leaf', () => {
+            renderMenu({ leaf: hitLeaf });
+            expect(screen.getByTestId('rename-item')).toBeInTheDocument();
+        });
+        it('shows "Rename item" for a table leaf', () => {
+            renderMenu({ leaf: tableLeaf });
+            expect(screen.getByTestId('rename-item')).toBeInTheDocument();
+        });
+        it('does not show "Rename item" for a folder', () => {
+            renderMenu({ tree: { leaves: [hitLeaf] } });
+            expect(screen.queryByTestId('rename-item')).not.toBeInTheDocument();
+        });
+        it('calls showModal when "Rename item" is clicked', () => {
+            renderMenu({ leaf: hitLeaf });
+            act(() => {
+                fireEvent.click(screen.getByTestId('rename-item'));
+            });
+            expect(mockShowModal).toHaveBeenCalledTimes(1);
+        });
+        it('passes the current case and leaf to the rename modal', () => {
+            const onUpdate = vi.fn();
+            renderMenu({ leaf: hitLeaf, onUpdate: onUpdate });
+            act(() => {
+                fireEvent.click(screen.getByTestId('rename-item'));
+            });
+            const [modalElement] = mockShowModal.mock.calls[0];
+            expect(modalElement.props._case).toBe(mockCase);
+            expect(modalElement.props.leaf).toBe(hitLeaf);
+        });
+        it('works fine when onUpdate is not provided', () => {
+            renderMenu({ leaf: hitLeaf });
+            act(() => {
+                fireEvent.click(screen.getByTestId('rename-item'));
+            });
+            expect(mockShowModal).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('"Remove folder" action', () => {
+        it('calls dispatchApi with all leaf values in a single batch call', async () => {
+            const folderTree = { leaves: [hitLeaf, referenceLeaf] };
+            renderMenu({ tree: folderTree });
+            act(() => {
+                fireEvent.click(screen.getByTestId('remove-item'));
+            });
+            await waitFor(() => {
+                expect(mockDel).toHaveBeenCalledWith('case-1', ['hit-123', 'https://example.com']);
+                expect(mockDel).toHaveBeenCalledTimes(1);
+            });
+        });
+        it('calls dispatchApi with leaves from nested subfolders in a single batch call', async () => {
+            const nestedTree = {
+                leaves: [hitLeaf],
+                subfolder: { leaves: [referenceLeaf] }
+            };
+            renderMenu({ tree: nestedTree });
+            act(() => {
+                fireEvent.click(screen.getByTestId('remove-item'));
+            });
+            await waitFor(() => {
+                expect(mockDel).toHaveBeenCalledWith('case-1', expect.arrayContaining(['hit-123', 'https://example.com']));
+                expect(mockDel).toHaveBeenCalledTimes(1);
+            });
+        });
+        it('calls onUpdate with the updated case after deletion', async () => {
+            const onUpdate = vi.fn();
+            const folderTree = { leaves: [hitLeaf, referenceLeaf] };
+            renderMenu({ tree: folderTree, onUpdate: onUpdate });
+            act(() => {
+                fireEvent.click(screen.getByTestId('remove-item'));
+            });
+            await waitFor(() => {
+                expect(onUpdate).toHaveBeenCalledWith(mockCase);
+            });
+        });
+        it('does not call the API or onUpdate for an empty folder', () => {
+            const onUpdate = vi.fn();
+            renderMenu({ tree: { leaves: [] }, onUpdate: onUpdate });
+            act(() => {
+                fireEvent.click(screen.getByTestId('remove-item'));
+            });
+            expect(mockDel).not.toHaveBeenCalled();
+            expect(onUpdate).not.toHaveBeenCalled();
+        });
+    });
+});

package/components/routes/cases/detail/sidebar/types.d.ts

@@ -0,0 +1,3 @@
+import type { Item } from 'models/entities/generated/Item';
+
+export type Tree = { leaves?: Item[]; [folder: string]: Tree | Item[] };

package/components/routes/cases/detail/sidebar/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Item } from '@cccsaurora/howler-ui/models/entities/generated/Item';
+import type { Tree } from './types';
+export declare const buildTree: (items?: Item[]) => Tree;

package/components/routes/cases/detail/sidebar/utils.js

@@ -0,0 +1,25 @@
+import { get, set } from 'lodash-es';
+export const buildTree = (items = []) => {
+    // Root tree node stores direct children in `leaves` and nested folders as object keys.
+    const tree = { leaves: [] };
+    items.forEach(item => {
+        // Ignore items that cannot be placed in the folder structure.
+        if (!item?.path) {
+            return;
+        }
+        // Split path into folder segments + item name, then remove the item name.
+        const parts = item.path.split('/');
+        parts.pop();
+        if (parts.length > 0) {
+            // Use dot notation so lodash `get/set` can address nested folder objects.
+            const key = parts.join('.');
+            const size = get(tree, key)?.leaves?.length || 0;
+            // Append this item to the folder's `leaves` array.
+            set(tree, `${key}.leaves.${size}`, item);
+            return;
+        }
+        // Items without parent folders are top-level leaves.
+        tree.leaves.push(item);
+    });
+    return tree;
+};

package/components/routes/cases/hooks/useCase.d.ts

@@ -0,0 +1,13 @@
+import type { Case } from '@cccsaurora/howler-ui/models/entities/generated/Case';
+interface CaseArguments {
+    case?: Case;
+    caseId?: string;
+}
+interface CaseResult {
+    case: Case;
+    update: (update: Partial<Case>, publish?: boolean) => Promise<void>;
+    loading: boolean;
+    missing: boolean;
+}
+declare const useCase: (args: CaseArguments) => CaseResult;
+export default useCase;

package/components/routes/cases/hooks/useCase.js

@@ -0,0 +1,51 @@
+import api from '@cccsaurora/howler-ui/api';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import { useCallback, useEffect, useState } from 'react';
+const useCase = ({ caseId, case: providedCase }) => {
+    const { dispatchApi } = useMyApi();
+    const [loading, setLoading] = useState(false);
+    const [missing, setMissing] = useState(false);
+    const [_case, setCase] = useState(providedCase);
+    useEffect(() => {
+        if (providedCase) {
+            setCase(providedCase);
+        }
+    }, [providedCase]);
+    useEffect(() => {
+        if (caseId) {
+            setLoading(true);
+            dispatchApi(api.v2.case.get(caseId), { throwError: false })
+                .then(setCase)
+                .finally(() => setLoading(false));
+        }
+    }, [caseId, dispatchApi]);
+    const update = useCallback(async (_updatedCase, publish = true) => {
+        if (!_case?.case_id) {
+            return;
+        }
+        try {
+            if (publish) {
+                setCase(await dispatchApi(api.v2.case.put(_case.case_id, _updatedCase)));
+            }
+            else {
+                setCase(prevCase => {
+                    if (!prevCase) {
+                        return prevCase;
+                    }
+                    return {
+                        ...prevCase,
+                        ..._updatedCase
+                    };
+                });
+            }
+        }
+        catch (e) {
+            setMissing(true);
+        }
+        finally {
+            return;
+        }
+    }, [_case?.case_id, dispatchApi]);
+    return { case: _case, update, loading, missing };
+};
+export default useCase;

package/components/routes/cases/modals/AddToCaseModal.d.ts

@@ -0,0 +1,7 @@
+import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import type { Observable } from '@cccsaurora/howler-ui/models/entities/generated/Observable';
+import { type FC } from 'react';
+declare const AddToCaseModal: FC<{
+    records: (Hit | Observable)[];
+}>;
+export default AddToCaseModal;

package/components/routes/cases/modals/AddToCaseModal.js

@@ -0,0 +1,62 @@
+import { createElement as _createElement } from "react";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Autocomplete, Button, Stack, TextField, Typography } from '@mui/material';
+import api from '@cccsaurora/howler-ui/api';
+import { ModalContext } from '@cccsaurora/howler-ui/components/app/providers/ModalProvider';
+import CaseCard from '@cccsaurora/howler-ui/components/elements/case/CaseCard';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import { useContext, useEffect, useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+const AddToCaseModal = ({ records }) => {
+    const { t } = useTranslation();
+    const { dispatchApi } = useMyApi();
+    const { close } = useContext(ModalContext);
+    const [cases, setCases] = useState([]);
+    const [selectedCase, setSelectedCase] = useState(null);
+    const [path, setPath] = useState('');
+    const [title, setTitle] = useState('');
+    useEffect(() => {
+        dispatchApi(api.search.case.post({ query: 'case_id:*', rows: 100 }), { throwError: false }).then(result => {
+            if (result) {
+                setCases(result.items);
+            }
+        });
+    }, [dispatchApi]);
+    const folderOptions = useMemo(() => {
+        if (!selectedCase?.items) {
+            return [];
+        }
+        const paths = new Set();
+        for (const item of selectedCase.items) {
+            if (!item.path) {
+                continue;
+            }
+            const parts = item.path.split('/');
+            parts.pop();
+            for (let i = 1; i <= parts.length; i++) {
+                paths.add(parts.slice(0, i).join('/'));
+            }
+        }
+        return Array.from(paths).sort();
+    }, [selectedCase]);
+    const fullPath = path ? `${path}/${title}` : title;
+    const isValid = !!selectedCase && !!title;
+    const onSubmit = async () => {
+        if (!selectedCase || records?.length < 1) {
+            return;
+        }
+        await dispatchApi(api.v2.case.items.post(selectedCase.case_id, {
+            path: fullPath,
+            value: records[0].howler.id,
+            type: records[0].__index
+        }));
+        close();
+    };
+    // TODO: No support currently for multiple records
+    return (_jsxs(Stack, { spacing: 2, p: 2, sx: { minWidth: 'min(800px, 60vw)', height: '100%' }, children: [_jsx(Typography, { variant: "h4", children: t('modal.cases.add_to_case') }), _jsx(Autocomplete, { options: cases, getOptionLabel: option => option.title ?? option.case_id ?? '', isOptionEqualToValue: (option, value) => option.case_id === value.case_id, value: selectedCase, disablePortal: true, onChange: (_ev, newVal) => {
+                    setSelectedCase(newVal);
+                    setPath('');
+                }, renderOption: (props, option) => (_createElement("li", { ...props, key: option.case_id, style: { ...props.style, display: 'flex', justifyContent: 'stretch', alignItems: 'stretch' } },
+                    _jsx(CaseCard, { case: option, slotProps: { card: { sx: { width: '100%' } } } }))), renderInput: params => (_jsx(TextField, { ...params, size: "small", placeholder: t('modal.cases.add_to_case.select_case'), fullWidth: true })) }), selectedCase && (_jsxs(_Fragment, { children: [_jsx(Autocomplete, { freeSolo: true, disablePortal: true, options: folderOptions, value: path, onInputChange: (_ev, newVal) => setPath(newVal), renderInput: params => (_jsx(TextField, { ...params, size: "small", placeholder: t('modal.cases.add_to_case.select_path'), fullWidth: true })) }), _jsx(TextField, { size: "small", placeholder: t('modal.cases.add_to_case.title'), value: title, onChange: ev => setTitle(ev.target.value), fullWidth: true }), title && (_jsx(Typography, { variant: "caption", color: "textSecondary", children: t('modal.cases.add_to_case.full_path', { path: fullPath }) }))] })), _jsx("div", { style: { flex: 1 } }), _jsxs(Stack, { direction: "row", spacing: 1, alignSelf: "end", children: [_jsx(Button, { variant: "outlined", color: "error", onClick: close, children: t('cancel') }), _jsx(Button, { variant: "outlined", color: "success", disabled: !isValid, onClick: onSubmit, children: t('confirm') })] })] }));
+};
+export default AddToCaseModal;

package/components/routes/cases/modals/RenameItemModal.d.ts

@@ -0,0 +1,9 @@
+import type { Case } from '@cccsaurora/howler-ui/models/entities/generated/Case';
+import type { Item } from '@cccsaurora/howler-ui/models/entities/generated/Item';
+import { type FC } from 'react';
+declare const RenameItemModal: FC<{
+    _case: Case;
+    leaf: Item;
+    onRenamed?: (updatedCase: Case) => void;
+}>;
+export default RenameItemModal;

package/components/routes/cases/modals/RenameItemModal.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Stack, TextField, Typography } from '@mui/material';
+import api from '@cccsaurora/howler-ui/api';
+import { ModalContext } from '@cccsaurora/howler-ui/components/app/providers/ModalProvider';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import { useContext, useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+const RenameItemModal = ({ _case, leaf, onRenamed }) => {
+    const { t } = useTranslation();
+    const { dispatchApi } = useMyApi();
+    const { close } = useContext(ModalContext);
+    const currentPath = leaf.path ?? '';
+    const lastSlash = currentPath.lastIndexOf('/');
+    const folderPrefix = lastSlash >= 0 ? currentPath.slice(0, lastSlash) : '';
+    const currentName = lastSlash >= 0 ? currentPath.slice(lastSlash + 1) : currentPath;
+    const [name, setName] = useState(currentName);
+    const newPath = folderPrefix ? `${folderPrefix}/${name}` : name;
+    const existingPaths = useMemo(() => new Set((_case.items ?? []).filter(item => item.value !== leaf.value).map(item => item.path)), [_case.items, leaf.value]);
+    const nameError = useMemo(() => {
+        if (!name.trim()) {
+            return t('modal.cases.rename_item.error.empty');
+        }
+        if (name.includes('/')) {
+            return t('modal.cases.rename_item.error.slash');
+        }
+        if (existingPaths.has(newPath)) {
+            return t('modal.cases.rename_item.error.taken');
+        }
+        return null;
+    }, [name, newPath, existingPaths, t]);
+    const isValid = !nameError;
+    const onSubmit = async () => {
+        if (!isValid || !_case.case_id || !leaf.value) {
+            return;
+        }
+        const updatedCase = await dispatchApi(api.v2.case.items.patch(_case.case_id, leaf.value, newPath));
+        if (updatedCase) {
+            onRenamed?.(updatedCase);
+            close();
+        }
+    };
+    return (_jsxs(Stack, { spacing: 2, p: 2, sx: { minWidth: 'min(600px, 60vw)' }, children: [_jsx(Typography, { variant: "h4", children: t('modal.cases.rename_item') }), folderPrefix && (_jsx(Typography, { variant: "body2", color: "textSecondary", children: t('modal.cases.rename_item.folder_path', { path: folderPrefix }) })), _jsx(TextField, { size: "small", label: t('modal.cases.rename_item.new_name'), value: name, onChange: ev => setName(ev.target.value), error: !!nameError, helperText: nameError ?? ' ', fullWidth: true, autoFocus: true, onKeyDown: ev => {
+                    if (ev.key === 'Enter' && isValid) {
+                        onSubmit();
+                    }
+                } }), _jsxs(Stack, { direction: "row", justifyContent: "flex-end", spacing: 1, children: [_jsx(Button, { onClick: close, color: "error", variant: "outlined", children: t('button.cancel') }), _jsx(Button, { onClick: onSubmit, color: "success", variant: "outlined", disabled: !isValid, children: t('button.confirm') })] })] }));
+};
+export default RenameItemModal;

package/components/routes/cases/modals/ResolveModal.d.ts

@@ -0,0 +1,7 @@
+import type { Case } from '@cccsaurora/howler-ui/models/entities/generated/Case';
+import { type FC } from 'react';
+declare const ResolveModal: FC<{
+    case: Case;
+    onConfirm: () => void;
+}>;
+export default ResolveModal;

package/components/routes/cases/modals/ResolveModal.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { OpenInNew } from '@mui/icons-material';
+import { Autocomplete, Box, Button, Card, Chip, Divider, IconButton, LinearProgress, Skeleton, Stack, TextField, Typography } from '@mui/material';
+import api from '@cccsaurora/howler-ui/api';
+import { ApiConfigContext } from '@cccsaurora/howler-ui/components/app/providers/ApiConfigProvider';
+import { ModalContext } from '@cccsaurora/howler-ui/components/app/providers/ModalProvider';
+import AnalyticLink from '@cccsaurora/howler-ui/components/elements/hit/elements/AnalyticLink';
+import EscalationChip from '@cccsaurora/howler-ui/components/elements/hit/elements/EscalationChip';
+import { HitLayout } from '@cccsaurora/howler-ui/components/elements/hit/HitLayout';
+import useHitActions from '@cccsaurora/howler-ui/components/hooks/useHitActions';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import { uniq } from 'lodash-es';
+import { useContext, useEffect, useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Link } from 'react-router-dom';
+import useCase from '../hooks/useCase';
+const ResolveModal = ({ case: _case, onConfirm }) => {
+    const { t } = useTranslation();
+    const { dispatchApi } = useMyApi();
+    const { close } = useContext(ModalContext);
+    const { config } = useContext(ApiConfigContext);
+    const { update: updateCase } = useCase({ case: _case });
+    const [loading, setLoading] = useState(true);
+    const [rationale, setRationale] = useState('');
+    const [assessment, setAssessment] = useState(null);
+    const [hits, setHits] = useState([]);
+    const hitIds = useMemo(() => uniq((_case?.items ?? [])
+        .filter(item => item.type === 'hit')
+        .map(item => item.value)
+        .filter(Boolean)), [_case?.items]);
+    const { assess } = useHitActions(hits);
+    useEffect(() => {
+        (async () => {
+            try {
+                const result = await dispatchApi(api.search.hit.post({
+                    query: `howler.id:(${hitIds.join(' OR ')}) AND -howler.status:resolved`,
+                    metadata: ['analytic']
+                }));
+                setHits(result.items);
+            }
+            finally {
+                setLoading(false);
+            }
+        })();
+    }, [dispatchApi, hitIds]);
+    const handleConfirm = async () => {
+        setLoading(true);
+        try {
+            await assess(assessment, true, rationale);
+            await updateCase({ status: 'resolved' });
+            onConfirm();
+            close();
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    return (_jsxs(Stack, { spacing: 2, p: 2, alignItems: "start", sx: { minWidth: 'min(1000px, 60vw)', maxHeight: '100%', height: '100%' }, children: [_jsx(Typography, { variant: "h4", children: t('modal.cases.resolve') }), _jsx(Typography, { children: t('modal.cases.resolve.description') }), _jsxs(Stack, { spacing: 1, overflow: "auto", width: "100%", flex: 1, children: [_jsxs(Stack, { direction: "row", spacing: 1, children: [_jsx(Box, { flex: 1, children: _jsx(TextField, { size: "small", fullWidth: true, placeholder: t('modal.rationale.label'), value: rationale, onChange: ev => setRationale(ev.target.value) }) }), _jsx(Box, { flex: 1, children: _jsx(Autocomplete, { size: "small", value: assessment, onChange: (_ev, _assessment) => setAssessment(_assessment), options: config.lookups['howler.assessment'], disablePortal: true, renderInput: params => (_jsx(TextField, { ...params, placeholder: t('hit.details.actions.assessment'), fullWidth: true })) }) })] }), _jsxs(Stack, { position: "relative", children: [_jsx(Divider, {}), _jsx(LinearProgress, { sx: { opacity: +loading } })] }), loading
+                        ? hitIds.map(id => _jsx(Skeleton, { variant: "rounded", height: "40px", width: "100%" }, id))
+                        : hits.map(hit => (_jsx(Card, { sx: { p: 1, flexShrink: 0 }, children: _jsxs(Stack, { direction: "row", alignItems: "center", spacing: 1, width: "100%", children: [_jsx(AnalyticLink, { hit: hit, compressed: true, alignSelf: "center" }), _jsx(EscalationChip, { hit: hit, layout: HitLayout.DENSE }), _jsx(Chip, { sx: { width: 'fit-content', display: 'inline-flex' }, label: hit.howler.status, size: "small", color: "primary" }), _jsx("div", { style: { flex: 1 } }), _jsx(IconButton, { size: "small", component: Link, to: `/hits/${hit.howler.id}`, children: _jsx(OpenInNew, { fontSize: "small" }) })] }) }, hit.howler.id)))] }), _jsxs(Stack, { direction: "row", spacing: 1, alignSelf: "end", children: [_jsx(Button, { variant: "outlined", color: "error", onClick: close, children: t('cancel') }), _jsx(Button, { variant: "outlined", color: "success", disabled: loading || !assessment || !rationale, onClick: handleConfirm, children: t('confirm') })] })] }));
+};
+export default ResolveModal;