@openmrs/esm-patient-orders-app 11.3.1-patch.9310 → 11.3.1-patch.9508

package/src/order-basket/general-order-type/{add-general-order/add-general-order.component.tsx → orderable-concept-search/orderable-concept-search.workspace.tsx}

@@ -1,40 +1,53 @@
-import React, { type ComponentProps, useCallback, useMemo, useRef, useState } from 'react';
+import React, { type ComponentProps, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Button, Search } from '@carbon/react';
 import { useTranslation } from 'react-i18next';
 import {
   ArrowLeftIcon,
+  launchWorkspace,
   ResponsiveWrapper,
   useConfig,
   useDebounce,
   useLayoutType,
-  type Visit,
-  Workspace2,
-  type Workspace2DefinitionProps,
+  type DefaultWorkspaceProps,
 } from '@openmrs/esm-framework';
-import { type OrderBasketItem, useOrderBasket, useOrderType } from '@openmrs/esm-patient-common-lib';
+import {
+  type DefaultPatientWorkspaceProps,
+  type OrderBasketItem,
+  useOrderBasket,
+  useOrderType,
+} from '@openmrs/esm-patient-common-lib';
 import { OrderForm } from '../general-order-form/general-order-form.component';
 import { prepOrderPostData } from '../resources';
 import { type ConfigObject } from '../../../config-schema';
 import OrderableConceptSearchResults from './search-results.component';
 import styles from './orderable-concept-search.scss';
 
-interface AddGeneralOrderProps {
-  initialOrder: OrderBasketItem;
+interface OrderableConceptSearchWorkspaceProps extends DefaultPatientWorkspaceProps {
+  order: OrderBasketItem;
   orderTypeUuid: string;
-  patient: fhir.Patient;
-  visitContext: Visit;
-  closeWorkspace: Workspace2DefinitionProps['closeWorkspace'];
+  orderableConceptClasses: Array<string>;
+  orderableConceptSets: Array<string>;
+}
+
+export const careSettingUuid = '6f0c9a92-6f24-11e3-af88-005056821db0';
+
+type DrugsOrOrders = Pick<OrderBasketItem, 'action' | 'concept'>;
+
+export function ordersEqual(order1: DrugsOrOrders, order2: DrugsOrOrders) {
+  return order1.action === order2.action && order1.concept.uuid === order2.concept.uuid;
 }
 
-/**
- * This workspace displays the drug order form for adding or editing a general order.
- */
-const AddGeneralOrder: React.FC<AddGeneralOrderProps> = ({
-  initialOrder,
+const OrderableConceptSearchWorkspace: React.FC<OrderableConceptSearchWorkspaceProps> = ({
+  order: initialOrder,
   orderTypeUuid,
+  closeWorkspace,
+  closeWorkspaceWithSavedChanges,
+  promptBeforeClosing,
+  setTitle,
+  patientUuid,
   patient,
   visitContext,
-  closeWorkspace,
+  mutateVisitContext,
 }) => {
   const { t } = useTranslation();
   const isTablet = useLayoutType() === 'tablet';
@@ -42,23 +55,16 @@ const AddGeneralOrder: React.FC<AddGeneralOrderProps> = ({
   const { orderTypes } = useConfig<ConfigObject>();
   const [currentOrder, setCurrentOrder] = useState(initialOrder);
   const { orderType } = useOrderType(orderTypeUuid);
-  const [hasUnsavedChanges, setHasUnsavedChanges] = useState(false);
 
-  const title = useMemo(() => {
+  useEffect(() => {
     if (orderType) {
-      if (initialOrder?.action == 'REVISE') {
-        return t(`editOrderableForOrderType`, 'Edit {{orderTypeDisplay}}', {
+      setTitle(
+        t(`addOrderableForOrderType`, 'Add {{orderTypeDisplay}}', {
           orderTypeDisplay: orderType.display.toLocaleLowerCase(),
-        });
-      } else {
-        return t(`addOrderableForOrderType`, 'Add {{orderTypeDisplay}}', {
-          orderTypeDisplay: orderType.display.toLocaleLowerCase(),
-        });
-      }
-    } else {
-      return '';
+        }),
+      );
     }
-  }, [orderType, t, initialOrder?.action]);
+  }, [orderType, t, setTitle]);
 
   const orderableConceptSets = useMemo(
     () => orderTypes.find((orderType) => orderType.orderTypeUuid === orderTypeUuid).orderableConceptSets,
@@ -66,7 +72,10 @@ const AddGeneralOrder: React.FC<AddGeneralOrderProps> = ({
   );
 
   const cancelDrugOrder = useCallback(() => {
-    closeWorkspace();
+    closeWorkspace({
+      onWorkspaceClose: () => launchWorkspace('order-basket'),
+      closeWorkspaceGroup: false,
+    });
   }, [closeWorkspace]);
 
   const openOrderForm = useCallback(
@@ -82,51 +91,53 @@ const AddGeneralOrder: React.FC<AddGeneralOrderProps> = ({
   );
 
   return (
-    <Workspace2 title={title} hasUnsavedChanges={hasUnsavedChanges}>
-      <div className={styles.workspaceWrapper}>
-        {!isTablet && (
-          <div className={styles.backButton}>
-            <Button
-              iconDescription="Return to order basket"
-              kind="ghost"
-              onClick={cancelDrugOrder}
-              renderIcon={(props: ComponentProps<typeof ArrowLeftIcon>) => <ArrowLeftIcon size={24} {...props} />}
-              size="sm"
-            >
-              <span>{t('backToOrderBasket', 'Back to order basket')}</span>
-            </Button>
-          </div>
-        )}
-        {currentOrder ? (
-          <OrderForm
-            initialOrder={currentOrder}
-            closeWorkspace={closeWorkspace}
-            setHasUnsavedChanges={setHasUnsavedChanges}
-            orderTypeUuid={orderTypeUuid}
-            patient={patient}
-          />
-        ) : (
-          <ConceptSearch
-            openOrderForm={openOrderForm}
-            closeWorkspace={closeWorkspace}
-            orderableConceptSets={orderableConceptSets}
-            orderTypeUuid={orderTypeUuid}
-            patient={patient}
-            visit={visitContext}
-          />
-        )}
-      </div>
-    </Workspace2>
+    <div className={styles.workspaceWrapper}>
+      {!isTablet && (
+        <div className={styles.backButton}>
+          <Button
+            iconDescription="Return to order basket"
+            kind="ghost"
+            onClick={cancelDrugOrder}
+            renderIcon={(props: ComponentProps<typeof ArrowLeftIcon>) => <ArrowLeftIcon size={24} {...props} />}
+            size="sm"
+          >
+            <span>{t('backToOrderBasket', 'Back to order basket')}</span>
+          </Button>
+        </div>
+      )}
+      {currentOrder ? (
+        <OrderForm
+          initialOrder={currentOrder}
+          closeWorkspace={closeWorkspace}
+          closeWorkspaceWithSavedChanges={closeWorkspaceWithSavedChanges}
+          promptBeforeClosing={promptBeforeClosing}
+          orderTypeUuid={orderTypeUuid}
+          orderableConceptSets={orderableConceptSets}
+          patientUuid={patientUuid}
+          patient={patient}
+          visitContext={visitContext}
+          mutateVisitContext={mutateVisitContext}
+          setTitle={() => {}}
+        />
+      ) : (
+        <ConceptSearch
+          openOrderForm={openOrderForm}
+          closeWorkspace={closeWorkspace}
+          orderableConceptSets={orderableConceptSets}
+          orderTypeUuid={orderTypeUuid}
+          patient={patient}
+        />
+      )}
+    </div>
   );
 };
 
 interface ConceptSearchProps {
-  closeWorkspace: Workspace2DefinitionProps['closeWorkspace'];
+  closeWorkspace: DefaultWorkspaceProps['closeWorkspace'];
   openOrderForm: (search: OrderBasketItem) => void;
   orderTypeUuid: string;
   orderableConceptSets: Array<string>;
   patient: fhir.Patient;
-  visit: Visit;
 }
 
 function ConceptSearch({
@@ -135,7 +146,6 @@ function ConceptSearch({
   openOrderForm,
   orderableConceptSets,
   patient,
-  visit,
 }: ConceptSearchProps) {
   const { t } = useTranslation();
   const { orderType } = useOrderType(orderTypeUuid);
@@ -145,7 +155,9 @@ function ConceptSearch({
   const searchInputRef = useRef(null);
 
   const cancelDrugOrder = useCallback(() => {
-    closeWorkspace();
+    closeWorkspace({
+      onWorkspaceClose: () => launchWorkspace('order-basket'),
+    });
   }, [closeWorkspace]);
 
   const focusAndClearSearchInput = () => {
@@ -179,12 +191,11 @@ function ConceptSearch({
         searchTerm={debouncedSearchTerm}
         openOrderForm={openOrderForm}
         focusAndClearSearchInput={focusAndClearSearchInput}
+        closeWorkspace={closeWorkspace}
         orderTypeUuid={orderTypeUuid}
         cancelOrder={() => {}}
         orderableConceptSets={orderableConceptSets}
-        closeWorkspace={closeWorkspace}
         patient={patient}
-        visit={visit}
       />
       {isTablet && (
         <div className={styles.separatorContainer}>
@@ -198,10 +209,4 @@ function ConceptSearch({
   );
 }
 
-type DrugsOrOrders = Pick<OrderBasketItem, 'action' | 'concept'>;
-
-function ordersEqual(order1: DrugsOrOrders, order2: DrugsOrOrders) {
-  return order1.action === order2.action && order1.concept.uuid === order2.concept.uuid;
-}
-
-export default AddGeneralOrder;
+export default OrderableConceptSearchWorkspace;

package/src/order-basket/general-order-type/{add-general-order → orderable-concept-search}/search-results.component.tsx

@@ -4,12 +4,12 @@ import { ShoppingCartArrowUp } from '@carbon/react/icons';
 import { Tile, Button, SkeletonText, ButtonSkeleton } from '@carbon/react';
 import { useTranslation } from 'react-i18next';
 import {
-  type Workspace2DefinitionProps,
   ArrowRightIcon,
+  type DefaultWorkspaceProps,
   ShoppingCartArrowDownIcon,
   useLayoutType,
   useSession,
-  type Visit,
+  launchWorkspace,
 } from '@openmrs/esm-framework';
 import {
   useOrderBasket,
@@ -27,9 +27,8 @@ interface OrderableConceptSearchResultsProps {
   cancelOrder: () => void;
   orderableConceptSets: Array<string>;
   orderTypeUuid: string;
-  closeWorkspace: Workspace2DefinitionProps['closeWorkspace'];
+  closeWorkspace: DefaultWorkspaceProps['closeWorkspace'];
   patient: fhir.Patient;
-  visit: Visit;
 }
 
 const OrderableConceptSearchResults: React.FC<OrderableConceptSearchResultsProps> = ({
@@ -41,7 +40,6 @@ const OrderableConceptSearchResults: React.FC<OrderableConceptSearchResultsProps
   orderTypeUuid,
   closeWorkspace,
   patient,
-  visit,
 }) => {
   const { t } = useTranslation();
   const isTablet = useLayoutType() === 'tablet';
@@ -94,7 +92,6 @@ const OrderableConceptSearchResults: React.FC<OrderableConceptSearchResultsProps
                 orderTypeUuid={orderTypeUuid}
                 closeWorkspace={closeWorkspace}
                 patient={patient}
-                visit={visit}
               />
             ))}
           </div>
@@ -159,9 +156,8 @@ interface TestTypeSearchResultItemProps {
   concept: OrderableConcept;
   openOrderForm: (searchResult: OrderBasketItem) => void;
   orderTypeUuid: string;
-  closeWorkspace: Workspace2DefinitionProps['closeWorkspace'];
+  closeWorkspace: DefaultWorkspaceProps['closeWorkspace'];
   patient: fhir.Patient;
-  visit: Visit;
 }
 
 const TestTypeSearchResultItem: React.FC<TestTypeSearchResultItemProps> = ({
@@ -170,7 +166,6 @@ const TestTypeSearchResultItem: React.FC<TestTypeSearchResultItemProps> = ({
   orderTypeUuid,
   closeWorkspace,
   patient,
-  visit,
 }) => {
   const { t } = useTranslation();
   const isTablet = useLayoutType() === 'tablet';
@@ -183,18 +178,22 @@ const TestTypeSearchResultItem: React.FC<TestTypeSearchResultItemProps> = ({
   );
 
   const createOrderBasketItem = useCallback(
-    (testType: OrderableConcept, visit: Visit) => {
-      return createEmptyOrder(testType, session.currentProvider?.uuid, visit);
+    (testType: OrderableConcept) => {
+      return createEmptyOrder(testType, session.currentProvider?.uuid);
     },
     [session.currentProvider.uuid],
   );
 
   const addToBasket = useCallback(() => {
-    const orderBasketItem = createOrderBasketItem(concept, visit);
+    const orderBasketItem = createOrderBasketItem(concept);
     orderBasketItem.isOrderIncomplete = true;
     setOrders([...orders, orderBasketItem]);
-    closeWorkspace({ discardUnsavedChanges: true });
-  }, [orders, setOrders, createOrderBasketItem, concept, closeWorkspace, visit]);
+    closeWorkspace({
+      ignoreChanges: true,
+      onWorkspaceClose: () => launchWorkspace('order-basket'),
+      closeWorkspaceGroup: false,
+    });
+  }, [orders, setOrders, createOrderBasketItem, concept, closeWorkspace]);
 
   const removeFromBasket = useCallback(() => {
     setOrders(orders.filter((order) => order?.concept?.uuid !== concept?.uuid));
@@ -233,7 +232,7 @@ const TestTypeSearchResultItem: React.FC<TestTypeSearchResultItemProps> = ({
         <Button
           kind="ghost"
           renderIcon={(props: ComponentProps<typeof ArrowRightIcon>) => <ArrowRightIcon size={16} {...props} />}
-          onClick={() => openOrderForm(createOrderBasketItem(concept, visit))}
+          onClick={() => openOrderForm(createOrderBasketItem(concept))}
         >
           {t('goToDrugOrderForm', 'Order form')}
         </Button>

package/src/order-basket/general-order-type/resources.ts

@@ -1,4 +1,4 @@
-import { toOmrsIsoString, type Visit } from '@openmrs/esm-framework';
+import { toOmrsIsoString } from '@openmrs/esm-framework';
 import {
   type OrderBasketItem,
   priorityOptions,
@@ -7,14 +7,13 @@ import {
   type OrderableConcept,
 } from '@openmrs/esm-patient-common-lib';
 
-export function createEmptyOrder(concept: OrderableConcept, orderer: string, visit: Visit): OrderBasketItem {
+export function createEmptyOrder(concept: OrderableConcept, orderer: string): OrderBasketItem {
   return {
     action: 'NEW',
     urgency: priorityOptions[0].value as OrderUrgency,
     display: concept.display,
     concept,
     orderer,
-    visit,
   };
 }
 

package/src/order-basket/order-basket.workspace.tsx

@@ -1,46 +1,262 @@
-import React, { useMemo } from 'react';
+import React, { useCallback, useEffect, useState } from 'react';
+import classNames from 'classnames';
+import { useTranslation } from 'react-i18next';
+import type { TFunction } from 'i18next';
+import { ActionableNotification, Button, ButtonSet, InlineLoading, InlineNotification } from '@carbon/react';
 import {
-  type OrderBasketExtensionProps,
-  type OrderBasketWindowProps,
+  ExtensionSlot,
+  showModal,
+  showSnackbar,
+  useConfig,
+  useLayoutType,
+  useSession,
+  type Visit,
+} from '@openmrs/esm-framework';
+import {
+  type DefaultPatientWorkspaceProps,
   type OrderBasketItem,
-  type PatientWorkspace2DefinitionProps,
+  invalidateVisitAndEncounterData,
+  postOrders,
+  postOrdersOnNewEncounter,
+  useOrderBasket,
 } from '@openmrs/esm-patient-common-lib';
-import OrderBasket from './order-basket.component';
+import { useSWRConfig } from 'swr';
+import { type ConfigObject } from '../config-schema';
+import { useMutatePatientOrders, useOrderEncounter } from '../api/api';
+import GeneralOrderType from './general-order-type/general-order-type.component';
+import styles from './order-basket.scss';
+
+interface OrderBasketSlotProps {
+  patientUuid: string;
+  patient: fhir.Patient;
+  visitContext: Visit;
+  mutateVisitContext: () => void;
+}
 
-const OrderBasketWorkspace: React.FC<PatientWorkspace2DefinitionProps<{}, OrderBasketWindowProps>> = ({
-  groupProps: { patientUuid, patient, visitContext, mutateVisitContext },
+const OrderBasket: React.FC<DefaultPatientWorkspaceProps> = ({
+  patientUuid,
+  patient,
   closeWorkspace,
-  launchChildWorkspace,
+  closeWorkspaceWithSavedChanges,
+  promptBeforeClosing,
+  visitContext,
+  mutateVisitContext,
 }) => {
-  const orderBasketExtensionProps = useMemo(() => {
-    const launchDrugOrderForm = (order: OrderBasketItem) => {
-      launchChildWorkspace('add-drug-order', { order });
-    };
-    const launchLabOrderForm = (orderTypeUuid: string, order: OrderBasketItem) => {
-      launchChildWorkspace('add-lab-order', { orderTypeUuid, order });
-    };
-    const launchGeneralOrderForm = (orderTypeUuid: string, order: OrderBasketItem) => {
-      launchChildWorkspace('orderable-concept-workspace', { orderTypeUuid, order });
-    };
-
-    return {
-      patient,
-      launchDrugOrderForm,
-      launchLabOrderForm,
-      launchGeneralOrderForm,
-    } satisfies OrderBasketExtensionProps;
-  }, [launchChildWorkspace, patient]);
+  const { t } = useTranslation();
+  const isTablet = useLayoutType() === 'tablet';
+  const config = useConfig<ConfigObject>();
+  const session = useSession();
+  const { orders, clearOrders } = useOrderBasket(patient);
+  const [ordersWithErrors, setOrdersWithErrors] = useState<OrderBasketItem[]>([]);
+  const {
+    visitRequired,
+    isLoading: isLoadingEncounterUuid,
+    encounterUuid,
+    error: errorFetchingEncounterUuid,
+    mutate: mutateEncounterUuid,
+  } = useOrderEncounter(patientUuid, visitContext, mutateVisitContext, config.orderEncounterType);
+  const [isSavingOrders, setIsSavingOrders] = useState(false);
+  const [creatingEncounterError, setCreatingEncounterError] = useState('');
+  const { mutate: mutateOrders } = useMutatePatientOrders(patientUuid);
+  const { mutate } = useSWRConfig();
+
+  useEffect(() => {
+    promptBeforeClosing(() => !!orders.length);
+  }, [orders, promptBeforeClosing]);
+
+  const openStartVisitDialog = useCallback(() => {
+    const dispose = showModal('start-visit-dialog', {
+      patientUuid,
+      closeModal: () => dispose(),
+    });
+  }, [patientUuid]);
+
+  const handleSave = useCallback(async () => {
+    const abortController = new AbortController();
+    setCreatingEncounterError('');
+    let orderEncounterUuid = encounterUuid;
+    setIsSavingOrders(true);
+    // If there's no encounter present, create an encounter along with the orders.
+    if (!orderEncounterUuid) {
+      try {
+        await postOrdersOnNewEncounter(
+          patientUuid,
+          config?.orderEncounterType,
+          visitRequired ? visitContext : null,
+          session?.sessionLocation?.uuid,
+          abortController,
+        );
+        mutateEncounterUuid();
+        // Only revalidate current visit since orders create new encounters
+        mutateVisitContext?.();
+        clearOrders();
+        await mutateOrders();
+
+        closeWorkspaceWithSavedChanges();
+        showOrderSuccessToast(t, orders);
+      } catch (e) {
+        console.error(e);
+        setCreatingEncounterError(
+          e.responseBody?.error?.message ||
+            t('tryReopeningTheWorkspaceAgain', 'Please try launching the workspace again'),
+        );
+      }
+    } else {
+      const erroredItems = await postOrders(patientUuid, orderEncounterUuid, abortController);
+      clearOrders({ exceptThoseMatching: (item) => erroredItems.map((e) => e.display).includes(item.display) });
+      // Only revalidate current visit since orders create new encounters
+      mutateVisitContext?.();
+      await mutateOrders();
+      invalidateVisitAndEncounterData(mutate, patientUuid);
+
+      if (erroredItems.length == 0) {
+        closeWorkspaceWithSavedChanges();
+        showOrderSuccessToast(t, orders);
+      } else {
+        setOrdersWithErrors(erroredItems);
+      }
+    }
+    setIsSavingOrders(false);
+    return () => abortController.abort();
+  }, [
+    visitContext,
+    visitRequired,
+    clearOrders,
+    closeWorkspaceWithSavedChanges,
+    config,
+    encounterUuid,
+    mutateEncounterUuid,
+    mutateOrders,
+    mutateVisitContext,
+    orders,
+    patientUuid,
+    session,
+    t,
+    mutate,
+  ]);
+
+  const handleCancel = useCallback(() => {
+    closeWorkspace({ onWorkspaceClose: clearOrders });
+  }, [clearOrders, closeWorkspace]);
+
+  const extensionProps = {
+    patientUuid,
+    patient,
+    visitContext,
+    mutateVisitContext,
+  } satisfies OrderBasketSlotProps;
 
   return (
-    <OrderBasket
-      patientUuid={patientUuid}
-      patient={patient}
-      visitContext={visitContext}
-      mutateVisitContext={mutateVisitContext}
-      closeWorkspace={closeWorkspace}
-      orderBasketExtensionProps={orderBasketExtensionProps}
-    />
+    <>
+      <div className={styles.container}>
+        <ExtensionSlot name="visit-context-header-slot" state={extensionProps} />
+        <div className={styles.orderBasketContainer}>
+          <ExtensionSlot
+            className={classNames(styles.orderBasketSlot, {
+              [styles.orderBasketSlotTablet]: isTablet,
+            })}
+            name="order-basket-slot"
+            state={extensionProps}
+          />
+          {config?.orderTypes?.length > 0 &&
+            config.orderTypes.map((orderType) => (
+              <div className={styles.orderPanel} key={orderType.orderTypeUuid}>
+                <GeneralOrderType
+                  key={orderType.orderTypeUuid}
+                  orderTypeUuid={orderType.orderTypeUuid}
+                  label={orderType.label}
+                  orderableConceptSets={orderType.orderableConceptSets}
+                  closeWorkspace={closeWorkspace}
+                  patient={patient}
+                />
+              </div>
+            ))}
+        </div>
+
+        <div>
+          {(creatingEncounterError || errorFetchingEncounterUuid) && (
+            <InlineNotification
+              kind="error"
+              title={t('tryReopeningTheWorkspaceAgain', 'Please try launching the workspace again')}
+              subtitle={creatingEncounterError}
+              lowContrast={true}
+              className={styles.inlineNotification}
+            />
+          )}
+          {ordersWithErrors.map((order) => (
+            <InlineNotification
+              lowContrast
+              kind="error"
+              title={t('saveDrugOrderFailed', 'Error ordering {{orderName}}', { orderName: order.display })}
+              subtitle={order.extractedOrderError?.fieldErrors?.join(', ')}
+              className={styles.inlineNotification}
+            />
+          ))}
+          <ButtonSet className={styles.buttonSet}>
+            <Button className={styles.actionButton} kind="secondary" onClick={handleCancel}>
+              {t('cancel', 'Cancel')}
+            </Button>
+            <Button
+              className={styles.actionButton}
+              kind="primary"
+              onClick={handleSave}
+              disabled={
+                isSavingOrders ||
+                !orders?.length ||
+                isLoadingEncounterUuid ||
+                (visitRequired && !visitContext) ||
+                orders?.some(({ isOrderIncomplete }) => isOrderIncomplete)
+              }
+            >
+              {isSavingOrders ? (
+                <InlineLoading description={t('saving', 'Saving') + '...'} />
+              ) : (
+                <span>{t('signAndClose', 'Sign and close')}</span>
+              )}
+            </Button>
+          </ButtonSet>
+        </div>
+      </div>
+      {visitRequired && !visitContext && (
+        <ActionableNotification
+          kind="error"
+          actionButtonLabel={t('startVisit', 'Start visit')}
+          onActionButtonClick={openStartVisitDialog}
+          title={t('startAVisitToRecordOrders', 'Start a visit to order')}
+          subtitle={t('visitRequired', 'You must select a visit to make orders')}
+          lowContrast={true}
+          inline
+          className={styles.actionNotification}
+          hasFocus
+        />
+      )}
+    </>
   );
 };
 
-export default OrderBasketWorkspace;
+function showOrderSuccessToast(t: TFunction, patientOrderItems: OrderBasketItem[]) {
+  const orderedString = patientOrderItems
+    .filter((item) => ['NEW', 'RENEW'].includes(item.action))
+    .map((item) => item.display)
+    .join(', ');
+  const updatedString = patientOrderItems
+    .filter((item) => item.action === 'REVISE')
+    .map((item) => item.display)
+    .join(', ');
+  const discontinuedString = patientOrderItems
+    .filter((item) => item.action === 'DISCONTINUE')
+    .map((item) => item.display)
+    .join(', ');
+
+  showSnackbar({
+    isLowContrast: true,
+    kind: 'success',
+    title: t('orderCompleted', 'Placed orders'),
+    subtitle:
+      (orderedString && `${t('ordered', 'Placed order for')} ${orderedString}. `) +
+      (updatedString && `${t('updated', 'Updated')} ${updatedString}. `) +
+      (discontinuedString && `${t('discontinued', 'Discontinued')} ${discontinuedString}.`),
+  });
+}
+
+export default OrderBasket;