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

package/src/lab-results/lab-results-schema.resource.tsx

@@ -25,17 +25,26 @@ function createSchemaForConcept(labOrderConcept: LabOrderConcept): SchemaRecord
   };
 }
 
+function createSchemaForConceptArray(labOrderConcepts: Array<LabOrderConcept>): SchemaRecord {
+  return labOrderConcepts.reduce((acc, concept) => {
+    return {
+      ...acc,
+      ...createSchemaForConcept(concept), // reuses recursive logic
+    };
+  }, {});
+}
+
 /**
- * Custom hook to generate a Zod schema for lab results form based on a lab order concept.
+ * Custom hook to generate a Zod schema for lab results form based on multiple lab order concepts.
  * This function is used to generate the schema for the lab results form.
- * @param labOrderConceptUuid - The UUID of the lab order concept.
+ * @param {Array<string>} labOrderConceptUuid - The List of UUID of the lab order concepts.
  * @returns A Zod schema object for the lab results form.
  */
-export const createLabResultsFormSchema = (labOrderConcepts: LabOrderConcept) => {
+export const createLabResultsFormCompositeSchema = (labOrderConcepts: Array<LabOrderConcept>) => {
   if (!labOrderConcepts) {
     return z.object({});
   }
-  const schema = createSchemaForConcept(labOrderConcepts);
+  const schema = createSchemaForConceptArray(labOrderConcepts);
 
   return z.object(schema);
 };

package/src/lab-results/lab-results.resource.ts

@@ -130,6 +130,26 @@ export function useOrderConceptByUuid(uuid: string) {
   return results;
 }
 
+export function useOrderConceptsByUuids(uuids: Array<string>) {
+  const { data, error, isLoading, isValidating, mutate } = useSWR<Array<LabOrderConcept>, Error>(
+    uuids.length ? ['concepts', ...uuids] : null,
+    () => Promise.all(uuids.map((uuid) => fetchAllSetMembers(uuid))),
+  );
+
+  const results = useMemo(
+    () => ({
+      concepts: data ?? [],
+      isLoading,
+      error,
+      isValidating,
+      mutate,
+    }),
+    [data, error, isLoading, isValidating, mutate],
+  );
+
+  return results;
+}
+
 export function useLabEncounter(encounterUuid: string) {
   const apiUrl = `${restBaseUrl}/encounter/${encounterUuid}?v=${labEncounterRepresentation}`;
 
@@ -163,6 +183,33 @@ export function useObservation(obsUuid: string) {
   };
 }
 
+export function useObservations(obsUuids: Array<string>) {
+  const fetchMultipleObservations = async (): Promise<Array<Observation>> => {
+    const results = await Promise.all(
+      obsUuids.map(async (uuid) => {
+        const url = `${restBaseUrl}/obs/${uuid}?v=${conceptObsRepresentation}`;
+        const res = await openmrsFetch(url);
+        return res.data;
+      }),
+    );
+
+    return results;
+  };
+
+  const { data, error, isLoading, isValidating, mutate } = useSWR<Observation[], Error>(
+    obsUuids && obsUuids.length > 0 ? ['observations', ...obsUuids] : null,
+    fetchMultipleObservations,
+  );
+
+  return {
+    data: data ?? [],
+    isLoading,
+    error,
+    isValidating,
+    mutate,
+  };
+}
+
 export function useCompletedLabResults(order: Order) {
   const {
     encounter,
@@ -188,6 +235,29 @@ export function useCompletedLabResults(order: Order) {
   };
 }
 
+export function useCompletedLabResultsArray(order: Order) {
+  const {
+    encounter,
+    isLoading: isLoadingEncounter,
+    mutate: mutateLabOrders,
+    error: encounterError,
+  } = useLabEncounter(order.encounter.uuid);
+
+  const obsUuids = encounter?.obs.filter((o) => o?.order.uuid === order?.uuid).map((o) => o.uuid);
+
+  const { data: observations, isLoading: isLoadingObs, error: errorObs, mutate: mutateObs } = useObservations(obsUuids);
+
+  return {
+    isLoading: isLoadingEncounter || isLoadingObs,
+    completeLabResults: observations,
+    mutate: () => {
+      mutateLabOrders();
+      mutateObs();
+    },
+    error: errorObs ?? encounterError,
+  };
+}
+
 // TODO: the calls to update order and observations for results should be transactional to allow for rollback
 export async function updateOrderResult(
   orderUuid: string,
@@ -256,6 +326,33 @@ export function createObservationPayload(
   }
 }
 
+export function createCompositeObservationPayload(
+  concepts: LabOrderConcept[],
+  order: Order,
+  values: Record<string, unknown>,
+  status: string,
+) {
+  if (!concepts || concepts.length === 0) return { obs: [] };
+
+  const allObs = concepts.flatMap((concept) => {
+    if (concept.set && concept.setMembers.length > 0) {
+      const groupMembers = concept.setMembers
+        .map((member) => createGroupMember(member, order, values, status))
+        .filter((member) => member !== null && member.value !== null && member.value !== undefined);
+
+      if (groupMembers.length === 0) return [];
+
+      return [createObservationByConcept(concept, order, groupMembers, null, status)];
+    } else {
+      const value = getValue(concept, values);
+      if (value === null || value === undefined) return [];
+      return [createObservationByConcept(concept, order, null, value, status)];
+    }
+  });
+
+  return { obs: allObs };
+}
+
 export function updateObservation(observationUuid: string, payload: Record<string, any>) {
   return openmrsFetch(`${restBaseUrl}/obs/${observationUuid}`, {
     method: 'POST',
@@ -289,6 +386,22 @@ function createObservation(order: Order, groupMembers = null, value = null, stat
   };
 }
 
+function createObservationByConcept(
+  concept: LabOrderConcept,
+  order: Order,
+  groupMembers = null,
+  value = null,
+  status: string,
+) {
+  return {
+    concept: { uuid: concept.uuid },
+    status: status,
+    order: { uuid: order.uuid },
+    ...(groupMembers && groupMembers.length > 0 && { groupMembers }),
+    ...(value !== null && value !== undefined && { value }),
+  };
+}
+
 function getValue(concept: LabOrderConcept, values: Record<string, unknown>) {
   const { datatype, uuid } = concept;
   const value = values[uuid];

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

@@ -19,12 +19,11 @@ import { zodResolver } from '@hookform/resolvers/zod';
 import { z } from 'zod';
 import {
   priorityOptions,
+  type DefaultPatientWorkspaceProps,
   type OrderBasketItem,
   type OrderUrgency,
   useOrderBasket,
   useOrderType,
-  postOrder,
-  useMutatePatientOrders,
 } from '@openmrs/esm-patient-common-lib';
 import {
   useLayoutType,
@@ -32,40 +31,37 @@ import {
   useConfig,
   ExtensionSlot,
   OpenmrsDatePicker,
-  type Workspace2DefinitionProps,
-  showSnackbar,
-  useAbortController,
+  launchWorkspace,
 } from '@openmrs/esm-framework';
 import { ordersEqual, prepOrderPostData } from '../resources';
 import { type ConfigObject } from '../../../config-schema';
 import styles from './general-order-form.scss';
 
-export interface OrderFormProps {
+export interface OrderFormProps extends DefaultPatientWorkspaceProps {
   initialOrder: OrderBasketItem;
   orderTypeUuid: string;
-  closeWorkspace: Workspace2DefinitionProps['closeWorkspace'];
-  setHasUnsavedChanges: (hasUnsavedChanges: boolean) => void;
-  patient: fhir.Patient;
+  orderableConceptSets: Array<string>;
 }
 
 // Designs:
 //   https://app.zeplin.io/project/60d5947dd636aebbd63dce4c/screen/640b06c440ee3f7af8747620
 //   https://app.zeplin.io/project/60d5947dd636aebbd63dce4c/screen/640b06d286e0aa7b0316db4a
 export function OrderForm({
-  patient,
   initialOrder,
-  orderTypeUuid,
   closeWorkspace,
-  setHasUnsavedChanges,
+  closeWorkspaceWithSavedChanges,
+  promptBeforeClosing,
+  patient,
+  orderTypeUuid,
 }: OrderFormProps) {
   const { t } = useTranslation();
   const isTablet = useLayoutType() === 'tablet';
   const session = useSession();
-  const { orders, setOrders, clearOrders } = useOrderBasket<OrderBasketItem>(patient, orderTypeUuid, prepOrderPostData);
+  const isEditing = useMemo(() => initialOrder && initialOrder.action === 'REVISE', [initialOrder]);
+  const { orders, setOrders } = useOrderBasket<OrderBasketItem>(patient, orderTypeUuid, prepOrderPostData);
   const [showErrorNotification, setShowErrorNotification] = useState(false);
   const { orderType } = useOrderType(orderTypeUuid);
   const config = useConfig<ConfigObject>();
-  const { mutate: mutateOrders } = useMutatePatientOrders(patient.id);
 
   const OrderFormSchema = useMemo(
     () =>
@@ -112,7 +108,7 @@ export function OrderForm({
     return menu?.item?.value?.toLowerCase().includes(menu?.inputValue?.toLowerCase());
   }, []);
 
-  const saveOrderToBasket = useCallback(
+  const handleFormSubmission = useCallback(
     (data: OrderBasketItem) => {
       const finalizedOrder: OrderBasketItem = {
         ...initialOrder,
@@ -135,55 +131,22 @@ export function OrderForm({
 
       setOrders(newOrders);
 
-      closeWorkspace({ discardUnsavedChanges: true });
+      closeWorkspaceWithSavedChanges({
+        onWorkspaceClose: () => launchWorkspace('order-basket'),
+        closeWorkspaceGroup: false,
+      });
     },
-    [orders, setOrders, session?.currentProvider?.uuid, initialOrder, closeWorkspace],
-  );
-
-  const submitDrugOrderToServer = useCallback(
-    (data: OrderBasketItem) => {
-      const finalizedOrder: OrderBasketItem = {
-        ...initialOrder,
-        ...data,
-      };
-      finalizedOrder.orderer = session.currentProvider.uuid;
-
-      postOrder(prepOrderPostData(finalizedOrder, patient.id, finalizedOrder?.encounterUuid))
-        .then(() => {
-          clearOrders();
-          mutateOrders();
-          showSnackbar({
-            isLowContrast: false,
-            kind: 'success',
-            title: t('successSavingDrugOrder', 'Order saved'),
-          });
-          closeWorkspace({ discardUnsavedChanges: true });
-        })
-        .catch((error) => {
-          showSnackbar({
-            isLowContrast: false,
-            kind: 'error',
-            title: t('errorSavingDrugOrder', 'Error saving order'),
-            subtitle: error,
-          });
-        });
-    },
-    [clearOrders, closeWorkspace, initialOrder, mutateOrders, patient.id, session.currentProvider.uuid, t],
+    [orders, setOrders, session?.currentProvider?.uuid, closeWorkspaceWithSavedChanges, initialOrder],
   );
 
   const cancelOrder = useCallback(() => {
-    closeWorkspace().then((didClose: boolean) => {
-      if (didClose) {
-        setOrders(orders.filter((order) => order.concept.uuid !== defaultValues.concept.conceptUuid));
-      }
+    setOrders(orders.filter((order) => order.concept.uuid !== defaultValues.concept.conceptUuid));
+    closeWorkspace({
+      onWorkspaceClose: () => launchWorkspace('order-basket'),
+      closeWorkspaceGroup: false,
     });
   }, [closeWorkspace, orders, setOrders, defaultValues]);
 
-  const closeModifyOrderWorkspace = useCallback(() => {
-    clearOrders();
-    closeWorkspace();
-  }, [clearOrders, closeWorkspace]);
-
   const onError = (errors: FieldErrors<OrderBasketItem>) => {
     if (errors) {
       setShowErrorNotification(true);
@@ -201,24 +164,20 @@ export function OrderForm({
   };
 
   useEffect(() => {
-    setHasUnsavedChanges(isDirty);
-  }, [isDirty, setHasUnsavedChanges]);
+    promptBeforeClosing(() => isDirty);
+  }, [isDirty, promptBeforeClosing]);
 
   const responsiveSize = isTablet ? 'lg' : 'sm';
 
   return (
     <>
-      <Form
-        className={styles.orderForm}
-        onSubmit={handleSubmit(initialOrder?.action == 'REVISE' ? submitDrugOrderToServer : saveOrderToBasket, onError)}
-        id="drugOrderForm"
-      >
+      <Form className={styles.orderForm} onSubmit={handleSubmit(handleFormSubmission, 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>
-                <label className={styles.testTypeLabel}>{t('testType', 'Test type')}</label>
+                <span className={styles.testTypeLabel}>{t('testType', 'Test type')}</span>
                 <p className={styles.testType}>{initialOrder?.concept?.display}</p>
               </InputWrapper>
             </Column>
@@ -335,12 +294,7 @@ export function OrderForm({
           <ButtonSet
             className={classNames(styles.buttonSet, isTablet ? styles.tabletButtonSet : styles.desktopButtonSet)}
           >
-            <Button
-              className={styles.button}
-              kind="secondary"
-              onClick={initialOrder?.action == 'REVISE' ? closeModifyOrderWorkspace : cancelOrder}
-              size="xl"
-            >
+            <Button className={styles.button} kind="secondary" onClick={cancelOrder} size="xl">
               {t('discard', 'Discard')}
             </Button>
             <Button className={styles.button} kind="primary" size="xl" type="submit">

package/src/order-basket/general-order-type/{general-order-panel.component.tsx → general-order-type.component.tsx}

@@ -1,7 +1,15 @@
 import React, { type ComponentProps, useCallback, useEffect, useMemo, useState } from 'react';
 import { Button, Tile } from '@carbon/react';
 import classNames from 'classnames';
-import { AddIcon, ChevronDownIcon, ChevronUpIcon, MaybeIcon, useLayoutType } from '@openmrs/esm-framework';
+import {
+  AddIcon,
+  ChevronDownIcon,
+  ChevronUpIcon,
+  type DefaultWorkspaceProps,
+  MaybeIcon,
+  useLayoutType,
+  launchWorkspace,
+} from '@openmrs/esm-framework';
 import { useTranslation } from 'react-i18next';
 import { type OrderBasketItem, useOrderBasket, useOrderType } from '@openmrs/esm-patient-common-lib';
 import { type OrderTypeDefinition } from '../../config-schema';
@@ -10,24 +18,11 @@ import OrderBasketItemTile from './order-basket-item-tile.component';
 import styles from './general-order-panel.scss';
 
 interface GeneralOrderTypeProps extends OrderTypeDefinition {
+  closeWorkspace: DefaultWorkspaceProps['closeWorkspace'];
   patient: fhir.Patient;
-  orderTypeUuid: string;
-  launchGeneralOrderForm(orderTypeUuid: string, order?: OrderBasketItem): void;
 }
 
-/**
- * The extension is slotted into order-basket-slot in the main Order Basket workspace by default.
- * It renders the "Add +" button for general orders, and lists pending general orders in the order basket.
- *
- * Designs: https://app.zeplin.io/project/60d59321e8100b0324762e05/screen/62c6bb9500e7671a618efa56
- */
-const GeneralOrderPanel: React.FC<GeneralOrderTypeProps> = ({
-  patient,
-  orderTypeUuid,
-  label,
-  icon,
-  launchGeneralOrderForm,
-}) => {
+const GeneralOrderType: React.FC<GeneralOrderTypeProps> = ({ patient, orderTypeUuid, closeWorkspace, label, icon }) => {
   const { t } = useTranslation();
   const isTablet = useLayoutType() === 'tablet';
   const { orderType, isLoadingOrderType } = useOrderType(orderTypeUuid);
@@ -70,6 +65,29 @@ const GeneralOrderPanel: React.FC<GeneralOrderTypeProps> = ({
     };
   }, [orders]);
 
+  const openConceptSearch = () => {
+    closeWorkspace({
+      ignoreChanges: true,
+      onWorkspaceClose: () =>
+        launchWorkspace('orderable-concept-workspace', {
+          orderTypeUuid,
+        }),
+      closeWorkspaceGroup: false,
+    });
+  };
+
+  const openOrderForm = (order: OrderBasketItem) => {
+    closeWorkspace({
+      ignoreChanges: true,
+      onWorkspaceClose: () =>
+        launchWorkspace('orderable-concept-workspace', {
+          order,
+          orderTypeUuid,
+        }),
+      closeWorkspaceGroup: false,
+    });
+  };
+
   const removeOrder = useCallback(
     (order: OrderBasketItem) => {
       const newOrders = [...orders];
@@ -102,7 +120,7 @@ const GeneralOrderPanel: React.FC<GeneralOrderTypeProps> = ({
             kind="ghost"
             renderIcon={(props: ComponentProps<typeof AddIcon>) => <AddIcon size={16} {...props} />}
             iconDescription={t('addMedication', 'Add medication')}
-            onClick={() => launchGeneralOrderForm(orderTypeUuid)}
+            onClick={openConceptSearch}
             size={isTablet ? 'md' : 'sm'}
           >
             {t('add', 'Add')}
@@ -130,7 +148,7 @@ const GeneralOrderPanel: React.FC<GeneralOrderTypeProps> = ({
                 <OrderBasketItemTile
                   key={`incomplete-${order.action}-${order.concept?.uuid}-${index}`}
                   orderBasketItem={order}
-                  onItemClick={() => launchGeneralOrderForm(orderTypeUuid, order)}
+                  onItemClick={() => openOrderForm(order)}
                   onRemoveClick={() => removeOrder(order)}
                 />
               ))}
@@ -142,7 +160,7 @@ const GeneralOrderPanel: React.FC<GeneralOrderTypeProps> = ({
                 <OrderBasketItemTile
                   key={`new-${order.action}-${order.concept?.uuid}-${index}`}
                   orderBasketItem={order}
-                  onItemClick={() => launchGeneralOrderForm(orderTypeUuid, order)}
+                  onItemClick={() => openOrderForm(order)}
                   onRemoveClick={() => removeOrder(order)}
                 />
               ))}
@@ -155,7 +173,7 @@ const GeneralOrderPanel: React.FC<GeneralOrderTypeProps> = ({
                 <OrderBasketItemTile
                   key={`renewed-${item.action}-${item.concept?.uuid}-${index}`}
                   orderBasketItem={item}
-                  onItemClick={() => launchGeneralOrderForm(orderTypeUuid, item)}
+                  onItemClick={() => openOrderForm(item)}
                   onRemoveClick={() => removeOrder(item)}
                 />
               ))}
@@ -168,7 +186,7 @@ const GeneralOrderPanel: React.FC<GeneralOrderTypeProps> = ({
                 <OrderBasketItemTile
                   key={`revised-${item.action}-${item.concept?.uuid}-${index}`}
                   orderBasketItem={item}
-                  onItemClick={() => launchGeneralOrderForm(orderTypeUuid, item)}
+                  onItemClick={() => openOrderForm(item)}
                   onRemoveClick={() => removeOrder(item)}
                 />
               ))}
@@ -181,7 +199,7 @@ const GeneralOrderPanel: React.FC<GeneralOrderTypeProps> = ({
                 <OrderBasketItemTile
                   key={`discontinued-${item.action}-${item.concept?.uuid}-${index}`}
                   orderBasketItem={item}
-                  onItemClick={() => launchGeneralOrderForm(orderTypeUuid, item)}
+                  onItemClick={() => openOrderForm(item)}
                   onRemoveClick={() => removeOrder(item)}
                 />
               ))}
@@ -193,4 +211,4 @@ const GeneralOrderPanel: React.FC<GeneralOrderTypeProps> = ({
   );
 };
 
-export default GeneralOrderPanel;
+export default GeneralOrderType;