vintasend 0.4.0 → 0.4.7

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

@@ -0,0 +1,282 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Box, Card, Stack, Textarea, Title } from '@mantine/core';
+import { createReference, getReferenceString } from '@medplum/core';
+import type {
+  ClinicalImpression,
+  Encounter,
+  Patient,
+  Practitioner,
+  Provenance,
+  Reference,
+  Task,
+} from '@medplum/fhirtypes';
+import { Loading, useMedplum, useResource } from '@medplum/react';
+import { useCallback, useEffect, useState } from 'react';
+import type { JSX } from 'react';
+import { SAVE_TIMEOUT_MS } from '../../config/constants';
+import { useEncounterChart } from '../../hooks/useEncounterChart';
+import { useDebouncedUpdateResource } from '../../hooks/useDebouncedUpdateResource';
+import { ChartNoteStatus } from '../../types/encounter';
+import { updateEncounterStatus } from '../../utils/encounter';
+import { showErrorNotification } from '../../utils/notifications';
+import { EncounterHeader } from './EncounterHeader';
+import { SignAddendum } from './SignAddendum';
+import { TaskPanel } from '../tasks/encounter/TaskPanel';
+import { BillingTab } from './BillingTab';
+
+const FHIR_ACT_REASON_SYSTEM = 'http://terminology.hl7.org/CodeSystem/v3-ActReason';
+const FHIR_PROVENANCE_PARTICIPANT_TYPE_SYSTEM = 'http://terminology.hl7.org/CodeSystem/provenance-participant-type';
+const FHIR_DOCUMENT_COMPLETION_SYSTEM = 'http://terminology.hl7.org/CodeSystem/v3-DocumentCompletion';
+
+const TASK_COMPLETED_STATUSES = new Set<Task['status']>([
+  'completed',
+  'cancelled',
+  'failed',
+  'rejected',
+  'entered-in-error',
+]);
+
+export interface EncounterChartProps {
+  encounter: Encounter | Reference<Encounter>;
+}
+
+export const EncounterChart = (props: EncounterChartProps): JSX.Element => {
+  const { encounter: encounterProp } = props;
+  const medplum = useMedplum();
+  const encounterResource = useResource(encounterProp);
+  const patientReference = encounterResource?.subject as Reference<Patient> | undefined;
+  const patientResource = useResource(patientReference);
+
+  const [activeTab, setActiveTab] = useState<string>('notes');
+  const {
+    encounter,
+    claim,
+    practitioner,
+    tasks,
+    clinicalImpression,
+    chargeItems,
+    appointment,
+    setEncounter,
+    setClaim,
+    setPractitioner,
+    setTasks,
+    setChargeItems,
+  } = useEncounterChart(encounterProp, patientReference);
+
+  const [chartNote, setChartNote] = useState<string | undefined>(clinicalImpression?.note?.[0]?.text);
+  const debouncedUpdateResource = useDebouncedUpdateResource(medplum, SAVE_TIMEOUT_MS);
+  const [provenances, setProvenances] = useState<Provenance[]>([]);
+  const [chartNoteStatus, setChartNoteStatus] = useState<ChartNoteStatus>(ChartNoteStatus.Unsigned);
+
+  useEffect(() => {
+    if (!encounter) {
+      return;
+    }
+
+    const fetchProvenance = async (): Promise<void> => {
+      const provenance = await medplum.searchResources('Provenance', `target=${getReferenceString(encounter)}`);
+      setProvenances(provenance);
+      if (provenance.length > 0 && clinicalImpression?.status === 'completed') {
+        setChartNoteStatus(ChartNoteStatus.SignedAndLocked);
+      } else if (provenance.length > 0) {
+        setChartNoteStatus(ChartNoteStatus.Signed);
+      } else {
+        setChartNoteStatus(ChartNoteStatus.Unsigned);
+      }
+    };
+
+    fetchProvenance().catch((err) => showErrorNotification(err));
+  }, [clinicalImpression, encounter, medplum]);
+
+  const updateTaskList = useCallback(
+    (updatedTask: Task): void => {
+      setTasks((prevTasks) => prevTasks.map((task) => (task.id === updatedTask.id ? updatedTask : task)));
+    },
+    [setTasks]
+  );
+
+  const handleEncounterStatusChange = useCallback(
+    async (newStatus: Encounter['status']): Promise<void> => {
+      if (!encounter) {
+        return;
+      }
+
+      try {
+        const updatedEncounter = await updateEncounterStatus(medplum, encounter, appointment, newStatus);
+        setEncounter(updatedEncounter);
+      } catch (err) {
+        showErrorNotification(err);
+      }
+    },
+    [encounter, medplum, setEncounter, appointment]
+  );
+
+  const handleTabChange = (tab: string): void => {
+    setActiveTab(tab);
+  };
+
+  const handleChartNoteChange = async (e: React.ChangeEvent<HTMLTextAreaElement>): Promise<void> => {
+    setChartNote(e.target.value);
+
+    if (!clinicalImpression) {
+      return;
+    }
+
+    try {
+      if (!e.target.value || e.target.value === '') {
+        const { note: _, ...restOfClinicalImpression } = clinicalImpression;
+        const updatedClinicalImpression: ClinicalImpression = restOfClinicalImpression;
+        await debouncedUpdateResource(updatedClinicalImpression);
+      } else {
+        const updatedClinicalImpression: ClinicalImpression = {
+          ...clinicalImpression,
+          note: [{ text: e.target.value }],
+        };
+        await debouncedUpdateResource(updatedClinicalImpression);
+      }
+    } catch (err) {
+      showErrorNotification(err);
+    }
+  };
+
+  const handleSign = async (practitioner: Reference<Practitioner>, lock: boolean): Promise<void> => {
+    if (!encounter) {
+      return;
+    }
+
+    if (lock) {
+      // Complete all incomplete tasks
+      const tasksToUpdate = tasks.filter((task) => !TASK_COMPLETED_STATUSES.has(task.status));
+      const updatedTasks = await Promise.all(
+        tasksToUpdate.map((task) =>
+          medplum.updateResource({
+            ...task,
+            status: 'completed',
+          })
+        )
+      );
+
+      setTasks(
+        tasks.map((task) => {
+          const updated = updatedTasks.find((t) => t.id === task.id);
+          return updated || task;
+        })
+      );
+    }
+
+    // Create provenance record with signature
+    const newProvenance = await medplum.createResource<Provenance>({
+      resourceType: 'Provenance',
+      target: [createReference(encounter)],
+      recorded: new Date().toISOString(),
+      reason: [
+        {
+          coding: [
+            {
+              system: FHIR_ACT_REASON_SYSTEM,
+              code: 'SIGN',
+              display: 'Signed',
+            },
+          ],
+        },
+      ],
+      agent: [
+        {
+          type: {
+            coding: [
+              {
+                system: FHIR_PROVENANCE_PARTICIPANT_TYPE_SYSTEM,
+                code: 'author',
+              },
+            ],
+          },
+          who: practitioner,
+        },
+      ],
+      signature: [
+        {
+          type: [
+            {
+              system: FHIR_DOCUMENT_COMPLETION_SYSTEM,
+              code: 'LA',
+              display: 'legally authenticated',
+            },
+          ],
+          when: new Date().toISOString(),
+          who: practitioner,
+        },
+      ],
+    });
+
+    setProvenances([...provenances, newProvenance]);
+
+    if (lock) {
+      setChartNoteStatus(ChartNoteStatus.SignedAndLocked);
+    } else {
+      setChartNoteStatus(ChartNoteStatus.Signed);
+    }
+  };
+
+  if (!patientResource || !encounter) {
+    return <Loading />;
+  }
+
+  return (
+    <>
+      <Stack justify="space-between" gap={0}>
+        <EncounterHeader
+          encounter={encounter}
+          chartNoteStatus={chartNoteStatus}
+          practitioner={practitioner}
+          onStatusChange={handleEncounterStatusChange}
+          onTabChange={handleTabChange}
+          onSign={handleSign}
+        />
+        <Box p="md">
+          {activeTab === 'notes' && (
+            <Stack gap="md">
+              <SignAddendum encounter={encounter} provenances={provenances} chartNoteStatus={chartNoteStatus} />
+
+              {clinicalImpression && (
+                <Card withBorder shadow="sm" mt="md">
+                  <Title>Fill chart note</Title>
+                  <Textarea
+                    defaultValue={clinicalImpression.note?.[0]?.text}
+                    value={chartNote}
+                    onChange={handleChartNoteChange}
+                    autosize
+                    minRows={4}
+                    maxRows={8}
+                    disabled={chartNoteStatus === ChartNoteStatus.SignedAndLocked}
+                  />
+                </Card>
+              )}
+              {tasks.map((task: Task) => (
+                <TaskPanel
+                  key={task.id}
+                  task={task}
+                  onUpdateTask={updateTaskList}
+                  enabled={chartNoteStatus !== ChartNoteStatus.SignedAndLocked}
+                />
+              ))}
+            </Stack>
+          )}
+          {activeTab === 'details' && (
+            <BillingTab
+              encounter={encounter}
+              setEncounter={setEncounter}
+              claim={claim}
+              patient={patientResource}
+              practitioner={practitioner}
+              setPractitioner={setPractitioner}
+              chargeItems={chargeItems}
+              setChargeItems={setChargeItems}
+              setClaim={setClaim}
+            />
+          )}
+        </Box>
+      </Stack>
+    </>
+  );
+};

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

@@ -0,0 +1,268 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { MantineProvider } from '@mantine/core';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MedplumProvider } from '@medplum/react';
+import type { Encounter, Practitioner } from '@medplum/fhirtypes';
+import { MockClient } from '@medplum/mock';
+import { MemoryRouter } from 'react-router';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { EncounterHeader } from './EncounterHeader';
+import { ChartNoteStatus } from '../../types/encounter';
+
+const mockEncounter: Encounter = {
+  resourceType: 'Encounter',
+  id: 'encounter-123',
+  status: 'in-progress',
+  class: { code: 'AMB', system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode' },
+  period: {
+    start: '2024-01-01T10:00:00Z',
+  },
+  subject: { reference: 'Patient/patient-123' },
+};
+
+const mockPractitioner: Practitioner = {
+  resourceType: 'Practitioner',
+  id: 'practitioner-123',
+  name: [{ given: ['Dr.'], family: 'Test' }],
+};
+
+describe('EncounterHeader', () => {
+  let medplum: MockClient;
+
+  beforeEach(async () => {
+    medplum = new MockClient();
+  });
+
+  const setup = (props: Partial<Parameters<typeof EncounterHeader>[0]> = {}): ReturnType<typeof render> => {
+    return render(
+      <MemoryRouter>
+        <MedplumProvider medplum={medplum}>
+          <MantineProvider>
+            <EncounterHeader encounter={mockEncounter} {...props} />
+          </MantineProvider>
+        </MedplumProvider>
+      </MemoryRouter>
+    );
+  };
+
+  test('renders encounter title and details', () => {
+    setup({ practitioner: mockPractitioner });
+
+    expect(screen.getByText('Visit')).toBeInTheDocument();
+    expect(screen.getByText(/Dr\. Test/)).toBeInTheDocument();
+  });
+
+  test('displays status button', () => {
+    setup();
+
+    expect(screen.getByText('In Progress')).toBeInTheDocument();
+  });
+
+  test('shows status menu for active encounters', async () => {
+    const user = userEvent.setup();
+    setup();
+
+    const statusButton = screen.getByText('In Progress');
+    await user.click(statusButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('Finished')).toBeInTheDocument();
+      expect(screen.getByText('Cancelled')).toBeInTheDocument();
+    });
+  });
+
+  test('calls onStatusChange when status is changed', async () => {
+    const user = userEvent.setup();
+    const onStatusChange = vi.fn();
+    setup({ onStatusChange });
+
+    const statusButton = screen.getByText('In Progress');
+    await user.click(statusButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('Finished')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('Finished'));
+
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenCalledWith('finished');
+    });
+  });
+
+  test('shows confirmation modal when cancelling encounter', async () => {
+    const user = userEvent.setup();
+    const onStatusChange = vi.fn();
+    setup({ onStatusChange });
+
+    const statusButton = screen.getByText('In Progress');
+    await user.click(statusButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('Cancelled')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('Cancelled'));
+
+    await waitFor(() => {
+      expect(screen.getByText('Are you sure you want to cancel this encounter?')).toBeInTheDocument();
+    });
+  });
+
+  test('confirms cancellation when user clicks yes', async () => {
+    const user = userEvent.setup();
+    const onStatusChange = vi.fn();
+    setup({ onStatusChange });
+
+    const statusButton = screen.getByText('In Progress');
+    await user.click(statusButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('Cancelled')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('Cancelled'));
+
+    await waitFor(() => {
+      expect(screen.getByText('Yes, cancel it')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('Yes, cancel it'));
+
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenCalledWith('cancelled');
+    });
+  });
+
+  test('cancels cancellation when user clicks no', async () => {
+    const user = userEvent.setup();
+    const onStatusChange = vi.fn();
+    setup({ onStatusChange });
+
+    const statusButton = screen.getByText('In Progress');
+    await user.click(statusButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('Cancelled')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('Cancelled'));
+
+    await waitFor(() => {
+      expect(screen.getByText('No, keep it')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('No, keep it'));
+
+    await waitFor(() => {
+      expect(screen.queryByText('Are you sure you want to cancel this encounter?')).not.toBeInTheDocument();
+    });
+
+    expect(onStatusChange).not.toHaveBeenCalled();
+  });
+
+  test('calls onTabChange when tab is changed', async () => {
+    const user = userEvent.setup();
+    const onTabChange = vi.fn();
+    setup({ onTabChange });
+
+    const detailsTab = screen.getByText('Details & Billing');
+    await user.click(detailsTab);
+
+    await waitFor(() => {
+      expect(onTabChange).toHaveBeenCalledWith('details');
+    });
+  });
+
+  test('shows sign button for finished unsigned encounters', () => {
+    const finishedEncounter: Encounter = {
+      ...mockEncounter,
+      status: 'finished',
+    };
+    const { container } = setup({ encounter: finishedEncounter, chartNoteStatus: ChartNoteStatus.Unsigned });
+
+    const signButtons = container.querySelectorAll('button');
+    expect(signButtons.length).toBeGreaterThan(0);
+  });
+
+  test('opens sign dialog when sign button is clicked', async () => {
+    const user = userEvent.setup();
+    const finishedEncounter: Encounter = {
+      ...mockEncounter,
+      status: 'finished',
+    };
+    setup({ encounter: finishedEncounter, chartNoteStatus: ChartNoteStatus.Unsigned });
+
+    const signButtons = screen.getAllByRole('button');
+    const signButton = signButtons.find((btn) => btn.querySelector('svg'));
+    if (signButton) {
+      await user.click(signButton);
+    }
+
+    await waitFor(() => {
+      expect(screen.getByText('Signing As')).toBeInTheDocument();
+    });
+  });
+
+  test('calls onSign when signing', async () => {
+    const user = userEvent.setup();
+    const onSign = vi.fn();
+    const finishedEncounter: Encounter = {
+      ...mockEncounter,
+      status: 'finished',
+    };
+    setup({ encounter: finishedEncounter, chartNoteStatus: ChartNoteStatus.Unsigned, onSign });
+
+    const signButtons = screen.getAllByRole('button');
+    const signButton = signButtons.find((btn) => btn.querySelector('svg'));
+    if (signButton) {
+      await user.click(signButton);
+    }
+
+    await waitFor(() => {
+      expect(screen.getByText('Just Sign')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('Just Sign'));
+
+    await waitFor(() => {
+      expect(onSign).toHaveBeenCalled();
+    });
+  });
+
+  test('does not show sign button for cancelled encounters', () => {
+    const cancelledEncounter: Encounter = {
+      ...mockEncounter,
+      status: 'cancelled',
+    };
+    setup({ encounter: cancelledEncounter });
+
+    const signButtons = screen.queryAllByRole('button');
+    const hasSignIcon = signButtons.some((btn) => btn.querySelector('svg[data-icon="lock"]'));
+    expect(hasSignIcon).toBe(false);
+  });
+
+  test('displays correct status for finished encounters', () => {
+    setup({ encounter: { ...mockEncounter, status: 'finished' } });
+    expect(screen.getByText('Finished')).toBeInTheDocument();
+  });
+
+  test('displays correct status for cancelled encounters', () => {
+    setup({ encounter: { ...mockEncounter, status: 'cancelled' } });
+    expect(screen.getByText('Cancelled')).toBeInTheDocument();
+  });
+
+  test('renders with practitioner name', () => {
+    setup({ practitioner: mockPractitioner });
+
+    expect(screen.getByText(/Dr\. Test/)).toBeInTheDocument();
+  });
+
+  test('renders with unknown provider when practitioner is not provided', () => {
+    setup({ practitioner: undefined });
+
+    expect(screen.getByText(/Unknown Provider/)).toBeInTheDocument();
+  });
+});