vintasend 0.4.0 → 0.4.7

package/dist/examples/vintasend-medplum-example/src/pages/labs/OrderLabsPage.test.tsx

@@ -0,0 +1,356 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { ServiceRequest } from '@medplum/fhirtypes';
+import type { LabOrganization, TestCoding } from '@medplum/health-gorilla-core';
+import { HomerSimpson, MockClient } from '@medplum/mock';
+import { MedplumProvider } from '@medplum/react';
+import { showNotification } from '@mantine/notifications';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { OrderLabsPage } from './OrderLabsPage';
+import { act, fireEvent, render, screen, waitFor } from '../../test-utils/render';
+import * as notifications from '../../utils/notifications';
+
+vi.mock('@medplum/health-gorilla-react', async () => {
+  const actual = await vi.importActual('@medplum/health-gorilla-react');
+  return {
+    ...actual,
+    useHealthGorillaLabOrder: vi.fn(),
+  };
+});
+
+vi.mock('react-router', async () => {
+  const actual = await vi.importActual('react-router');
+  return {
+    ...actual,
+    useParams: vi.fn(),
+  };
+});
+
+vi.mock('@mantine/notifications', () => ({
+  showNotification: vi.fn(),
+}));
+
+vi.mock('../../utils/notifications', () => ({
+  showErrorNotification: vi.fn(),
+}));
+
+import { useHealthGorillaLabOrder } from '@medplum/health-gorilla-react';
+import { MemoryRouter, useParams } from 'react-router';
+
+describe('OrderLabsPage', () => {
+  let medplum: MockClient;
+  let mockOnSubmitLabOrder: () => void;
+  let mockLabOrderReturn: ReturnType<typeof useHealthGorillaLabOrder>;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+
+    medplum = new MockClient();
+    mockOnSubmitLabOrder = vi.fn();
+
+    const mockTest: TestCoding = {
+      code: 'TEST001',
+      display: 'Complete Blood Count',
+      system: 'http://loinc.org',
+    };
+
+    const mockLab: LabOrganization = {
+      resourceType: 'Organization',
+      id: 'lab-123',
+      name: 'Test Lab',
+      identifier: [
+        {
+          system: 'https://www.healthgorilla.com/fhir/StructureDefinition/organization-identifier',
+          value: 'HG123',
+        },
+      ],
+    } as LabOrganization;
+
+    mockLabOrderReturn = {
+      state: {
+        performingLab: undefined,
+        performingLabAccountNumber: undefined,
+        selectedTests: [],
+        testMetadata: {},
+        diagnoses: [],
+        billingInformation: {
+          billTo: 'patient',
+        },
+        specimenCollectedDateTime: undefined,
+        orderNotes: undefined,
+      },
+      removeDiagnosis: vi.fn(),
+      setDiagnoses: vi.fn(),
+      getActivePatientCoverages: vi.fn().mockResolvedValue([]),
+      updateBillingInformation: vi.fn(),
+      setSpecimenCollectedDateTime: vi.fn(),
+      setOrderNotes: vi.fn(),
+      validateOrder: vi.fn().mockReturnValue(undefined),
+      createOrderBundle: vi.fn().mockResolvedValue({
+        serviceRequest: {
+          resourceType: 'ServiceRequest',
+          id: 'order-123',
+          status: 'draft',
+        } as ServiceRequest,
+      }),
+      searchAvailableLabs: vi.fn().mockResolvedValue([mockLab]),
+      searchAvailableTests: vi.fn().mockResolvedValue([mockTest]),
+      setPerformingLab: vi.fn(),
+      setPerformingLabAccountNumber: vi.fn(),
+      addTest: vi.fn(),
+      removeTest: vi.fn(),
+      setTests: vi.fn(),
+      updateTestMetadata: vi.fn(),
+      addDiagnosis: vi.fn(),
+    };
+
+    vi.mocked(useHealthGorillaLabOrder).mockReturnValue(mockLabOrderReturn);
+    vi.mocked(useParams).mockReturnValue({});
+    vi.spyOn(medplum, 'executeBot').mockResolvedValue({});
+  });
+
+  function setup(props: { patientId?: string } = {}): void {
+    vi.mocked(useParams).mockReturnValue({ patientId: props.patientId });
+
+    if (props.patientId) {
+      vi.spyOn(medplum, 'readResource').mockResolvedValue(HomerSimpson as typeof HomerSimpson & { id: string });
+    }
+
+    render(
+      <MemoryRouter>
+        <MedplumProvider medplum={medplum}>
+          <OrderLabsPage onSubmitLabOrder={mockOnSubmitLabOrder} />
+        </MedplumProvider>
+      </MemoryRouter>
+    );
+  }
+
+  test('Renders form fields', () => {
+    setup();
+
+    expect(screen.getByText('Requester')).toBeInTheDocument();
+    expect(screen.getByLabelText(/^Patient/)).toBeInTheDocument();
+    expect(screen.getByText('Selected tests')).toBeInTheDocument();
+    expect(screen.getByText('Diagnoses')).toBeInTheDocument();
+    expect(screen.getByText('Bill to')).toBeInTheDocument();
+    expect(screen.getByText('Order notes')).toBeInTheDocument();
+    expect(screen.getByText('Specimen collection time')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Submit Order' })).toBeInTheDocument();
+  });
+
+  test('Loads patient when patientId is provided', async () => {
+    setup({ patientId: 'patient-123' });
+
+    await waitFor(() => {
+      expect(medplum.readResource).toHaveBeenCalledWith('Patient', 'patient-123');
+    });
+  });
+
+  test('Shows test metadata cards when tests are selected', () => {
+    const mockTest: TestCoding = {
+      code: 'TEST001',
+      display: 'Complete Blood Count',
+      system: 'http://loinc.org',
+    };
+
+    mockLabOrderReturn.state.selectedTests = [mockTest];
+    mockLabOrderReturn.state.testMetadata = {
+      TEST001: { aoeStatus: 'none' },
+    };
+    vi.mocked(useHealthGorillaLabOrder).mockReturnValue(mockLabOrderReturn);
+
+    setup();
+
+    // Test metadata cards should be rendered (component will render them)
+    expect(screen.getByText('Selected tests')).toBeInTheDocument();
+  });
+
+  test('Shows coverage input when patient is set', async () => {
+    mockLabOrderReturn.state.performingLab = {
+      resourceType: 'Organization',
+      id: 'lab-123',
+    } as LabOrganization;
+    vi.mocked(useHealthGorillaLabOrder).mockReturnValue(mockLabOrderReturn);
+
+    await act(async () => setup({ patientId: 'patient-123' }));
+    expect(screen.getByText('Bill to')).toBeInTheDocument();
+  });
+
+  test('Updates billing information when radio button is selected', async () => {
+    setup();
+
+    const insuranceRadio = screen.getByLabelText('Insurance');
+
+    await act(async () => {
+      fireEvent.click(insuranceRadio);
+    });
+
+    expect(mockLabOrderReturn.updateBillingInformation).toHaveBeenCalledWith({
+      billTo: 'insurance',
+    });
+  });
+
+  test('Updates order notes when text input changes', async () => {
+    setup();
+
+    const notesInput = screen.getByLabelText('Order notes');
+
+    await act(async () => {
+      fireEvent.change(notesInput, { target: { value: 'Test notes' } });
+    });
+
+    expect(mockLabOrderReturn.setOrderNotes).toHaveBeenCalledWith('Test notes');
+  });
+
+  test('Submits order successfully', async () => {
+    const mockServiceRequest: ServiceRequest = {
+      resourceType: 'ServiceRequest',
+      id: 'order-123',
+      status: 'draft',
+    } as ServiceRequest;
+
+    mockLabOrderReturn.createOrderBundle = vi.fn().mockResolvedValue({
+      serviceRequest: mockServiceRequest,
+    });
+    vi.mocked(useHealthGorillaLabOrder).mockReturnValue(mockLabOrderReturn);
+    vi.spyOn(medplum, 'executeBot').mockResolvedValue({});
+
+    setup();
+
+    const submitButton = screen.getByRole('button', { name: 'Submit Order' });
+
+    await act(async () => {
+      fireEvent.click(submitButton);
+    });
+
+    await waitFor(() => {
+      expect(mockLabOrderReturn.createOrderBundle).toHaveBeenCalled();
+    });
+
+    await waitFor(() => {
+      expect(medplum.executeBot).toHaveBeenCalled();
+    });
+
+    const executeBotCall = (medplum.executeBot as ReturnType<typeof vi.fn>).mock.calls[0];
+    expect(executeBotCall[0]).toEqual({
+      system: 'https://www.medplum.com/integrations/bot-identifier',
+      value: 'health-gorilla-labs/send-to-health-gorilla',
+    });
+    expect(executeBotCall[1]).toEqual(mockServiceRequest);
+
+    expect(showNotification).toHaveBeenCalledWith({
+      title: 'Lab Order Submitted',
+      message: 'The lab order has been successfully submitted.',
+      color: 'green',
+    });
+
+    expect(mockOnSubmitLabOrder).toHaveBeenCalled();
+  });
+
+  test('Shows error when order submission fails', async () => {
+    const error = new Error('Submission failed');
+    mockLabOrderReturn.createOrderBundle = vi.fn().mockRejectedValue(error);
+    vi.mocked(useHealthGorillaLabOrder).mockReturnValue(mockLabOrderReturn);
+
+    setup();
+
+    const submitButton = screen.getByRole('button', { name: 'Submit Order' });
+
+    await act(async () => {
+      fireEvent.click(submitButton);
+    });
+
+    await waitFor(() => {
+      expect(notifications.showErrorNotification).toHaveBeenCalledWith(error);
+    });
+
+    expect(showNotification).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: 'Lab Order Submitted',
+      })
+    );
+    expect(mockOnSubmitLabOrder).not.toHaveBeenCalled();
+  });
+
+  test('Shows error when bot execution fails', async () => {
+    const mockServiceRequest: ServiceRequest = {
+      resourceType: 'ServiceRequest',
+      id: 'order-123',
+      status: 'draft',
+    } as ServiceRequest;
+
+    const botError = new Error('Bot execution failed');
+    mockLabOrderReturn.createOrderBundle = vi.fn().mockResolvedValue({
+      serviceRequest: mockServiceRequest,
+    });
+    vi.mocked(useHealthGorillaLabOrder).mockReturnValue(mockLabOrderReturn);
+    vi.spyOn(medplum, 'executeBot').mockRejectedValue(botError);
+
+    setup();
+
+    const submitButton = screen.getByRole('button', { name: 'Submit Order' });
+
+    await act(async () => {
+      fireEvent.click(submitButton);
+    });
+
+    await waitFor(() => {
+      expect(notifications.showErrorNotification).toHaveBeenCalledWith(botError);
+    });
+
+    expect(showNotification).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: 'Lab Order Submitted',
+      })
+    );
+    expect(mockOnSubmitLabOrder).not.toHaveBeenCalled();
+  });
+
+  test('Disables submit button while submitting', async () => {
+    const mockServiceRequest: ServiceRequest = {
+      resourceType: 'ServiceRequest',
+      id: 'order-123',
+      status: 'draft',
+    } as ServiceRequest;
+
+    let resolveCreateOrder: (() => void) | undefined;
+    const createOrderPromise = new Promise<{ serviceRequest: ServiceRequest }>((resolve) => {
+      resolveCreateOrder = () => resolve({ serviceRequest: mockServiceRequest });
+    });
+
+    mockLabOrderReturn.createOrderBundle = vi.fn().mockReturnValue(createOrderPromise);
+    vi.mocked(useHealthGorillaLabOrder).mockReturnValue(mockLabOrderReturn);
+    vi.spyOn(medplum, 'executeBot').mockResolvedValue({});
+
+    setup();
+
+    const submitButton = screen.getByRole('button', { name: 'Submit Order' });
+
+    // Click button to start submission
+    fireEvent.click(submitButton);
+
+    // Wait for button to be disabled
+    await waitFor(() => {
+      expect(submitButton).toBeDisabled();
+    });
+
+    resolveCreateOrder?.();
+
+    await createOrderPromise;
+
+    // Wait for button to be enabled again
+    await waitFor(
+      () => {
+        expect(submitButton).not.toBeDisabled();
+      },
+      { timeout: 2000 }
+    );
+  });
+
+  test('Renders specimen collection date time input', () => {
+    setup();
+
+    expect(screen.getByText('Specimen collection time')).toBeInTheDocument();
+    expect(screen.getByText('Specimen collection time')).toBeInTheDocument();
+  });
+});

package/dist/examples/vintasend-medplum-example/src/pages/labs/OrderLabsPage.tsx

@@ -0,0 +1,275 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Button, Container, Group, Input, Radio, Stack, TextInput } from '@mantine/core';
+import { ContentType, createReference } from '@medplum/core';
+import type { MedplumClient } from '@medplum/core';
+import type { Encounter, Patient, Practitioner, Reference, ServiceRequest, Task } from '@medplum/fhirtypes';
+import { NPI_SYSTEM } from '@medplum/health-gorilla-core';
+import type {
+  BillingInformation,
+  DiagnosisCodeableConcept,
+  LabOrderInputErrors,
+  LabOrganization,
+  TestCoding,
+} from '@medplum/health-gorilla-core';
+import { HealthGorillaLabOrderProvider, useHealthGorillaLabOrder } from '@medplum/health-gorilla-react';
+import {
+  AsyncAutocomplete,
+  DateTimeInput,
+  Panel,
+  ResourceInput,
+  useMedplum,
+  useResource,
+  ValueSetAutocomplete,
+} from '@medplum/react';
+import type { AsyncAutocompleteOption } from '@medplum/react';
+import { PerformingLabInput } from '../../components/PerformingLabInput';
+import { TestMetadataCardInput } from '../../components/labs/TestMetadataCardInput';
+import { CoverageInput } from '../../components/labs/CoverageInput';
+import { useState, useEffect, useRef } from 'react';
+import type { JSX } from 'react';
+import { useParams } from 'react-router';
+import { showErrorNotification } from '../../utils/notifications';
+import { showNotification } from '@mantine/notifications';
+
+async function sendLabOrderToHealthGorilla(medplum: MedplumClient, labOrder: ServiceRequest): Promise<void> {
+  return medplum.executeBot(
+    {
+      system: 'https://www.medplum.com/integrations/bot-identifier',
+      value: 'health-gorilla-labs/send-to-health-gorilla',
+    },
+    labOrder,
+    ContentType.FHIR_JSON
+  );
+}
+
+export interface OrderLabsPageProps {
+  encounter?: Encounter | Reference<Encounter> | undefined;
+  task?: Task | Reference<Task> | undefined;
+  tests?: TestCoding[] | undefined;
+  performingLab?: LabOrganization | undefined;
+  onSubmitLabOrder: (serviceRequest?: ServiceRequest) => void;
+}
+
+export function OrderLabsPage(props: OrderLabsPageProps): JSX.Element {
+  const { encounter, task, tests, performingLab, onSubmitLabOrder } = props;
+  const medplum = useMedplum();
+  const { patientId } = useParams();
+  const [patient, setPatient] = useState<Patient | undefined>();
+  const [requester, setRequester] = useState<Practitioner | undefined>(medplum.getProfile() as Practitioner);
+  const encounterResource = useResource(encounter);
+  const taskResource = useResource(task);
+  const labOrderReturn = useHealthGorillaLabOrder({
+    patient,
+    requester,
+  });
+
+  const {
+    state,
+    searchAvailableTests,
+    setTests,
+    setDiagnoses,
+    updateBillingInformation,
+    setSpecimenCollectedDateTime,
+    setOrderNotes,
+    createOrderBundle,
+  } = labOrderReturn;
+
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [createError, setCreateError] = useState<{ generic?: unknown; validation?: LabOrderInputErrors } | undefined>();
+  const prevTestsRef = useRef<TestCoding[] | undefined>(undefined);
+
+  useEffect(() => {
+    // Only set tests if they're provided and different from the previous value
+    // Compare by checking if arrays have different lengths or different test codes
+    const testsChanged =
+      tests &&
+      (prevTestsRef.current?.length !== tests.length ||
+        prevTestsRef.current.some((prevTest, index) => prevTest.code !== tests[index]?.code));
+
+    if (testsChanged) {
+      setTests(tests);
+      prevTestsRef.current = tests;
+    }
+  }, [tests, setTests]);
+
+  useEffect(() => {
+    if (patientId) {
+      medplum
+        .readResource('Patient', patientId)
+        .then((patient) => {
+          setPatient(patient);
+        })
+        .catch((error) => {
+          showErrorNotification(error);
+        });
+    }
+  }, [patientId, medplum]);
+
+  const submitOrder = async (): Promise<void> => {
+    try {
+      setIsSubmitting(true);
+      setCreateError(undefined);
+      let { serviceRequest } = await createOrderBundle();
+      if (encounterResource) {
+        serviceRequest = {
+          ...serviceRequest,
+          encounter: createReference(encounterResource),
+        };
+      }
+      if (taskResource) {
+        await medplum.updateResource({
+          ...taskResource,
+          output: [
+            ...(taskResource.output || []),
+            {
+              type: { text: 'ServiceRequest' },
+              valueReference: createReference(serviceRequest),
+            },
+          ],
+          focus: createReference(serviceRequest),
+        });
+      }
+      await sendLabOrderToHealthGorilla(medplum, serviceRequest);
+
+      showNotification({
+        title: 'Lab Order Submitted',
+        message: 'The lab order has been successfully submitted.',
+        color: 'green',
+      });
+      onSubmitLabOrder({ ...serviceRequest, status: 'active' });
+    } catch (error) {
+      setCreateError({ generic: error });
+      showErrorNotification(error);
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+
+  return (
+    <HealthGorillaLabOrderProvider {...labOrderReturn}>
+      <Container size="md">
+        <Panel>
+          <Stack gap="md">
+            <Input.Wrapper label="Requester" required error={createError?.validation?.requester?.message}>
+              <ResourceInput<Practitioner>
+                resourceType="Practitioner"
+                name="Requester"
+                onChange={setRequester}
+                defaultValue={requester}
+                searchCriteria={{ identifier: `${NPI_SYSTEM}|` }}
+              />
+            </Input.Wrapper>
+            <Input.Wrapper label="Patient" required error={createError?.validation?.patient?.message}>
+              <ResourceInput<Patient>
+                resourceType="Patient"
+                name="patient"
+                defaultValue={patient}
+                onChange={setPatient}
+              />
+            </Input.Wrapper>
+            <PerformingLabInput
+              patient={patient}
+              performingLab={performingLab}
+              error={createError?.validation?.performingLab}
+            />
+            <div>
+              <AsyncAutocomplete<TestCoding>
+                required
+                error={createError?.validation?.selectedTests?.message}
+                label="Selected tests"
+                disabled={!state.performingLab}
+                maxValues={10}
+                defaultValue={tests}
+                loadOptions={searchAvailableTests}
+                toOption={TestCodingToOption}
+                onChange={setTests}
+              />
+              {state.selectedTests.length > 0 && (
+                <Group mt="md" gap="md" align="flex-start" wrap="wrap">
+                  {state.selectedTests.map((test: TestCoding) => (
+                    <TestMetadataCardInput
+                      key={test.code}
+                      test={test}
+                      metadata={state.testMetadata[test.code]}
+                      error={createError?.validation?.testMetadata?.[test.code]}
+                    />
+                  ))}
+                </Group>
+              )}
+            </div>
+            <div>
+              <ValueSetAutocomplete
+                label="Diagnoses"
+                binding="http://hl7.org/fhir/sid/icd-10-cm/vs"
+                name="diagnoses"
+                maxValues={10}
+                onChange={(items) => {
+                  const codeableConcepts = items.map((item) => ({ coding: [item] })) as DiagnosisCodeableConcept[];
+                  setDiagnoses(codeableConcepts);
+                }}
+              />
+            </div>
+            <Group align="flex-start" gap={48}>
+              <div>
+                <Radio.Group
+                  value={state.billingInformation.billTo}
+                  error={createError?.validation?.billingInformation?.billTo?.message}
+                  onChange={(newBillTo) => {
+                    updateBillingInformation({ billTo: newBillTo as BillingInformation['billTo'] });
+                  }}
+                  label="Bill to"
+                  withAsterisk
+                >
+                  <Stack gap={4}>
+                    <Radio value="patient" label="Patient" />
+                    <Radio value="insurance" label="Insurance" />
+                    <Radio value="customer-account" label="Customer" />
+                  </Stack>
+                </Radio.Group>
+              </div>
+              {patient && (
+                <CoverageInput patient={patient} error={createError?.validation?.billingInformation?.patientCoverage} />
+              )}
+            </Group>
+            <TextInput label="Order notes" onChange={(e) => setOrderNotes(e.currentTarget.value)} />
+            <DateTimeInput
+              label="Specimen collection time"
+              name=""
+              onChange={(isoDateTimeString) => {
+                setSpecimenCollectedDateTime(isoDateTimeString ? new Date(isoDateTimeString) : undefined);
+              }}
+            />
+            <Group>
+              <Button onClick={submitOrder} loading={isSubmitting} disabled={isSubmitting}>
+                Submit Order
+              </Button>
+            </Group>
+          </Stack>
+        </Panel>
+      </Container>
+    </HealthGorillaLabOrderProvider>
+  );
+}
+
+function TestCodingToOption(element: TestCoding): AsyncAutocompleteOption<TestCoding> {
+  return {
+    value: toKey(element),
+    label: getDisplay(element),
+    resource: element,
+  };
+}
+
+function toKey(element: TestCoding): string {
+  if (typeof element.code === 'string') {
+    return element.code;
+  }
+  return JSON.stringify(element);
+}
+
+function getDisplay(item: TestCoding): string {
+  if (typeof item.display === 'string') {
+    return item.display;
+  }
+  return toKey(item);
+}

package/dist/examples/vintasend-medplum-example/src/pages/messages/MessagesPage.module.css

@@ -0,0 +1,8 @@
+.container {
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
+  height: calc(100vh - var(--app-shell-header-height, 0));
+  overflow: hidden;
+  flex: 1;
+}