@openmrs/esm-patient-tests-app 11.3.1-pre.9447 → 11.3.1-pre.9455

package/src/test-orders/add-test-order/test-order-form.component.tsx

@@ -19,35 +19,35 @@ import { zodResolver } from '@hookform/resolvers/zod';
 import { z } from 'zod';
 import { useTranslation } from 'react-i18next';
 import {
-  type DefaultPatientWorkspaceProps,
-  type Order,
   type OrderUrgency,
   priorityOptions,
   useOrderBasket,
   useOrderType,
+  type TestOrderBasketItem,
+  postOrder,
+  useMutatePatientOrders,
+  showOrderSuccessToast,
 } from '@openmrs/esm-patient-common-lib';
 import {
   ExtensionSlot,
-  launchWorkspace,
   OpenmrsDatePicker,
+  showSnackbar,
   useConfig,
   useLayoutType,
   useSession,
+  type Workspace2DefinitionProps,
 } from '@openmrs/esm-framework';
 import { prepTestOrderPostData, useOrderReasons } from '../api';
 import { ordersEqual } from './test-order';
 import { type ConfigObject } from '../../config-schema';
-import { type TestOrderBasketItem } from '../../types';
-import { WORKSPACES } from '../lab-order-basket-panel/lab-order-basket-panel.extension';
 import styles from './test-order-form.scss';
 
-export interface LabOrderFormProps extends DefaultPatientWorkspaceProps {
+export interface LabOrderFormProps {
+  closeWorkspace: Workspace2DefinitionProps['closeWorkspace'];
   initialOrder: TestOrderBasketItem;
   orderTypeUuid: string;
   orderableConceptSets: Array<string>;
-  prevWorkSpace: string;
-  isWorkSpaceType: (value: string) => boolean;
-  prevOrder: Order;
+  setHasUnsavedChanges: (hasUnsavedChanges: boolean) => void;
   patient: fhir.Patient;
 }
 
@@ -57,25 +57,22 @@ export interface LabOrderFormProps extends DefaultPatientWorkspaceProps {
 export function LabOrderForm({
   initialOrder,
   closeWorkspace,
-  closeWorkspaceWithSavedChanges,
-  promptBeforeClosing,
   orderTypeUuid,
-  orderableConceptSets,
-  prevWorkSpace,
-  isWorkSpaceType,
-  prevOrder,
-  patientUuid,
+  setHasUnsavedChanges,
   patient,
 }: LabOrderFormProps) {
   const { t } = useTranslation();
   const isTablet = useLayoutType() === 'tablet';
   const session = useSession();
-  const isEditing = useMemo(() => initialOrder && initialOrder.action === 'REVISE', [initialOrder]);
-  const { orders, setOrders } = useOrderBasket<TestOrderBasketItem>(patient, orderTypeUuid, prepTestOrderPostData);
+  const { orders, setOrders, clearOrders } = useOrderBasket<TestOrderBasketItem>(
+    patient,
+    orderTypeUuid,
+    prepTestOrderPostData,
+  );
   const [showErrorNotification, setShowErrorNotification] = useState(false);
   const config = useConfig<ConfigObject>();
-  const { orderType, isLoadingOrderType } = useOrderType(orderTypeUuid);
-
+  const { orderType } = useOrderType(orderTypeUuid);
+  const { mutate: mutateOrders } = useMutatePatientOrders(patient.id);
   const orderReasonRequired = useMemo(
     () =>
       (config.labTestsWithOrderReasons?.find((c) => c.labTestUuid === initialOrder?.testType?.conceptUuid) || {})
@@ -147,7 +144,7 @@ export function LabOrderForm({
     return itemDisplay?.includes(inputValue);
   }, []);
 
-  const handleFormSubmission = useCallback(
+  const saveLabOrderToBasket = useCallback(
     (data: TestOrderBasketItem) => {
       const finalizedOrder: TestOrderBasketItem = {
         ...initialOrder,
@@ -170,40 +167,46 @@ export function LabOrderForm({
 
       setOrders(newOrders);
 
-      closeWorkspaceWithSavedChanges({
-        onWorkspaceClose: () =>
-          typeof isWorkSpaceType === 'function' &&
-          isWorkSpaceType(prevWorkSpace) &&
-          prevWorkSpace === WORKSPACES.TEST_RESULTS_FORM
-            ? launchWorkspace(prevWorkSpace, { order: prevOrder })
-            : launchWorkspace(WORKSPACES.ORDER_BASKET),
-        closeWorkspaceGroup: false,
-      });
+      closeWorkspace({ discardUnsavedChanges: true });
     },
-    [
-      orders,
-      setOrders,
-      session?.currentProvider?.uuid,
-      closeWorkspaceWithSavedChanges,
-      initialOrder,
-      isWorkSpaceType,
-      prevOrder,
-      prevWorkSpace,
-    ],
+    [orders, setOrders, session?.currentProvider?.uuid, closeWorkspace, initialOrder],
+  );
+
+  const submitLabOrderToServer = useCallback(
+    (data: TestOrderBasketItem) => {
+      const finalizedOrder: TestOrderBasketItem = {
+        ...initialOrder,
+        ...data,
+      };
+      finalizedOrder.orderer = session.currentProvider.uuid;
+      postOrder(prepTestOrderPostData(finalizedOrder, patient.id, finalizedOrder?.encounterUuid))
+        .then(() => {
+          clearOrders();
+          mutateOrders();
+          showOrderSuccessToast(t, [finalizedOrder]);
+          closeWorkspace({ discardUnsavedChanges: true });
+        })
+        .catch((error) => {
+          showSnackbar({
+            isLowContrast: false,
+            kind: 'error',
+            title: t('errorSavingLabOrder', 'Error saving lab order'),
+            subtitle: error.message,
+          });
+        });
+    },
+    [clearOrders, closeWorkspace, initialOrder, mutateOrders, patient.id, session.currentProvider.uuid, t],
   );
 
   const cancelOrder = useCallback(() => {
     setOrders(orders.filter((order) => order.testType.conceptUuid !== defaultValues.testType.conceptUuid));
-    closeWorkspace({
-      onWorkspaceClose: () =>
-        typeof isWorkSpaceType === 'function' &&
-        isWorkSpaceType(prevWorkSpace) &&
-        prevWorkSpace === WORKSPACES.TEST_RESULTS_FORM
-          ? launchWorkspace(prevWorkSpace, { order: prevOrder })
-          : launchWorkspace(WORKSPACES.ORDER_BASKET),
-      closeWorkspaceGroup: false,
-    });
-  }, [closeWorkspace, orders, setOrders, defaultValues, isWorkSpaceType, prevOrder, prevWorkSpace]);
+    closeWorkspace();
+  }, [closeWorkspace, orders, setOrders, defaultValues]);
+
+  const closeModifyOrderWorkspace = useCallback(() => {
+    clearOrders();
+    closeWorkspace();
+  }, [clearOrders, closeWorkspace]);
 
   const onError = (errors: FieldErrors<TestOrderBasketItem>) => {
     if (errors) {
@@ -225,19 +228,23 @@ export function LabOrderForm({
   );
 
   useEffect(() => {
-    promptBeforeClosing(() => isDirty);
-  }, [isDirty, promptBeforeClosing]);
+    setHasUnsavedChanges(isDirty);
+  }, [isDirty, setHasUnsavedChanges]);
 
   const responsiveSize = isTablet ? 'lg' : 'sm';
 
   return (
-    <Form className={styles.orderForm} onSubmit={handleSubmit(handleFormSubmission, onError)} id="drugOrderForm">
+    <Form
+      className={styles.orderForm}
+      onSubmit={handleSubmit(initialOrder?.action == 'REVISE' ? submitLabOrderToServer : saveLabOrderToBasket, onError)}
+      id="drugOrderForm"
+    >
       <div className={styles.form}>
         <ExtensionSlot name="top-of-lab-order-form-slot" state={{ order: initialOrder }} />
         <Grid className={styles.gridRow}>
           <Column lg={16} md={8} sm={4}>
             <InputWrapper>
-              <span className={styles.testTypeLabel}>{t('testType', 'Test type')}</span>
+              <label className={styles.testTypeLabel}>{t('testType', 'Test type')}</label>
               <p className={styles.testType}>{initialOrder?.testType?.label}</p>
             </InputWrapper>
           </Column>
@@ -381,15 +388,16 @@ export function LabOrderForm({
         <ButtonSet
           className={classNames(styles.buttonSet, isTablet ? styles.tabletButtonSet : styles.desktopButtonSet)}
         >
-          <Button className={styles.button} kind="secondary" onClick={cancelOrder} size="xl">
+          <Button
+            className={styles.button}
+            kind="secondary"
+            onClick={initialOrder?.action == 'REVISE' ? closeModifyOrderWorkspace : cancelOrder}
+            size="xl"
+          >
             {t('discard', 'Discard')}
           </Button>
           <Button className={styles.button} kind="primary" size="xl" type="submit">
-            {typeof isWorkSpaceType === 'function' &&
-            isWorkSpaceType(prevWorkSpace) &&
-            prevWorkSpace === WORKSPACES.TEST_RESULTS_FORM
-              ? t('saveTest', 'Save test')
-              : t('saveOrder', 'Save order')}
+            {t('saveOrder', 'Save order')}
           </Button>
         </ButtonSet>
       </div>

package/src/test-orders/add-test-order/test-order.ts

@@ -1,16 +1,16 @@
-import { priorityOptions, type OrderUrgency } from '@openmrs/esm-patient-common-lib';
+import { priorityOptions, type OrderUrgency, type TestOrderBasketItem } from '@openmrs/esm-patient-common-lib';
 import { type TestType } from './useTestTypes';
-import type { TestOrderBasketItem } from '../../types';
 
 type LabOrderRequest = Pick<TestOrderBasketItem, 'action' | 'testType'>;
 
-export function createEmptyLabOrder(testType: TestType, orderer: string): TestOrderBasketItem {
+export function createEmptyLabOrder(testType: TestType, orderer: string, visit): TestOrderBasketItem {
   return {
     action: 'NEW',
     urgency: priorityOptions[0].value as OrderUrgency,
     display: testType.label,
     testType,
     orderer,
+    visit,
   };
 }
 

package/src/test-orders/add-test-order/test-type-search.component.tsx

@@ -5,34 +5,30 @@ import { Button, ButtonSkeleton, Search, SkeletonText, Tile } from '@carbon/reac
 import { ShoppingCartArrowUp } from '@carbon/react/icons';
 import {
   ArrowRightIcon,
-  closeWorkspace,
-  launchWorkspace,
   ResponsiveWrapper,
   ShoppingCartArrowDownIcon,
   useDebounce,
   useLayoutType,
   useSession,
+  type Visit,
+  type Workspace2DefinitionProps,
 } from '@openmrs/esm-framework';
-import { useOrderBasket, type Order } from '@openmrs/esm-patient-common-lib';
-import type { TestOrderBasketItem } from '../../types';
+import { useOrderBasket, type TestOrderBasketItem } from '@openmrs/esm-patient-common-lib';
 import { prepTestOrderPostData } from '../api';
 import { createEmptyLabOrder } from './test-order';
 import { useTestTypes, type TestType } from './useTestTypes';
-import { WORKSPACES } from '../lab-order-basket-panel/lab-order-basket-panel.extension';
 import styles from './test-type-search.scss';
 
 export interface TestTypeSearchProps {
   openLabForm: (searchResult: TestOrderBasketItem) => void;
   orderTypeUuid: string;
   orderableConceptSets: Array<string>;
-  prevWorkSpace: string;
-  isWorkSpaceType: (value: string) => boolean;
-  prevOrder: Order;
+  closeWorkspace: Workspace2DefinitionProps['closeWorkspace'];
   patient: fhir.Patient;
+  visit: Visit;
 }
 
 interface TestTypeSearchResultsProps extends TestTypeSearchProps {
-  cancelOrder: () => void;
   searchTerm: string;
   focusAndClearSearchInput: () => void;
   patient: fhir.Patient;
@@ -42,20 +38,18 @@ interface TestTypeSearchResultItemProps {
   orderTypeUuid: string;
   testType: TestType;
   openOrderForm: (searchResult: TestOrderBasketItem) => void;
-  prevWorkSpace: string;
-  isWorkSpaceType: (value: string) => boolean;
-  prevOrder: Order;
   patient: fhir.Patient;
+  visit: Visit;
+  closeWorkspace: Workspace2DefinitionProps['closeWorkspace'];
 }
 
 export function TestTypeSearch({
+  patient,
+  visit,
   openLabForm,
   orderTypeUuid,
   orderableConceptSets,
-  prevWorkSpace,
-  isWorkSpaceType,
-  prevOrder,
-  patient,
+  closeWorkspace,
 }: TestTypeSearchProps) {
   const { t } = useTranslation();
   const [searchTerm, setSearchTerm] = useState('');
@@ -67,18 +61,6 @@ export function TestTypeSearch({
     searchInputRef.current?.focus();
   }, [setSearchTerm]);
 
-  const cancelOrder = useCallback(() => {
-    closeWorkspace('add-lab-order', {
-      ignoreChanges: true,
-      onWorkspaceClose: () =>
-        typeof isWorkSpaceType === 'function' &&
-        isWorkSpaceType(prevWorkSpace) &&
-        prevWorkSpace === WORKSPACES.TEST_RESULTS_FORM
-          ? launchWorkspace(prevWorkSpace, { order: prevOrder })
-          : launchWorkspace(WORKSPACES.ORDER_BASKET),
-    });
-  }, [isWorkSpaceType, prevOrder, prevWorkSpace]);
-
   const handleSearchTermChange = useCallback(
     (event: React.ChangeEvent<HTMLInputElement>) => {
       setSearchTerm(event.target.value ?? '');
@@ -100,32 +82,28 @@ export function TestTypeSearch({
         />
       </ResponsiveWrapper>
       <TestTypeSearchResults
-        cancelOrder={cancelOrder}
+        closeWorkspace={closeWorkspace}
         orderTypeUuid={orderTypeUuid}
         orderableConceptSets={orderableConceptSets}
         focusAndClearSearchInput={focusAndClearSearchInput}
         openLabForm={openLabForm}
         searchTerm={debouncedSearchTerm}
-        prevWorkSpace={prevWorkSpace}
-        isWorkSpaceType={isWorkSpaceType}
-        prevOrder={prevOrder}
         patient={patient}
+        visit={visit}
       />
     </>
   );
 }
 
 function TestTypeSearchResults({
-  cancelOrder,
+  closeWorkspace,
   searchTerm,
   orderTypeUuid,
   orderableConceptSets,
   openLabForm,
   focusAndClearSearchInput,
-  prevWorkSpace,
-  isWorkSpaceType,
-  prevOrder,
   patient,
+  visit,
 }: TestTypeSearchResultsProps) {
   const { t } = useTranslation();
   const isTablet = useLayoutType() === 'tablet';
@@ -176,10 +154,9 @@ function TestTypeSearchResults({
                 orderTypeUuid={orderTypeUuid}
                 openOrderForm={openLabForm}
                 testType={testType}
-                prevWorkSpace={prevWorkSpace}
-                isWorkSpaceType={isWorkSpaceType}
-                prevOrder={prevOrder}
+                closeWorkspace={closeWorkspace}
                 patient={patient}
+                visit={visit}
               />
             ))}
           </div>
@@ -187,12 +164,12 @@ function TestTypeSearchResults({
         {isTablet && (
           <div className={styles.separatorContainer}>
             <p className={styles.separator}>{t('or', 'or')}</p>
-            <Button iconDescription="Return to order basket" kind="ghost" onClick={cancelOrder}>
-              {typeof isWorkSpaceType === 'function' &&
-              isWorkSpaceType(prevWorkSpace) &&
-              prevWorkSpace === WORKSPACES.TEST_RESULTS_FORM
-                ? t('backToTestResults', 'Back to test Results')
-                : t('backToOrderBasket', 'Back to order basket')}
+            <Button
+              iconDescription="Return to order basket"
+              kind="ghost"
+              onClick={() => closeWorkspace({ discardUnsavedChanges: true })}
+            >
+              {t('back', 'Back')}
             </Button>
           </div>
         )}
@@ -224,10 +201,9 @@ const TestTypeSearchResultItem: React.FC<TestTypeSearchResultItemProps> = ({
   testType,
   openOrderForm,
   orderTypeUuid,
-  prevWorkSpace,
-  isWorkSpaceType,
-  prevOrder,
+  closeWorkspace,
   patient,
+  visit,
 }) => {
   const { t } = useTranslation();
   const isTablet = useLayoutType() === 'tablet';
@@ -241,25 +217,17 @@ const TestTypeSearchResultItem: React.FC<TestTypeSearchResultItemProps> = ({
 
   const createLabOrder = useCallback(
     (orderableConcept: TestType) => {
-      return createEmptyLabOrder(orderableConcept, session.currentProvider?.uuid);
+      return createEmptyLabOrder(orderableConcept, session.currentProvider?.uuid, visit);
     },
-    [session.currentProvider.uuid],
+    [session.currentProvider.uuid, visit],
   );
 
   const addToBasket = useCallback(() => {
     const labOrder = createLabOrder(testType);
     labOrder.isOrderIncomplete = true;
     setOrders([...orders, labOrder]);
-    closeWorkspace('add-lab-order', {
-      ignoreChanges: true,
-      onWorkspaceClose: () =>
-        typeof isWorkSpaceType === 'function' &&
-        isWorkSpaceType(prevWorkSpace) &&
-        prevWorkSpace === WORKSPACES.TEST_RESULTS_FORM
-          ? launchWorkspace(prevWorkSpace, { order: prevOrder })
-          : launchWorkspace(WORKSPACES.ORDER_BASKET),
-    });
-  }, [orders, setOrders, createLabOrder, testType, isWorkSpaceType, prevOrder, prevWorkSpace]);
+    closeWorkspace({ discardUnsavedChanges: true });
+  }, [orders, setOrders, createLabOrder, testType, closeWorkspace]);
 
   const removeFromBasket = useCallback(() => {
     setOrders(orders.filter((order) => order.testType.conceptUuid !== testType.conceptUuid));

package/src/test-orders/api.ts

@@ -2,7 +2,12 @@ import { useCallback, useMemo } from 'react';
 import { chunk } from 'lodash-es';
 import useSWR, { useSWRConfig } from 'swr';
 import useSWRImmutable from 'swr/immutable';
-import type { OrderPost, PatientOrderFetchResponse, TestOrderPost } from '@openmrs/esm-patient-common-lib';
+import type {
+  OrderPost,
+  PatientOrderFetchResponse,
+  TestOrderBasketItem,
+  TestOrderPost,
+} from '@openmrs/esm-patient-common-lib';
 import {
   type FetchResponse,
   openmrsFetch,
@@ -12,7 +17,6 @@ import {
   useConfig,
 } from '@openmrs/esm-framework';
 import { type ConfigObject } from '../config-schema';
-import type { TestOrderBasketItem } from '../types';
 
 export const careSettingUuid = '6f0c9a92-6f24-11e3-af88-005056821db0';
 

package/src/test-orders/lab-order-basket-panel/lab-order-basket-item-tile.component.tsx

@@ -3,7 +3,7 @@ import classNames from 'classnames';
 import { useTranslation } from 'react-i18next';
 import { ClickableTile, IconButton, Tile } from '@carbon/react';
 import { ExtensionSlot, TrashCanIcon, useLayoutType, WarningIcon } from '@openmrs/esm-framework';
-import type { TestOrderBasketItem } from '../../types';
+import type { TestOrderBasketItem } from '@openmrs/esm-patient-common-lib';
 import styles from './lab-order-basket-item-tile.scss';
 
 export interface OrderBasketItemTileProps {

package/src/test-orders/lab-order-basket-panel/lab-order-basket-panel.extension.tsx

@@ -2,38 +2,26 @@ import React, { type ComponentProps, useCallback, useEffect, useMemo, useState }
 import classNames from 'classnames';
 import { useTranslation } from 'react-i18next';
 import { Button, Tile } from '@carbon/react';
+import { AddIcon, ChevronDownIcon, ChevronUpIcon, useLayoutType, useConfig, MaybeIcon } from '@openmrs/esm-framework';
 import {
-  AddIcon,
-  closeWorkspace,
-  ChevronDownIcon,
-  ChevronUpIcon,
-  useLayoutType,
-  useConfig,
-  MaybeIcon,
-  launchWorkspace,
-  useWorkspaces,
-  type Visit,
-} from '@openmrs/esm-framework';
-import { type OrderBasketItem, useOrderBasket, useOrderType } from '@openmrs/esm-patient-common-lib';
+  type TestOrderBasketItem,
+  useOrderBasket,
+  useOrderType,
+  type OrderBasketExtensionProps,
+} from '@openmrs/esm-patient-common-lib';
 import type { ConfigObject } from '../../config-schema';
-import type { TestOrderBasketItem } from '../../types';
 import { LabOrderBasketItemTile } from './lab-order-basket-item-tile.component';
 import { prepTestOrderPostData } from '../api';
 import LabIcon from './lab-icon.component';
 import styles from './lab-order-basket-panel.scss';
 
-interface OrderBasketSlotProps {
-  patientUuid: string;
-  patient: fhir.Patient;
-  visitContext: Visit;
-  mutateVisitContext: () => void;
-}
-
 /**
+ * The extension is slotted into order-basket-slot in the main Order Basket workspace by default.
+ * It renders the "Add +" button for lab orders, and lists pending lab orders in the order basket.
+ *
  * Designs: https://app.zeplin.io/project/60d59321e8100b0324762e05/screen/648c44d9d4052c613e7f23da
- * Slotted into order-basket-slot by default
  */
-const LabOrderBasketPanelExtension: React.FC<OrderBasketSlotProps> = ({ patient }) => {
+export function LabOrderBasketPanelExtension({ patient, launchLabOrderForm }: OrderBasketExtensionProps) {
   const { orders, additionalTestOrderTypes } = useConfig<ConfigObject>();
   const { t } = useTranslation();
   const allOrderTypes: ConfigObject['additionalTestOrderTypes'] = [
@@ -49,35 +37,30 @@ const LabOrderBasketPanelExtension: React.FC<OrderBasketSlotProps> = ({ patient
   return (
     <>
       {allOrderTypes.map((orderTypeConfig) => (
-        <LabOrderBasketPanel patient={patient} key={orderTypeConfig.orderTypeUuid} {...orderTypeConfig} />
+        <LabOrderBasketPanel
+          key={orderTypeConfig.orderTypeUuid}
+          patient={patient}
+          {...orderTypeConfig}
+          launchLabOrderForm={launchLabOrderForm}
+        />
       ))}
     </>
   );
-};
-
-export const WORKSPACES = {
-  TEST_RESULTS_FORM: 'test-results-form-workspace',
-  ORDER_BASKET: 'order-basket',
-};
+}
 
 type OrderTypeConfig = ConfigObject['additionalTestOrderTypes'][0];
 
 interface LabOrderBasketPanelProps extends OrderTypeConfig {
   patient: fhir.Patient;
+  launchLabOrderForm(orderTypeUuid: string, order?: TestOrderBasketItem): void;
 }
 
-function LabOrderBasketPanel({ orderTypeUuid, label, icon, patient }: LabOrderBasketPanelProps) {
+function LabOrderBasketPanel({ orderTypeUuid, label, icon, patient, launchLabOrderForm }: LabOrderBasketPanelProps) {
   const { t } = useTranslation();
-  type WorkSpaceType = (typeof WORKSPACES)[keyof typeof WORKSPACES];
   const isTablet = useLayoutType() === 'tablet';
   const responsiveSize = isTablet ? 'md' : 'sm';
   const isDefaultLabOrder = icon === 'omrs-icon-lab-order';
   const { orderType, isLoadingOrderType } = useOrderType(orderTypeUuid);
-  const { workspaces = [{ name: WORKSPACES.ORDER_BASKET, additionalProps: {} }] } = useWorkspaces();
-  const [prevWorkSpace, setPrevWorkSpace] = useState(workspaces[0]?.name);
-  const [prevOrder, setPrevOrder] = useState(
-    workspaces[0]?.name === WORKSPACES.TEST_RESULTS_FORM ? workspaces[0].additionalProps['order'] : null,
-  );
   const { orders, setOrders } = useOrderBasket<TestOrderBasketItem>(patient, orderTypeUuid, prepTestOrderPostData);
   const [isExpanded, setIsExpanded] = useState(orders.length > 0);
   const {
@@ -115,41 +98,6 @@ function LabOrderBasketPanel({ orderTypeUuid, label, icon, patient }: LabOrderBa
       discontinuedOrderBasketItems,
     };
   }, [orders]);
-  const isWorkSpaceType = useCallback((value: string): value is WorkSpaceType => {
-    return Object.values(WORKSPACES).includes(value as WorkSpaceType);
-  }, []);
-
-  const openNewLabForm = useCallback(() => {
-    closeWorkspace(isWorkSpaceType(prevWorkSpace) ? prevWorkSpace : WORKSPACES.ORDER_BASKET, {
-      ignoreChanges: true,
-      onWorkspaceClose: () =>
-        launchWorkspace('add-lab-order', {
-          orderTypeUuid: orderTypeUuid,
-          prevWorkSpace: prevWorkSpace,
-          isWorkSpaceType: isWorkSpaceType,
-          prevOrder: prevOrder,
-        }),
-      closeWorkspaceGroup: false,
-    });
-  }, [orderTypeUuid, isWorkSpaceType, prevOrder, prevWorkSpace]);
-
-  const openEditLabForm = useCallback(
-    (order: OrderBasketItem) => {
-      closeWorkspace(isWorkSpaceType(prevWorkSpace) ? prevWorkSpace : WORKSPACES.ORDER_BASKET, {
-        ignoreChanges: true,
-        onWorkspaceClose: () =>
-          launchWorkspace('add-lab-order', {
-            order,
-            orderTypeUuid: orderTypeUuid,
-            prevWorkSpace: prevWorkSpace,
-            isWorkSpaceType: isWorkSpaceType,
-            prevOrder: prevOrder,
-          }),
-        closeWorkspaceGroup: false,
-      });
-    },
-    [orderTypeUuid, isWorkSpaceType, prevOrder, prevWorkSpace],
-  );
 
   const removeLabOrder = useCallback(
     (order: TestOrderBasketItem) => {
@@ -181,20 +129,14 @@ function LabOrderBasketPanel({ orderTypeUuid, label, icon, patient }: LabOrderBa
           ) : (
             <MaybeIcon icon={icon ? icon : 'omrs-icon-generic-order-type'} size={isTablet ? 40 : 24} />
           )}
-          <h4 className={styles.heading}>{`${
-            isWorkSpaceType(prevWorkSpace) && prevWorkSpace === WORKSPACES.ORDER_BASKET
-              ? label
-                ? t(label)
-                : orderType?.display
-              : t('tests', 'Tests')
-          } (${orders.length})`}</h4>
+          <h4 className={styles.heading}>{`${label ? t(label) : orderType?.display} (${orders.length})`}</h4>
         </div>
         <div className={styles.buttonContainer}>
           <Button
             className={styles.addButton}
             iconDescription="Add lab order"
             kind="ghost"
-            onClick={openNewLabForm}
+            onClick={() => launchLabOrderForm(orderTypeUuid)}
             renderIcon={(props: ComponentProps<typeof AddIcon>) => <AddIcon size={16} {...props} />}
             size={responsiveSize}
           >
@@ -225,7 +167,7 @@ function LabOrderBasketPanel({ orderTypeUuid, label, icon, patient }: LabOrderBa
                   {incompleteOrderBasketItems.map((order) => (
                     <LabOrderBasketItemTile
                       key={order.uuid}
-                      onItemClick={() => openEditLabForm(order)}
+                      onItemClick={() => launchLabOrderForm(orderTypeUuid, order)}
                       onRemoveClick={() => removeLabOrder(order)}
                       orderBasketItem={order}
                     />
@@ -237,7 +179,7 @@ function LabOrderBasketPanel({ orderTypeUuid, label, icon, patient }: LabOrderBa
                   {newOrderBasketItems.map((order) => (
                     <LabOrderBasketItemTile
                       key={order.uuid}
-                      onItemClick={() => openEditLabForm(order)}
+                      onItemClick={() => launchLabOrderForm(orderTypeUuid, order)}
                       onRemoveClick={() => removeLabOrder(order)}
                       orderBasketItem={order}
                     />
@@ -250,7 +192,7 @@ function LabOrderBasketPanel({ orderTypeUuid, label, icon, patient }: LabOrderBa
                   {renewedOrderBasketItems.map((order) => (
                     <LabOrderBasketItemTile
                       key={order.uuid}
-                      onItemClick={() => openEditLabForm(order)}
+                      onItemClick={() => launchLabOrderForm(orderTypeUuid, order)}
                       onRemoveClick={() => removeLabOrder(order)}
                       orderBasketItem={order}
                     />
@@ -263,7 +205,7 @@ function LabOrderBasketPanel({ orderTypeUuid, label, icon, patient }: LabOrderBa
                   {revisedOrderBasketItems.map((order) => (
                     <LabOrderBasketItemTile
                       key={order.uuid}
-                      onItemClick={() => openEditLabForm(order)}
+                      onItemClick={() => launchLabOrderForm(orderTypeUuid, order)}
                       onRemoveClick={() => removeLabOrder(order)}
                       orderBasketItem={order}
                     />
@@ -276,7 +218,7 @@ function LabOrderBasketPanel({ orderTypeUuid, label, icon, patient }: LabOrderBa
                   {discontinuedOrderBasketItems.map((order) => (
                     <LabOrderBasketItemTile
                       key={order.uuid}
-                      onItemClick={() => openEditLabForm(order)}
+                      onItemClick={() => launchLabOrderForm(orderTypeUuid, order)}
                       onRemoveClick={() => removeLabOrder(order)}
                       orderBasketItem={order}
                     />