@openmrs/esm-patient-orders-app 11.3.1-pre.9637 → 11.3.1-pre.9645

package/src/components/order-details-table.component.tsx

@@ -30,7 +30,6 @@ import {
   CardHeader,
   EmptyState,
   ErrorState,
-  getDrugOrderByUuid,
   PatientChartPagination,
   type Order,
   type OrderBasketItem,
@@ -39,6 +38,8 @@ import {
   useOrderBasket,
   useOrderTypes,
   usePatientOrders,
+  getDrugOrderByUuid,
+  invalidateVisitByUuid,
 } from '@openmrs/esm-patient-common-lib';
 import { prepMedicationOrderPostData } from '@openmrs/esm-patient-medications-app/src/api/api';
 import { prepTestOrderPostData } from '@openmrs/esm-patient-tests-app/src/test-orders/api';
@@ -65,6 +66,7 @@ import MedicationRecord from './medication-record.component';
 import PrintComponent from '../print/print.component';
 import TestOrder from './test-order.component';
 import styles from './order-details-table.scss';
+import { useSWRConfig } from 'swr';
 
 interface OrderDetailsProps {
   patientUuid: string;
@@ -75,8 +77,6 @@ interface OrderDetailsProps {
 }
 
 interface OrderBasketItemActionsProps {
-  openOrderBasket: (encounterUuid) => void;
-  launchOrderForm: (order: Order) => void;
   orderItem: Order;
   patient: fhir.Patient;
 }
@@ -103,9 +103,6 @@ const OrderDetailsTable: React.FC<OrderDetailsProps> = ({
   const isTablet = useLayoutType() === 'tablet';
   const responsiveSize = isTablet ? 'lg' : 'md';
   const _launchOrderBasket = useLaunchWorkspaceRequiringVisit(patientUuid, 'order-basket');
-  const launchAddDrugOrder = useLaunchWorkspaceRequiringVisit(patientUuid, 'add-drug-order');
-  const launchModifyLabOrder = useLaunchWorkspaceRequiringVisit(patientUuid, 'add-lab-order');
-  const launchModifyGeneralOrder = useLaunchWorkspaceRequiringVisit(patientUuid, 'orderable-concept-workspace');
   const contentToPrintRef = useRef<HTMLDivElement | null>(null);
   const { excludePatientIdentifierCodeTypes } = useConfig();
   const [isPrinting, setIsPrinting] = useState(false);
@@ -184,49 +181,11 @@ const OrderDetailsTable: React.FC<OrderDetailsProps> = ({
     }
     return allOrders.filter((order) => order.orderType?.uuid === selectedOrderTypeUuid);
   }, [allOrders, selectedOrderTypeUuid]);
-
-  const launchOrderBasket = useCallback(
-    (encounterUuid: string) => {
-      _launchOrderBasket(null, { encounterUuid });
-    },
+  const launchOrderBasketForNewItem = useCallback(
+    () => _launchOrderBasket(null, { encounterUuid: '' }),
     [_launchOrderBasket],
   );
 
-  // launch respective order basket based on order type
-  const launchOrderForm = useCallback(
-    (orderItem: Order) => {
-      switch (orderItem.type) {
-        case ORDER_TYPES.DRUG_ORDER:
-          launchAddDrugOrder(
-            { order: buildMedicationOrder(orderItem, 'REVISE') },
-            { encounterUuid: orderItem.encounter.uuid },
-          );
-          break;
-        case ORDER_TYPES.TEST_ORDER:
-          launchModifyLabOrder(
-            {
-              order: buildLabOrder(orderItem, 'REVISE'),
-              orderTypeUuid: orderItem.orderType.uuid,
-            },
-            { encounterUuid: orderItem.encounter.uuid },
-          );
-          break;
-        case ORDER_TYPES.GENERAL_ORDER:
-          launchModifyGeneralOrder(
-            {
-              order: buildGeneralOrder(orderItem, 'REVISE'),
-              orderTypeUuid: orderItem.orderType.uuid,
-            },
-            { encounterUuid: orderItem.encounter.uuid },
-          );
-          break;
-        default:
-          launchOrderBasket(orderItem.encounter.uuid);
-      }
-    },
-    [launchAddDrugOrder, launchModifyGeneralOrder, launchModifyLabOrder, launchOrderBasket],
-  );
-
   const tableHeaders: Array<OrderHeaderProps> = [
     {
       key: 'orderNumber',
@@ -439,7 +398,7 @@ const OrderDetailsTable: React.FC<OrderDetailsProps> = ({
             <EmptyState
               headerTitle={headerTitle}
               displayText={emptyStateDisplayText}
-              launchForm={() => launchOrderBasket('')}
+              launchForm={() => launchOrderBasketForNewItem()}
             />
           ) : (
             <div className={styles.widgetCard}>
@@ -467,7 +426,7 @@ const OrderDetailsTable: React.FC<OrderDetailsProps> = ({
                       kind="ghost"
                       renderIcon={AddIcon}
                       iconDescription={t('launchOrderBasket', 'Launch order basket')}
-                      onClick={() => launchOrderBasket('')}
+                      onClick={() => launchOrderBasketForNewItem()}
                     >
                       {t('add', 'Add')}
                     </Button>
@@ -541,12 +500,7 @@ const OrderDetailsTable: React.FC<OrderDetailsProps> = ({
                                     {!isPrinting && (
                                       <TableCell className="cds--table-column-menu">
                                         {matchingOrder && isOmrsOrder(matchingOrder) ? (
-                                          <OrderBasketItemActions
-                                            patient={patient}
-                                            launchOrderForm={launchOrderForm}
-                                            openOrderBasket={launchOrderBasket}
-                                            orderItem={matchingOrder}
-                                          />
+                                          <OrderBasketItemActions patient={patient} orderItem={matchingOrder} />
                                         ) : (
                                           <ExtensionSlot
                                             name={`${matchingOrder?.type}-action-menu-items-slot`}
@@ -628,7 +582,7 @@ const OrderDetailsTable: React.FC<OrderDetailsProps> = ({
   );
 };
 
-function OrderBasketItemActions({ orderItem, openOrderBasket, launchOrderForm, patient }: OrderBasketItemActionsProps) {
+function OrderBasketItemActions({ orderItem, patient }: OrderBasketItemActionsProps) {
   const { t } = useTranslation();
 
   // Use the appropriate grouping key and postDataPrepFunction based on order type
@@ -654,48 +608,74 @@ function OrderBasketItemActions({ orderItem, openOrderBasket, launchOrderForm, p
   const { grouping, postDataPrepFn } = getOrderBasketConfig();
   const { orders, setOrders } = useOrderBasket<MutableOrderBasketItem>(patient, grouping, postDataPrepFn);
   const alreadyInBasket = orders.some((x) => x.uuid === orderItem.uuid);
+  const { mutate: globalMutate } = useSWRConfig();
+
+  const windowProps = useMemo(() => ({ encounterUuid: orderItem.encounter.uuid }), [orderItem.encounter.uuid]);
+  const groupProps = useMemo(
+    () => ({
+      patient,
+      patientUuid: patient.id,
+      visitContext: orderItem.encounter.visit,
+      mutateVisitContext: invalidateVisitByUuid(globalMutate, orderItem.encounter.visit.uuid),
+    }),
+    [patient, orderItem.encounter.visit, globalMutate],
+  );
 
   const handleCancelOrder = useCallback(() => {
     if (orderItem.type === ORDER_TYPES.DRUG_ORDER) {
       getDrugOrderByUuid(orderItem.uuid).then((res) => {
         const medicationOrder = res.data;
         const discontinueItem = buildMedicationOrder(medicationOrder, 'DISCONTINUE');
-        openOrderBasket(orderItem.encounter.uuid);
         setOrders([...orders, discontinueItem]);
       });
     } else if (orderItem.type === ORDER_TYPES.TEST_ORDER) {
       const labItem = buildLabOrder(orderItem, 'DISCONTINUE');
-      openOrderBasket(orderItem.encounter.uuid);
       setOrders([...orders, labItem]);
     } else {
       const order = buildGeneralOrder(orderItem, 'DISCONTINUE');
-      openOrderBasket(orderItem.encounter.uuid);
       setOrders([...orders, order]);
     }
-  }, [orderItem, setOrders, orders, openOrderBasket]);
+    launchWorkspace2('order-basket', {}, windowProps, groupProps);
+  }, [orderItem, setOrders, orders, windowProps, groupProps]);
 
   const handleModifyOrder = useCallback(() => {
     if (orderItem.type === ORDER_TYPES.DRUG_ORDER) {
+      // make another call to fetch the order,
+      // this time with custom rep to include the drug field
+      // (when we fetch the array containing orderItem, we fetched for
+      // all order types and including the drug field in the custom rep will
+      // yield an error)
       getDrugOrderByUuid(orderItem.uuid)
         .then((res) => {
           const medicationOrder = res.data;
-          const medicationItem = buildMedicationOrder(medicationOrder, 'REVISE');
-          setOrders([...orders, medicationItem]);
-          launchOrderForm(medicationOrder);
+          launchWorkspace2(
+            'add-drug-order',
+            { order: buildMedicationOrder(medicationOrder, 'REVISE'), orderToEditOrdererUuid: orderItem.orderer.uuid },
+            windowProps,
+            groupProps,
+          );
         })
         .catch((e) => {
           console.error('Error modifying drug order: ', e);
         });
     } else if (orderItem.type === ORDER_TYPES.TEST_ORDER) {
       const labItem = buildLabOrder(orderItem, 'REVISE');
-      setOrders([...orders, labItem]);
-      launchOrderForm(orderItem);
+      launchWorkspace2(
+        'add-lab-order',
+        { order: labItem, orderTypeUuid: orderItem.orderType.uuid, orderToEditOrdererUuid: orderItem.orderer.uuid },
+        windowProps,
+        groupProps,
+      );
     } else if (orderItem.type === ORDER_TYPES.GENERAL_ORDER) {
-      const order = buildGeneralOrder(orderItem, 'REVISE');
-      setOrders([...orders, order]);
-      launchOrderForm(orderItem);
+      const generalItem = buildGeneralOrder(orderItem, 'REVISE');
+      launchWorkspace2(
+        'orderable-concept-workspace',
+        { order: generalItem, orderTypeUuid: orderItem.orderType.uuid, orderToEditOrdererUuid: orderItem.orderer.uuid },
+        windowProps,
+        groupProps,
+      );
     }
-  }, [orderItem, launchOrderForm, orders, setOrders]);
+  }, [orderItem, windowProps, groupProps]);
 
   const handleAddOrEditTestResults = useCallback(() => {
     launchWorkspace2('test-results-form-workspace', { order: orderItem, patient });

package/src/config-schema.ts

@@ -53,6 +53,12 @@ export const configSchema = {
     _description:
       'Whether to display the "Reference number" field in the Order form. This field maps to the accession_number property in the Order data model',
   },
+  ordererProviderRoles: {
+    _type: Type.Array,
+    _description:
+      'Array of provider roles uuids. If specified, the order basket shows the "Prescribing Clinician" dropdown listing all providers with one of the specified roles. (The dropdown is hidden if no providers match the role criteria.) This feature requires the providermanagement backend module. Note that, in any case, any user who can submit orders form may still do so with themselves as the prescriber.',
+    _default: [],
+  },
 };
 
 export interface OrderTypeDefinition {
@@ -68,4 +74,5 @@ export interface ConfigObject {
   showPrintButton: boolean;
   orderTypes: Array<OrderTypeDefinition>;
   showReferenceNumberField: boolean;
+  ordererProviderRoles: Array<string>;
 }

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

@@ -21,6 +21,7 @@ const ExportedOrderBasketWorkspace: React.FC<Workspace2DefinitionProps<{}, Expor
     drugOrderWorkspaceName,
     labOrderWorkspaceName,
     generalOrderWorkspaceName,
+    onOrderBasketSubmitted,
   },
   closeWorkspace,
   launchChildWorkspace,
@@ -52,6 +53,7 @@ const ExportedOrderBasketWorkspace: React.FC<Workspace2DefinitionProps<{}, Expor
       mutateVisitContext={mutateVisitContext}
       closeWorkspace={closeWorkspace}
       orderBasketExtensionProps={orderBasketExtensionProps}
+      onOrderBasketSubmitted={onOrderBasketSubmitted}
     />
   );
 };

package/src/order-basket/general-order-type/add-general-order/search-results.component.tsx

@@ -174,7 +174,6 @@ const TestTypeSearchResultItem: React.FC<TestTypeSearchResultItemProps> = ({
 }) => {
   const { t } = useTranslation();
   const isTablet = useLayoutType() === 'tablet';
-  const session = useSession();
   const { orders, setOrders } = useOrderBasket<OrderBasketItem>(patient, orderTypeUuid, prepOrderPostData);
 
   const orderAlreadyInBasket = useMemo(
@@ -182,19 +181,12 @@ const TestTypeSearchResultItem: React.FC<TestTypeSearchResultItemProps> = ({
     [orders, concept],
   );
 
-  const createOrderBasketItem = useCallback(
-    (testType: OrderableConcept, visit: Visit) => {
-      return createEmptyOrder(testType, session.currentProvider?.uuid, visit);
-    },
-    [session.currentProvider.uuid],
-  );
-
   const addToBasket = useCallback(() => {
-    const orderBasketItem = createOrderBasketItem(concept, visit);
+    const orderBasketItem = createEmptyOrder(concept, visit);
     orderBasketItem.isOrderIncomplete = true;
     setOrders([...orders, orderBasketItem]);
     closeWorkspace({ discardUnsavedChanges: true });
-  }, [orders, setOrders, createOrderBasketItem, concept, closeWorkspace, visit]);
+  }, [orders, setOrders, concept, closeWorkspace, visit]);
 
   const removeFromBasket = useCallback(() => {
     setOrders(orders.filter((order) => order?.concept?.uuid !== concept?.uuid));
@@ -233,7 +225,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(createEmptyOrder(concept, visit))}
         >
           {t('goToDrugOrderForm', 'Order form')}
         </Button>

package/src/order-basket/general-order-type/general-order-form/general-order-form.component.tsx

@@ -41,6 +41,7 @@ import styles from './general-order-form.scss';
 
 export interface OrderFormProps {
   initialOrder: OrderBasketItem;
+  orderToEditOrdererUuid?: string;
   orderTypeUuid: string;
   closeWorkspace: Workspace2DefinitionProps['closeWorkspace'];
   setHasUnsavedChanges: (hasUnsavedChanges: boolean) => void;
@@ -53,6 +54,7 @@ export interface OrderFormProps {
 export function OrderForm({
   patient,
   initialOrder,
+  orderToEditOrdererUuid,
   orderTypeUuid,
   closeWorkspace,
   setHasUnsavedChanges,
@@ -117,7 +119,6 @@ export function OrderForm({
         ...initialOrder,
         ...data,
       };
-      finalizedOrder.orderer = session.currentProvider.uuid;
 
       const newOrders = [...orders];
       const existingOrder = orders.find((order) => ordersEqual(order, finalizedOrder));
@@ -136,7 +137,7 @@ export function OrderForm({
 
       closeWorkspace({ discardUnsavedChanges: true });
     },
-    [orders, setOrders, session?.currentProvider?.uuid, initialOrder, closeWorkspace],
+    [orders, setOrders, initialOrder, closeWorkspace],
   );
 
   const submitDrugOrderToServer = useCallback(
@@ -145,9 +146,8 @@ export function OrderForm({
         ...initialOrder,
         ...data,
       };
-      finalizedOrder.orderer = session.currentProvider.uuid;
 
-      postOrder(prepOrderPostData(finalizedOrder, patient.id, finalizedOrder?.encounterUuid))
+      postOrder(prepOrderPostData(finalizedOrder, patient.id, finalizedOrder?.encounterUuid, orderToEditOrdererUuid))
         .then(() => {
           clearOrders();
           mutateOrders();
@@ -167,7 +167,7 @@ export function OrderForm({
           });
         });
     },
-    [clearOrders, closeWorkspace, initialOrder, mutateOrders, patient.id, session.currentProvider.uuid, t],
+    [clearOrders, closeWorkspace, initialOrder, mutateOrders, patient.id, orderToEditOrdererUuid, t],
   );
 
   const cancelOrder = useCallback(() => {

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

@@ -5,15 +5,16 @@ import {
   type OrderUrgency,
   type OrderPost,
   type OrderableConcept,
+  careSettingUuid,
+  type PostDataPrepFunction,
 } from '@openmrs/esm-patient-common-lib';
 
-export function createEmptyOrder(concept: OrderableConcept, orderer: string, visit: Visit): OrderBasketItem {
+export function createEmptyOrder(concept: OrderableConcept, visit: Visit): OrderBasketItem {
   return {
     action: 'NEW',
     urgency: priorityOptions[0].value as OrderUrgency,
     display: concept.display,
     concept,
-    orderer,
     visit,
   };
 }
@@ -22,20 +23,19 @@ export function ordersEqual(order1: OrderBasketItem, order2: OrderBasketItem) {
   return order1.action === order2.action && order1.concept.uuid === order2.concept.uuid;
 }
 
-const careSettingUuid = '6f0c9a92-6f24-11e3-af88-005056821db0';
-
-export function prepOrderPostData(
-  order: OrderBasketItem,
-  patientUuid: string,
-  encounterUuid: string | null,
-): OrderPost {
+export const prepOrderPostData: PostDataPrepFunction = (
+  order,
+  patientUuid,
+  encounterUuid,
+  orderingProviderUuid,
+): OrderPost => {
   if (order.action === 'NEW' || order.action === 'RENEW') {
     return {
       action: 'NEW',
       type: 'order',
       patient: patientUuid,
       careSetting: careSettingUuid,
-      orderer: order.orderer,
+      orderer: orderingProviderUuid,
       encounter: encounterUuid,
       concept: order.concept.uuid,
       instructions: order.instructions,
@@ -49,8 +49,8 @@ export function prepOrderPostData(
       action: 'REVISE',
       type: 'order',
       patient: patientUuid,
-      careSetting: order.careSetting,
-      orderer: order.orderer,
+      careSetting: careSettingUuid,
+      orderer: orderingProviderUuid,
       encounter: encounterUuid,
       concept: order?.concept?.uuid,
       instructions: order.instructions,
@@ -64,8 +64,8 @@ export function prepOrderPostData(
       action: 'DISCONTINUE',
       type: 'order',
       patient: patientUuid,
-      careSetting: order.careSetting,
-      orderer: order.orderer,
+      careSetting: careSettingUuid,
+      orderer: orderingProviderUuid,
       encounter: encounterUuid,
       concept: order?.concept?.uuid,
       previousOrder: order.previousOrder,
@@ -76,4 +76,4 @@ export function prepOrderPostData(
   } else {
     throw new Error(`Unknown order action: ${order.action}.`);
   }
-}
+};