vintasend 0.4.0 → 0.4.7

package/dist/examples/vintasend-medplum-example/src/components/tasks/TaskProperties.tsx

@@ -0,0 +1,170 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Divider, Flex, Paper, Stack, Text } from '@mantine/core';
+import type { PaperProps } from '@mantine/core';
+import { getReferenceString } from '@medplum/core';
+import type { Media, Organization, Patient, Practitioner, Reference, ResourceType, Task } from '@medplum/fhirtypes';
+import { CodeInput, DateTimeInput, ReferenceInput, ResourceInput, useMedplum } from '@medplum/react';
+import React, { useEffect, useState } from 'react';
+import { getTaskAttachments } from '../../../lib/file-upload';
+import { TaskAttachmentList } from './TaskAttachmentList';
+
+interface TaskPropertiesProps extends PaperProps {
+  task: Task;
+  onTaskChange: (task: Task) => void;
+}
+
+export function TaskProperties(props: TaskPropertiesProps): React.JSX.Element {
+  const { task: initialTask, onTaskChange, ...paperProps } = props;
+  const medplum = useMedplum();
+  const [task, setTask] = useState<Task | undefined>(initialTask);
+  const [dueDate, setDueDate] = useState<string | undefined>(task?.restriction?.period?.end);
+  const [attachments, setAttachments] = useState<Media[]>([]);
+
+  useEffect(() => {
+    setTask(initialTask);
+    
+    // Load attachments when task changes
+    const loadAttachments = async (): Promise<void> => {
+      if (initialTask) {
+        const taskAttachments = await getTaskAttachments(medplum, initialTask);
+        setAttachments(taskAttachments);
+      }
+    };
+    
+    void loadAttachments();
+  }, [initialTask, medplum]);
+
+  const handleDueDateChange = async (value: string | undefined): Promise<void> => {
+    setDueDate(value);
+    await handleTaskUpdate({ ...task, restriction: { ...task?.restriction, period: { end: value } } } as Task);
+  };
+
+  const handlePatientChange = async (value: Reference<Patient> | undefined): Promise<void> => {
+    await handleTaskUpdate({ ...task, for: value } as Task);
+  };
+
+  const handlePriorityChange = async (value: string): Promise<void> => {
+    await handleTaskUpdate({ ...task, priority: value as Task['priority'] } as Task);
+  };
+
+  const handleOwnerChange = async (value: Reference<Practitioner | Organization> | undefined): Promise<void> => {
+    await handleTaskUpdate({ ...task, owner: value } as Task);
+  };
+
+  const handleStatusChange = async (value: string | undefined): Promise<void> => {
+    if (value) {
+      await handleTaskUpdate({ ...task, status: value as Task['status'] } as Task);
+    }
+  };
+
+  const handleTaskUpdate = async (value: Task): Promise<void> => {
+    onTaskChange(value);
+  };
+
+  return (
+    <Paper {...paperProps}>
+      <Flex direction="column" gap="lg">
+        <Stack gap="xs">
+          <CodeInput
+            key={`${task?.status}-${task?.id}`}
+            name="status"
+            label="Status"
+            binding="http://hl7.org/fhir/ValueSet/task-status"
+            maxValues={1}
+            defaultValue={task?.status}
+            onChange={handleStatusChange}
+          />
+
+          <DateTimeInput
+            name="Due Date"
+            placeholder="End"
+            label="Due Date"
+            defaultValue={dueDate}
+            onChange={handleDueDateChange}
+          />
+
+          <Stack gap={0}>
+            <Text size="sm" fw={500}>
+              Assignee
+            </Text>
+            <ReferenceInput
+              name="owner"
+              targetTypes={['Practitioner', 'Organization']}
+              defaultValue={task?.owner ? { reference: task.owner.reference } : undefined}
+              onChange={async (value: Reference<Practitioner | Organization> | undefined) => {
+                await handleOwnerChange(value ? { reference: value.reference } : undefined);
+              }}
+            />
+          </Stack>
+
+          <CodeInput
+            name="priority"
+            label="Priority"
+            binding="http://hl7.org/fhir/ValueSet/request-priority"
+            maxValues={1}
+            defaultValue={task?.priority?.toString()}
+            onChange={(value: string | undefined) => handlePriorityChange(value ?? '')}
+          />
+
+          {task?.basedOn && task.basedOn.length > 0 ? (
+            <ResourceInput
+              label="Based On"
+              resourceType={task.basedOn[0].reference?.split('/').pop() as ResourceType}
+              name="basedOn-0"
+              defaultValue={task.basedOn[0]}
+              disabled
+            />
+          ) : (
+            <Stack gap={0}>
+              <Text size="sm" fw={500}>
+                Based On
+              </Text>
+              <ReferenceInput
+                name="basedOn"
+                placeholder="Select any resource..."
+                onChange={async (value: Reference | undefined) => {
+                  if (value?.reference) {
+                    const newBasedOn = [...(task?.basedOn || []), value];
+                    await handleTaskUpdate({ ...task, basedOn: newBasedOn } as Task);
+                  }
+                }}
+              />
+            </Stack>
+          )}
+        </Stack>
+
+        <Divider />
+
+        <Stack gap="xs" pt="md">
+          <ResourceInput
+            label="Patient"
+            resourceType="Patient"
+            name="patient"
+            placeholder="Search for patient"
+            defaultValue={task?.for as Reference<Patient>}
+            onChange={async (patient: Patient | undefined) => {
+              await handlePatientChange(patient ? { reference: getReferenceString(patient) } : undefined);
+            }}
+          />
+
+          {task?.encounter && (
+            <ResourceInput label="Encounter" resourceType="Encounter" name="encounter" defaultValue={task.encounter} />
+          )}
+        </Stack>
+
+        {attachments.length > 0 && (
+          <>
+            <Divider />
+            <Stack gap="xs" pt="md">
+              <Text size="sm" fw={500}>
+                Attachments
+              </Text>
+              <TaskAttachmentList attachments={attachments} readOnly />
+            </Stack>
+          </>
+        )}
+      </Flex>
+    </Paper>
+  );
+}

package/dist/examples/vintasend-medplum-example/src/components/tasks/TaskSelectEmpty.test.tsx

@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { MantineProvider } from '@mantine/core';
+import { render, screen } from '@testing-library/react';
+import { describe, expect, test } from 'vitest';
+import { TaskSelectEmpty } from './TaskSelectEmpty';
+
+describe('TaskSelectEmpty', () => {
+  const setup = (props: { notFound?: boolean } = {}): ReturnType<typeof render> => {
+    return render(
+      <MantineProvider>
+        <TaskSelectEmpty {...props} />
+      </MantineProvider>
+    );
+  };
+
+  test('renders "No task selected" message by default', () => {
+    setup();
+    expect(screen.getByText('No task selected')).toBeInTheDocument();
+    expect(
+      screen.getByText('Select a task from the list to view details, add notes, and manage properties')
+    ).toBeInTheDocument();
+  });
+
+  test('renders "Task not found" message when notFound is true', () => {
+    setup({ notFound: true });
+    expect(screen.getByText('Task not found')).toBeInTheDocument();
+    expect(
+      screen.queryByText('Select a task from the list to view details, add notes, and manage properties')
+    ).not.toBeInTheDocument();
+  });
+});

package/dist/examples/vintasend-medplum-example/src/components/tasks/TaskSelectEmpty.tsx

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Center, Flex, Stack, Text, ThemeIcon } from '@mantine/core';
+import { IconClipboardList } from '@tabler/icons-react';
+import type { JSX } from 'react';
+
+interface TaskSelectEmptyProps {
+  notFound?: boolean;
+}
+
+export function TaskSelectEmpty(props: TaskSelectEmptyProps): JSX.Element {
+  const { notFound = false } = props;
+  return (
+    <Flex direction="row" h="100%" w="100%">
+      <Center h="100%" w="100%">
+        <Stack align="center" gap="md">
+          <ThemeIcon size={64} variant="light" color="gray">
+            <IconClipboardList size={32} />
+          </ThemeIcon>
+          <Stack align="center" gap="xs">
+            <Text size="lg" fw={500} c="dimmed">
+              {notFound ? 'Task not found' : 'No task selected'}
+            </Text>
+            {!notFound && (
+              <Text size="sm" c="dimmed" ta="center">
+                Select a task from the list to view details, add notes, and manage properties
+              </Text>
+            )}
+          </Stack>
+        </Stack>
+      </Center>
+    </Flex>
+  );
+}

package/dist/examples/vintasend-medplum-example/src/components/tasks/encounter/SimpleTask.test.tsx

@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { render, screen } from '@testing-library/react';
+import { describe, expect, test } from 'vitest';
+import { SimpleTask } from './SimpleTask';
+import type { Task } from '@medplum/fhirtypes';
+import { MantineProvider } from '@mantine/core';
+
+describe('SimpleTask', () => {
+  const mockTask: Task = {
+    resourceType: 'Task',
+    id: 'task-123',
+    status: 'in-progress',
+    intent: 'order',
+    code: { text: 'Test Task Code' },
+    description: 'Test Task Description',
+  };
+
+  const setup = (task: Task): void => {
+    render(
+      <MantineProvider>
+        <SimpleTask task={task} />
+      </MantineProvider>
+    );
+  };
+
+  test('renders task details correctly', () => {
+    setup(mockTask);
+    expect(screen.getByText('Test Task Code')).toBeInTheDocument();
+    expect(screen.getByText('Test Task Description')).toBeInTheDocument();
+  });
+
+  test('renders View Service Request button when focus is ServiceRequest', () => {
+    const taskWithFocus: Task = {
+      ...mockTask,
+      focus: { reference: 'ServiceRequest/123' },
+    };
+    setup(taskWithFocus);
+    expect(screen.getByText('View Service Request')).toBeInTheDocument();
+    expect(screen.getByText('View Service Request').closest('a')).toHaveAttribute('href', '/ServiceRequest/123');
+  });
+
+  test('does not render View Service Request button when focus is not ServiceRequest', () => {
+    setup(mockTask);
+    expect(screen.queryByText('View Service Request')).not.toBeInTheDocument();
+  });
+});

package/dist/examples/vintasend-medplum-example/src/components/tasks/encounter/SimpleTask.tsx

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Box, Button, Stack, Text } from '@mantine/core';
+import type { Task } from '@medplum/fhirtypes';
+import type { JSX } from 'react';
+
+interface SimpleTaskProps {
+  task: Task;
+}
+
+export const SimpleTask = ({ task }: SimpleTaskProps): JSX.Element => {
+  return (
+    <Box p="md">
+      <Stack gap="xs">
+        {task.code?.text && (
+          <Text fw={500} size="lg">
+            {task.code.text}
+          </Text>
+        )}
+        <Text>{task.description}</Text>
+        {task.focus?.reference?.startsWith('ServiceRequest/') && (
+          <Button component="a" href={`/${task.focus.reference}`} target="_blank">
+            View Service Request
+          </Button>
+        )}
+      </Stack>
+    </Box>
+  );
+};

package/dist/examples/vintasend-medplum-example/src/components/tasks/encounter/TaskPanel.test.tsx

@@ -0,0 +1,285 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { MantineProvider } from '@mantine/core';
+import { Notifications } from '@mantine/notifications';
+import { render, screen, waitFor, act } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MedplumProvider } from '@medplum/react';
+import { MockClient } from '@medplum/mock';
+import { MemoryRouter, Routes, Route } from 'react-router';
+import * as reactRouter from 'react-router';
+import { describe, expect, test, vi, beforeEach } from 'vitest';
+import { TaskPanel } from './TaskPanel';
+import type { Questionnaire, QuestionnaireResponse, ServiceRequest, Task } from '@medplum/fhirtypes';
+
+describe('TaskPanel', () => {
+  let medplum: MockClient;
+  let navigateSpy: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+    vi.clearAllMocks();
+    navigateSpy = vi.fn().mockReturnValue(Promise.resolve());
+    vi.spyOn(reactRouter, 'useNavigate').mockReturnValue(navigateSpy as any);
+  });
+
+  const setup = async (task: Task, onUpdateTask: (task: Task) => void, enabled = true): Promise<void> => {
+    await act(async () => {
+      render(
+        <MemoryRouter initialEntries={['/Patient/123/Encounter/456']}>
+          <MedplumProvider medplum={medplum}>
+            <MantineProvider>
+              <Notifications />
+              <Routes>
+                <Route
+                  path="/Patient/:patientId/Encounter/:encounterId"
+                  element={<TaskPanel task={task} onUpdateTask={onUpdateTask} enabled={enabled} />}
+                />
+                <Route
+                  path="/Patient/:patientId/Encounter/:encounterId/Task/:taskId"
+                  element={<div>Task Detail Page</div>}
+                />
+              </Routes>
+            </MantineProvider>
+          </MedplumProvider>
+        </MemoryRouter>
+      );
+    });
+  };
+
+  const mockTask: Task = {
+    resourceType: 'Task',
+    id: 'task-123',
+    status: 'in-progress',
+    intent: 'order',
+    code: { text: 'Test Task Code' },
+    description: 'Test Task Description',
+  };
+
+  test('renders TaskQuestionnaireForm when focus is Questionnaire', async () => {
+    const questionnaireId = `q-${Date.now()}`;
+    const questionnaire: Questionnaire = {
+      resourceType: 'Questionnaire',
+      id: questionnaireId,
+      status: 'active',
+      item: [{ linkId: 'q1', type: 'string', text: 'Test Question' }],
+    };
+    await medplum.createResource(questionnaire);
+
+    const task: Task = {
+      ...mockTask,
+      focus: { reference: `Questionnaire/${questionnaireId}` },
+      input: [{ type: { text: 'Questionnaire' }, valueReference: { reference: `Questionnaire/${questionnaireId}` } }],
+    };
+    const onUpdateTask = vi.fn();
+    await setup(task, onUpdateTask);
+
+    // Wait for the task status panel to render
+    await waitFor(() => {
+      expect(screen.getByText('Task Status:')).toBeInTheDocument();
+    });
+  });
+
+  test('renders TaskServiceRequest when focus is ServiceRequest', async () => {
+    const task: Task = {
+      ...mockTask,
+      focus: { reference: 'ServiceRequest/1234' },
+      for: { reference: 'Patient/123' },
+      input: [{ type: { text: 'ServiceRequest' }, valueReference: { reference: 'ServiceRequest/123' } }],
+    };
+    const onUpdateTask = vi.fn();
+    const serviceRequest: ServiceRequest = {
+      resourceType: 'ServiceRequest',
+      id: '1234',
+      status: 'active',
+      code: { text: 'Test Service Request' },
+      intent: 'order',
+      subject: { reference: 'Patient/123' },
+      requisition: { value: 'REQ-123' },
+    };
+    await medplum.createResource(serviceRequest);
+    medplum.readReference = vi.fn().mockResolvedValue(serviceRequest);
+    await setup(task, onUpdateTask);
+
+    await waitFor(() => {
+      expect(screen.getByText('Test Task Code')).toBeInTheDocument();
+      expect(screen.getByText(/✅ Order Sent/)).toBeInTheDocument();
+    });
+  });
+
+  test('renders SimpleTask when focus is neither Questionnaire nor ServiceRequest', async () => {
+    const onUpdateTask = vi.fn();
+    await setup(mockTask, onUpdateTask);
+    expect(screen.getByText('Test Task Code')).toBeInTheDocument();
+    expect(screen.getByText('Test Task Description')).toBeInTheDocument();
+  });
+
+  test('renders TaskStatusPanel', async () => {
+    const onUpdateTask = vi.fn();
+    await setup(mockTask, onUpdateTask);
+    expect(screen.getByText('Task Status:')).toBeInTheDocument();
+  });
+
+  test('updates task status when changed in TaskStatusPanel', async () => {
+    const user = userEvent.setup();
+    const onUpdateTask = vi.fn();
+    medplum.updateResource = vi.fn().mockResolvedValue({ ...mockTask, status: 'completed' });
+    await setup(mockTask, onUpdateTask);
+
+    const statusBadge = screen.getByText('In Progress');
+    await user.click(statusBadge);
+
+    await waitFor(() => {
+      const completedOption = screen.getByText('Completed');
+      expect(completedOption).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('Completed'));
+
+    await waitFor(() => {
+      expect(medplum.updateResource).toHaveBeenCalledWith(
+        expect.objectContaining({
+          id: 'task-123',
+          status: 'completed',
+        })
+      );
+      expect(onUpdateTask).toHaveBeenCalled();
+    });
+  });
+
+  test('renders with edit action button', async () => {
+    const onUpdateTask = vi.fn();
+    await setup(mockTask, onUpdateTask);
+
+    // Wait for the component to render
+    await waitFor(() => {
+      expect(screen.getByText('Test Task Code')).toBeInTheDocument();
+    });
+
+    // The panel should have action buttons
+    const buttons = screen.getAllByRole('button');
+    expect(buttons.length).toBeGreaterThan(0);
+  });
+
+  test('saves questionnaire response when response changes - update existing', async () => {
+    const questionnaire: Questionnaire = {
+      resourceType: 'Questionnaire',
+      id: 'q-123',
+      status: 'active',
+      item: [{ linkId: 'q1', type: 'string', text: 'Test Question' }],
+    };
+    await medplum.createResource(questionnaire);
+
+    const existingResponse: QuestionnaireResponse = {
+      resourceType: 'QuestionnaireResponse',
+      id: 'qr-456',
+      status: 'in-progress',
+      questionnaire: 'Questionnaire/q-123',
+    };
+    await medplum.createResource(existingResponse);
+
+    const task: Task = {
+      ...mockTask,
+      focus: { reference: 'Questionnaire/q-123' },
+      output: [
+        { type: { text: 'QuestionnaireResponse' }, valueReference: { reference: 'QuestionnaireResponse/qr-456' } },
+      ],
+    };
+
+    const onUpdateTask = vi.fn();
+    await setup(task, onUpdateTask);
+
+    // Wait for the component to render with task status
+    await waitFor(() => {
+      expect(screen.getByText('Task Status:')).toBeInTheDocument();
+    });
+  });
+
+  test('creates new questionnaire response when none exists', async () => {
+    const questionnaire: Questionnaire = {
+      resourceType: 'Questionnaire',
+      id: 'q-new',
+      status: 'active',
+      item: [{ linkId: 'q1', type: 'string', text: 'Test Question' }],
+    };
+    await medplum.createResource(questionnaire);
+
+    const task: Task = {
+      ...mockTask,
+      id: 'task-new-qr',
+      focus: { reference: 'Questionnaire/q-new' },
+    };
+
+    const onUpdateTask = vi.fn();
+    await setup(task, onUpdateTask);
+
+    // Wait for the component to render with task status
+    await waitFor(() => {
+      expect(screen.getByText('Task Status:')).toBeInTheDocument();
+    });
+  });
+
+  test('shows error notification when status update fails', async () => {
+    const user = userEvent.setup();
+    const onUpdateTask = vi.fn();
+    medplum.updateResource = vi.fn().mockRejectedValue(new Error('Update failed'));
+    await setup(mockTask, onUpdateTask);
+
+    const statusBadge = screen.getByText('In Progress');
+    await user.click(statusBadge);
+
+    await waitFor(() => {
+      const completedOption = screen.getByText('Completed');
+      expect(completedOption).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('Completed'));
+
+    await waitFor(() => {
+      expect(medplum.updateResource).toHaveBeenCalled();
+    });
+
+    await waitFor(() => {
+      expect(medplum.updateResource).toHaveBeenCalled();
+    });
+  });
+
+  test('renders with enabled=false disables status changes', async () => {
+    const onUpdateTask = vi.fn();
+    await setup(mockTask, onUpdateTask, false);
+
+    expect(screen.getByText('Test Task Code')).toBeInTheDocument();
+    expect(screen.getByText('Task Status:')).toBeInTheDocument();
+  });
+
+  test('handles task without focus reference', async () => {
+    const taskWithoutFocus: Task = {
+      resourceType: 'Task',
+      id: 'task-no-focus',
+      status: 'draft',
+      intent: 'order',
+      code: { text: 'Simple Task' },
+    };
+
+    const onUpdateTask = vi.fn();
+    await setup(taskWithoutFocus, onUpdateTask);
+
+    expect(screen.getByText('Simple Task')).toBeInTheDocument();
+  });
+
+  test('handles task with undefined focus reference', async () => {
+    const taskWithUndefinedFocus: Task = {
+      resourceType: 'Task',
+      id: 'task-undefined-focus',
+      status: 'draft',
+      intent: 'order',
+      code: { text: 'Task with undefined focus' },
+      focus: { display: 'Some Display' }, // focus without reference
+    };
+
+    const onUpdateTask = vi.fn();
+    await setup(taskWithUndefinedFocus, onUpdateTask);
+
+    expect(screen.getByText('Task with undefined focus')).toBeInTheDocument();
+  });
+});