vintasend 0.4.0 → 0.4.7

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

@@ -0,0 +1,120 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { MantineProvider } from '@mantine/core';
+import { act, render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MedplumProvider } from '@medplum/react';
+import { MockClient } from '@medplum/mock';
+import { MemoryRouter } from 'react-router';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { SignLockDialog } from './SignLockDialog';
+
+describe('SignLockDialog', () => {
+  let medplum: MockClient;
+
+  beforeEach(async () => {
+    medplum = new MockClient();
+    vi.clearAllMocks();
+  });
+
+  const setup = (props: Partial<Parameters<typeof SignLockDialog>[0]> = {}): ReturnType<typeof render> => {
+    return render(
+      <MemoryRouter>
+        <MedplumProvider medplum={medplum}>
+          <MantineProvider>
+            <SignLockDialog onSign={vi.fn()} {...props} />
+          </MantineProvider>
+        </MedplumProvider>
+      </MemoryRouter>
+    );
+  };
+
+  test('renders sign and lock button', () => {
+    setup();
+
+    expect(screen.getByText('Sign & Lock Note')).toBeInTheDocument();
+  });
+
+  test('renders just sign button', () => {
+    setup();
+
+    expect(screen.getByText('Just Sign')).toBeInTheDocument();
+  });
+
+  test('displays practitioner information', async () => {
+    await act(async () => {
+      setup();
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText(/Alice Smith/i)).toBeInTheDocument();
+    });
+  });
+
+  test('calls onSign with lock=true when sign and lock is clicked', async () => {
+    const user = userEvent.setup();
+    const onSign = vi.fn();
+    await act(async () => {
+      setup({ onSign });
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText('Sign & Lock Note')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('Sign & Lock Note'));
+
+    await waitFor(() => {
+      expect(onSign).toHaveBeenCalled();
+      const call = onSign.mock.calls[0];
+      expect(call[1]).toBe(true);
+    });
+  });
+
+  test('calls onSign with lock=false when just sign is clicked', async () => {
+    const user = userEvent.setup();
+    const onSign = vi.fn();
+    await act(async () => {
+      setup({ onSign });
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText('Just Sign')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('Just Sign'));
+
+    await waitFor(() => {
+      expect(onSign).toHaveBeenCalled();
+      const call = onSign.mock.calls[0];
+      expect(call[1]).toBe(false);
+    });
+  });
+
+  test('handles error gracefully when no author is found', async () => {
+    const user = userEvent.setup();
+    const onSign = vi.fn();
+    const medplumWithoutProfile = new MockClient({ profile: null });
+
+    render(
+      <MemoryRouter>
+        <MedplumProvider medplum={medplumWithoutProfile}>
+          <MantineProvider>
+            <SignLockDialog onSign={onSign} />
+          </MantineProvider>
+        </MedplumProvider>
+      </MemoryRouter>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText('Sign & Lock Note')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('Sign & Lock Note'));
+
+    // Verify that onSign is not called when there's no author
+    await waitFor(() => {
+      expect(onSign).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -0,0 +1,57 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Button, Group, Paper, Stack, Text } from '@mantine/core';
+import { createReference } from '@medplum/core';
+import type { Practitioner, Reference } from '@medplum/fhirtypes';
+import { ResourceAvatar, useMedplumProfile } from '@medplum/react';
+import { IconLock, IconSignature } from '@tabler/icons-react';
+import type { JSX } from 'react';
+import { showErrorNotification } from '../../utils/notifications';
+
+interface SignLockDialogProps {
+  onSign: (practitioner: Reference<Practitioner>, lock: boolean) => void;
+}
+
+export const SignLockDialog = (props: SignLockDialogProps): JSX.Element => {
+  const { onSign } = props;
+  const author = useMedplumProfile();
+  const authorReference = author ? (createReference(author) as Reference<Practitioner>) : undefined;
+
+  const handleSign = (lock: boolean): void => {
+    if (!authorReference) {
+      showErrorNotification('No author information found');
+      return;
+    }
+
+    onSign(authorReference, lock);
+  };
+
+  return (
+    <Stack gap="md">
+      <Paper p="sm" withBorder radius="md">
+        <Group gap="sm">
+          <ResourceAvatar value={authorReference} radius="xl" size={36} />
+          <Text size="sm" fw={500}>
+            {authorReference?.display}
+          </Text>
+        </Group>
+      </Paper>
+
+      <Stack gap={0}>
+        <Button fullWidth leftSection={<IconLock size={18} />} onClick={() => handleSign(true)} mt="md">
+          Sign & Lock Note
+        </Button>
+
+        <Button
+          variant="outline"
+          fullWidth
+          leftSection={<IconSignature size={18} />}
+          onClick={() => handleSign(false)}
+          mt="md"
+        >
+          Just Sign
+        </Button>
+      </Stack>
+    </Stack>
+  );
+};

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

@@ -0,0 +1,224 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { MantineProvider } from '@mantine/core';
+import { act, fireEvent, 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 { VisitDetailsPanel } from './VisitDetailsPanel';
+
+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',
+    end: '2024-01-01T11:00:00Z',
+  },
+  subject: { reference: 'Patient/patient-123' },
+};
+
+const mockPractitioner: Practitioner = {
+  resourceType: 'Practitioner',
+  id: 'practitioner-123',
+  name: [{ given: ['Dr.'], family: 'Test' }],
+};
+
+describe('VisitDetailsPanel', () => {
+  let medplum: MockClient;
+
+  beforeEach(async () => {
+    medplum = new MockClient();
+  });
+
+  const setup = (props: Partial<Parameters<typeof VisitDetailsPanel>[0]> = {}): ReturnType<typeof render> => {
+    return render(
+      <MemoryRouter>
+        <MedplumProvider medplum={medplum}>
+          <MantineProvider>
+            <VisitDetailsPanel encounter={mockEncounter} onEncounterChange={vi.fn()} {...props} />
+          </MantineProvider>
+        </MedplumProvider>
+      </MemoryRouter>
+    );
+  };
+
+  test('renders visit details title', () => {
+    setup();
+
+    expect(screen.getByText('Visit Details')).toBeInTheDocument();
+  });
+
+  test('renders practitioner input', () => {
+    setup();
+
+    expect(screen.getByText(/Practitioner/i)).toBeInTheDocument();
+  });
+
+  test('renders check in date input', () => {
+    setup();
+
+    expect(screen.getByLabelText(/Check in/i)).toBeInTheDocument();
+  });
+
+  test('renders check out date input', () => {
+    setup();
+
+    expect(screen.getByLabelText(/Check out/i)).toBeInTheDocument();
+  });
+
+  test('calls onEncounterChange when practitioner is changed', async () => {
+    const onEncounterChange = vi.fn();
+
+    const mockPractitioner1: Practitioner = {
+      resourceType: 'Practitioner',
+      id: 'practitioner-1',
+      name: [{ given: ['Dr.'], family: 'Test' }],
+    };
+
+    const mockPractitioner2: Practitioner = {
+      resourceType: 'Practitioner',
+      id: 'practitioner-2',
+      name: [{ given: ['Dr.'], family: 'Smith' }],
+    };
+
+    await medplum.createResource(mockPractitioner1);
+    await medplum.createResource(mockPractitioner2);
+
+    // Mock search to return practitioners
+    vi.spyOn(medplum, 'searchResources').mockResolvedValue([mockPractitioner1, mockPractitioner2] as any);
+
+    // Start without a practitioner selected so ResourceInput shows a searchbox
+    setup({ onEncounterChange });
+
+    await waitFor(() => {
+      expect(screen.getByText(/Practitioner/i)).toBeInTheDocument();
+    });
+
+    // Find the ResourceInput searchbox (ResourceInput uses AsyncAutocomplete which renders a searchbox)
+    await waitFor(
+      () => {
+        const searchbox = screen.queryByRole('searchbox');
+        expect(searchbox).toBeInTheDocument();
+      },
+      { timeout: 3000 }
+    );
+
+    const practitionerInput = screen.getByRole('searchbox');
+
+    // Type to search for a practitioner using fireEvent.change (like PlanDefinitionBuilder)
+    await act(async () => {
+      fireEvent.change(practitionerInput, { target: { value: 'Smith' } });
+    });
+
+    // Wait for search to be called
+    await waitFor(
+      () => {
+        expect(medplum.searchResources).toHaveBeenCalledWith(
+          'Practitioner',
+          expect.any(URLSearchParams),
+          expect.any(Object)
+        );
+      },
+      { timeout: 3000 }
+    );
+
+    // Wait for the dropdown option to appear and click it (like PlanDefinitionBuilder)
+    // The display string for Practitioner is typically "Dr. Smith" or just "Smith"
+    await waitFor(
+      () => {
+        const smithOption = screen.queryByText(/Smith/i);
+        expect(smithOption).toBeInTheDocument();
+      },
+      { timeout: 3000 }
+    );
+
+    await act(async () => {
+      const smithOption = screen.getByText(/Smith/i);
+      fireEvent.click(smithOption);
+    });
+
+    // Verify onEncounterChange was called with updated encounter
+    await waitFor(
+      () => {
+        expect(onEncounterChange).toHaveBeenCalled();
+        const call = onEncounterChange.mock.calls[onEncounterChange.mock.calls.length - 1];
+        const updatedEncounter = call[0] as Encounter;
+        expect(updatedEncounter.participant).toBeDefined();
+        expect(updatedEncounter.participant?.[0]?.individual?.reference).toBe('Practitioner/practitioner-2');
+      },
+      { timeout: 5000 }
+    );
+  });
+
+  test('calls onEncounterChange when check in time is changed', async () => {
+    const user = userEvent.setup();
+    const onEncounterChange = vi.fn();
+    setup({ onEncounterChange });
+
+    const checkinInput = screen.getByLabelText(/Check in/i);
+    await user.clear(checkinInput);
+    await user.type(checkinInput, '2024-01-02T10:00:00Z');
+
+    await waitFor(() => {
+      expect(onEncounterChange).toHaveBeenCalled();
+    });
+  });
+
+  test('calls onEncounterChange when check out time is changed', async () => {
+    const user = userEvent.setup();
+    const onEncounterChange = vi.fn();
+    setup({ onEncounterChange });
+
+    const checkoutInput = screen.getByLabelText(/Check out/i);
+    await user.clear(checkoutInput);
+    await user.type(checkoutInput, '2024-01-02T11:00:00Z');
+
+    await waitFor(() => {
+      expect(onEncounterChange).toHaveBeenCalled();
+    });
+  });
+
+  test('displays default practitioner value', async () => {
+    await medplum.createResource(mockPractitioner);
+    setup({ practitioner: mockPractitioner });
+
+    await waitFor(() => {
+      expect(screen.getByText(/Practitioner/i)).toBeInTheDocument();
+      expect(screen.getByText(/Dr\. Test/i)).toBeInTheDocument();
+    });
+  });
+
+  test('displays default check in time', () => {
+    setup();
+
+    const checkinInput = screen.getByLabelText(/Check in/i);
+    // DateTimeInput converts UTC to local time, so we need to format in local time
+    const utcDate = new Date('2024-01-01T10:00:00Z');
+    const year = utcDate.getFullYear();
+    const month = String(utcDate.getMonth() + 1).padStart(2, '0');
+    const day = String(utcDate.getDate()).padStart(2, '0');
+    const hours = String(utcDate.getHours()).padStart(2, '0');
+    const minutes = String(utcDate.getMinutes()).padStart(2, '0');
+    const localTimeString = `${year}-${month}-${day}T${hours}:${minutes}`;
+    expect(checkinInput).toHaveValue(localTimeString);
+  });
+
+  test('displays default check out time', () => {
+    setup();
+
+    const checkoutInput = screen.getByLabelText(/Check out/i);
+    const utcDate = new Date('2024-01-01T11:00:00Z');
+    const year = utcDate.getFullYear();
+    const month = String(utcDate.getMonth() + 1).padStart(2, '0');
+    const day = String(utcDate.getDate()).padStart(2, '0');
+    const hours = String(utcDate.getHours()).padStart(2, '0');
+    const minutes = String(utcDate.getMinutes()).padStart(2, '0');
+    const localTimeString = `${year}-${month}-${day}T${hours}:${minutes}`;
+    expect(checkoutInput).toHaveValue(localTimeString);
+  });
+});

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

@@ -0,0 +1,100 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Card, Stack, Text } from '@mantine/core';
+import { getReferenceString } from '@medplum/core';
+import type { Encounter, Practitioner } from '@medplum/fhirtypes';
+import { DateTimeInput, ResourceInput } from '@medplum/react';
+import type { JSX } from 'react';
+
+interface VisitDetailsPanelProps {
+  practitioner?: Practitioner;
+  encounter: Encounter;
+  onEncounterChange: (encounter: Encounter) => void;
+}
+
+export const VisitDetailsPanel = (props: VisitDetailsPanelProps): JSX.Element => {
+  const { practitioner, encounter, onEncounterChange } = props;
+
+  const handlePractitionerChange = async (practitioner: Practitioner | undefined): Promise<void> => {
+    if (!encounter || !practitioner) {
+      return;
+    }
+
+    const updatedEncounter = {
+      ...encounter,
+      participant: [
+        {
+          individual: {
+            reference: getReferenceString(practitioner),
+          },
+        },
+      ],
+    };
+
+    onEncounterChange(updatedEncounter);
+  };
+
+  const handleCheckinChange = async (checkin: string): Promise<void> => {
+    if (!encounter || !checkin) {
+      return;
+    }
+
+    const updatedEncounter = {
+      ...encounter,
+      period: {
+        start: checkin,
+      },
+    };
+
+    onEncounterChange(updatedEncounter);
+  };
+
+  const handleCheckoutChange = async (checkout: string): Promise<void> => {
+    if (!encounter || !checkout) {
+      return;
+    }
+
+    const updatedEncounter = {
+      ...encounter,
+      period: {
+        end: checkout,
+      },
+    };
+
+    onEncounterChange(updatedEncounter);
+  };
+
+  return (
+    <Stack gap={0}>
+      <Text fw={600} size="lg" mb="md">
+        Visit Details
+      </Text>
+      <Card withBorder shadow="sm" p="md">
+        <Stack gap="md">
+          <ResourceInput
+            resourceType="Practitioner"
+            name="practitioner"
+            label="Practitioner"
+            placeholder="Search for practitioner"
+            defaultValue={practitioner}
+            onChange={handlePractitionerChange}
+          />
+
+          <DateTimeInput
+            name="checkin"
+            label="Check in"
+            defaultValue={encounter.period?.start}
+            onChange={handleCheckinChange}
+          />
+
+          <DateTimeInput
+            name="checkout"
+            label="Check out"
+            defaultValue={encounter.period?.end}
+            onChange={handleCheckoutChange}
+          />
+        </Stack>
+      </Card>
+    </Stack>
+  );
+};