@openmrs/esm-patient-medications-app 11.3.1-pre.9641 → 11.3.1-pre.9645

package/src/add-drug-order/drug-order-form.component.tsx

@@ -32,9 +32,7 @@ import {
   parseDate,
   showSnackbar,
   useConfig,
-  useFeatureFlag,
   useLayoutType,
-  useSession,
   Workspace2,
   type Visit,
 } from '@openmrs/esm-framework';
@@ -51,31 +49,21 @@ import {
 } from '@openmrs/esm-patient-common-lib';
 import { useOrderConfig } from '../api/order-config';
 import { type ConfigObject } from '../config-schema';
-import { type Provider, useActivePatientOrders, useProviders } from '../api';
+import { useActivePatientOrders } from '../api';
 import styles from './drug-order-form.scss';
-import {
-  drugOrderBasketItemToFormValue,
-  type MedicationOrderFormData,
-  useDrugOrderForm,
-} from './drug-order-form.resource';
-import DrugSearchComboBox from './drug-search/drug-search-combobox.component';
+import { type MedicationOrderFormData, useDrugOrderForm } from './drug-order-form.resource';
 
 export interface DrugOrderFormProps {
-  initialOrderBasketItem: DrugOrderBasketItem;
+  /**
+   * This is either an order pending in the order basket, or an existing order saved to the backend for editing.
+   */
+  initialOrderBasketItem: DrugOrderBasketItem | null;
   patient: fhir.Patient;
   visitContext: Visit;
   onSave: (finalizedOrder: DrugOrderBasketItem) => Promise<void>;
   saveButtonText: string;
   onCancel: () => void;
   workspaceTitle: string;
-
-  /**
-   * If true, allows user to select the prescribing provider when ordering medications from the order basket.
-   * (Otherwise, the prescribing provider always defaults to the current user.)
-   * The `prescriberProviderRoles` config must be set for this to work properly.
-   */
-  allowSelectingPrescribingClinician: boolean;
-  allowSelectingDrug: boolean;
 }
 
 function MedicationInfoHeader({
@@ -125,37 +113,21 @@ function InputWrapper({ children }) {
 }
 
 export function DrugOrderForm({
-  initialOrderBasketItem,
+  initialOrderBasketItem: initialOrderBasketItem,
   patient,
   onSave,
   saveButtonText,
   onCancel,
-  allowSelectingPrescribingClinician,
-  allowSelectingDrug,
   visitContext,
   workspaceTitle,
 }: DrugOrderFormProps) {
   const { t } = useTranslation();
-  const { daysDurationUnit, prescriberProviderRoles } = useConfig<ConfigObject>();
+  const { daysDurationUnit } = useConfig<ConfigObject>();
   const isTablet = useLayoutType() === 'tablet';
   const { orderConfigObject, error: errorFetchingOrderConfig } = useOrderConfig();
 
-  const isProviderManagementModuleInstalled = useFeatureFlag('providermanagement-module');
-  const allowAndSupportSelectingPrescribingClinician =
-    isProviderManagementModuleInstalled && allowSelectingPrescribingClinician;
-
-  const {
-    data: providers,
-    isLoading: isLoadingProviders,
-    error: errorLoadingProviders,
-  } = useProviders(allowAndSupportSelectingPrescribingClinician ? prescriberProviderRoles : null);
   const [isSaving, setIsSaving] = useState(false);
-
-  const { currentProvider } = useSession();
-  const defaultPrescribingProvider = allowAndSupportSelectingPrescribingClinician
-    ? providers?.find((p) => p.uuid === currentProvider.uuid)
-    : currentProvider;
-  const drugOrderForm = useDrugOrderForm(initialOrderBasketItem, defaultPrescribingProvider?.uuid);
+  const drugOrderForm = useDrugOrderForm(initialOrderBasketItem);
   const {
     control,
     formState: { isDirty },
@@ -198,11 +170,9 @@ export function DrugOrderForm({
   const startDate = watch('startDate');
 
   const handleFormSubmission = async (data: MedicationOrderFormData) => {
-    const newBasketItems = {
+    const newBasketItem = {
       ...initialOrderBasketItem,
       drug: data.drug,
-      orderer: data.orderer.uuid,
-      careSetting: data.careSetting,
       isFreeTextDosage: data.isFreeTextDosage,
       freeTextDosage: data.freeTextDosage,
       dosage: data.dosage,
@@ -219,9 +189,14 @@ export function DrugOrderForm({
       indication: data.indication,
       frequency: data.frequency,
       startDate: data.startDate,
+      action: initialOrderBasketItem?.action ?? 'NEW',
+      commonMedicationName: data.drug.display,
+      display: data.drug.display,
+      visit: initialOrderBasketItem?.visit ?? visitContext, // TODO: they really should be the same
     } as DrugOrderBasketItem;
+
     setIsSaving(true);
-    await onSave(newBasketItems);
+    await onSave(newBasketItem);
     setIsSaving(false);
   };
 
@@ -281,10 +256,6 @@ export function DrugOrderForm({
     return menu?.item?.value?.toLowerCase().includes(menu?.inputValue?.toLowerCase());
   }, []);
 
-  const filterItemsByProviderName = useCallback((menu) => {
-    return menu?.item?.person?.display?.toLowerCase().includes(menu?.inputValue?.toLowerCase());
-  }, []);
-
   const filterItemsBySynonymNames = useCallback((menu) => {
     if (menu?.inputValue?.length) {
       return menu.item?.names?.some((abbr: string) => abbr.toLowerCase().includes(menu.inputValue.toLowerCase()));
@@ -325,8 +296,10 @@ export function DrugOrderForm({
   // See: https://openmrs.atlassian.net/browse/RESTWS-1003
   const { data: activeOrders } = useActivePatientOrders(patient.id);
   const drugAlreadyPrescribedForNewOrder = useMemo(
-    () => initialOrderBasketItem.action == 'NEW' && activeOrders?.some((order) => order?.drug?.uuid === drug?.uuid),
-    [activeOrders, drug, initialOrderBasketItem.action],
+    () =>
+      (initialOrderBasketItem == null || initialOrderBasketItem?.action == 'NEW') &&
+      activeOrders?.some((order) => order?.drug?.uuid === drug?.uuid),
+    [activeOrders, drug, initialOrderBasketItem],
   );
 
   return (
@@ -361,66 +334,6 @@ export function DrugOrderForm({
               />
             )}
             <h1 className={styles.orderFormHeading}>{t('orderForm', 'Order Form')}</h1>
-            {(allowSelectingDrug || allowSelectingPrescribingClinician) && (
-              <section className={styles.formSection}>
-                <h3 className={styles.sectionHeader}>{t('prescriptionInfo', 'Prescription info')}</h3>
-                <Stack gap={5}>
-                  {allowSelectingDrug && (
-                    <InputWrapper>
-                      <DrugSearchComboBox
-                        setSelectedDrugItem={(item) => {
-                          // when selecting a new drug, it can have its own order template that populates many fields
-                          // we should just reset the entire form
-                          reset(drugOrderBasketItemToFormValue(item, startDate, currentProvider.uuid));
-                        }}
-                        visit={visitContext}
-                      />
-                      {drugAlreadyPrescribedForNewOrder && (
-                        <FormLabel className={styles.errorLabel}>
-                          {t('activePrescriptionExists', 'Active prescription exists for this drug')}
-                        </FormLabel>
-                      )}
-                      <FormLabel className={styles.errorLabel}>{drugFieldError?.message}</FormLabel>
-                    </InputWrapper>
-                  )}
-                  {allowAndSupportSelectingPrescribingClinician &&
-                    !isLoadingProviders &&
-                    (providers?.length > 0 ? (
-                      <ControlledFieldInput
-                        control={control}
-                        name="orderer"
-                        type="comboBox"
-                        getValues={getValues}
-                        id="orderer"
-                        shouldFilterItem={filterItemsByProviderName}
-                        placeholder={t('prescribingClinician', 'Prescribing Clinician')}
-                        titleText={t('prescribingClinician', 'Prescribing Clinician')}
-                        items={providers}
-                        itemToString={(item: Provider) => item?.person?.display}
-                      />
-                    ) : errorLoadingProviders ? (
-                      <InlineNotification
-                        kind="warning"
-                        lowContrast
-                        className={styles.inlineNotification}
-                        title={t('errorLoadingClinicians', 'Error loading clinicians')}
-                        subtitle={t('tryReopeningTheForm', 'Please try launching the form again')}
-                      />
-                    ) : (
-                      <InlineNotification
-                        kind="warning"
-                        lowContrast
-                        className={styles.inlineNotification}
-                        title={t('noCliniciansFound', 'No clinicians found')}
-                        subtitle={t(
-                          'noCliniciansFoundDescription',
-                          'Cannot select prescribing clinician because no clinicians with appropriate roles are found. Check configuration.',
-                        )}
-                      />
-                    ))}
-                </Stack>
-              </section>
-            )}
             <div ref={medicationInfoHeaderRef}>
               <MedicationInfoHeader dosage={dosage} drug={drug} routeValue={routeValue} unitValue={unitValue} />
             </div>

package/src/add-drug-order/drug-order-form.resource.ts

@@ -5,10 +5,10 @@ import { zodResolver } from '@hookform/resolvers/zod';
 import { z } from 'zod';
 import { parseDate, useConfig } from '@openmrs/esm-framework';
 import { type Drug, type DrugOrderBasketItem } from '@openmrs/esm-patient-common-lib';
-import { careSettingUuid, useRequireOutpatientQuantity } from '../api';
+import { useRequireOutpatientQuantity } from '../api';
 import { type ConfigObject } from '../config-schema';
 
-export function useDrugOrderForm(initialOrderBasketItem: DrugOrderBasketItem, defaultPrescribingProviderUuid: string) {
+export function useDrugOrderForm(initialOrderBasketItem: DrugOrderBasketItem) {
   const medicationOrderFormSchema = useCreateMedicationOrderFormSchema();
 
   const defaultValues = useMemo(() => {
@@ -17,8 +17,8 @@ export function useDrugOrderForm(initialOrderBasketItem: DrugOrderBasketItem, de
         ? parseDate(initialOrderBasketItem?.startDate)
         : (initialOrderBasketItem?.startDate as Date) ?? new Date();
 
-    return drugOrderBasketItemToFormValue(initialOrderBasketItem, defaultStartDate, defaultPrescribingProviderUuid);
-  }, [initialOrderBasketItem, defaultPrescribingProviderUuid]);
+    return drugOrderBasketItemToFormValue(initialOrderBasketItem, defaultStartDate);
+  }, [initialOrderBasketItem]);
 
   const drugOrderForm: UseFormReturn<MedicationOrderFormData> = useForm<MedicationOrderFormData>({
     mode: 'all',
@@ -29,17 +29,9 @@ export function useDrugOrderForm(initialOrderBasketItem: DrugOrderBasketItem, de
   return drugOrderForm;
 }
 
-export function drugOrderBasketItemToFormValue(
-  item: DrugOrderBasketItem,
-  startDate: Date,
-  providerUuid: string,
-): MedicationOrderFormData {
+export function drugOrderBasketItemToFormValue(item: DrugOrderBasketItem, startDate: Date): MedicationOrderFormData {
   return {
-    orderer: {
-      uuid: providerUuid,
-    },
     drug: item?.drug as Partial<Drug>,
-    careSetting: careSettingUuid,
     isFreeTextDosage: item?.isFreeTextDosage ?? false,
     freeTextDosage: item?.freeTextDosage,
     dosage: item?.dosage ?? null,
@@ -95,15 +87,6 @@ function useCreateMedicationOrderFormSchema() {
           },
         )
         .passthrough(),
-      orderer: z.object(
-        {
-          uuid: z.string(),
-        },
-        {
-          message: t('prescribingClinicianRequiredErrorMessage', 'Prescribing clinician is required'),
-        },
-      ),
-      careSetting: z.string(),
       freeTextDosage: z.string().refine((value) => !!value, {
         message: t('freeDosageErrorMessage', 'Add free dosage note'),
       }),

package/src/add-drug-order/drug-search/drug-search-combobox.component.tsx

@@ -7,17 +7,22 @@ import { type ConfigObject } from '../../config-schema';
 import { useTranslation } from 'react-i18next';
 
 interface DrugSearchComboBoxProps {
-  setSelectedDrugItem(drug: DrugOrderBasketItem);
+  initialOrderBasketItem: DrugOrderBasketItem;
+  setSelectedDrugItem(drug: DrugOrderBasketItem): void;
   visit: Visit;
 }
 
 /**
  * This component is a ComboBox for searching for drugs. Similar to drug-search.component.tsx,
  * but allows for custom behavior when a drug is selected.
- * This extension is currently not used anywhere in the patient-medications-app, but
- * is used by other apps (ex: dispensing) for selecting drugs.
+ * This component is currently not used anywhere in the patient-medications-app, but can be used
+ * in the future for a drug form with an inlined drug search.
  */
-const DrugSearchComboBox: React.FC<DrugSearchComboBoxProps> = ({ setSelectedDrugItem, visit }) => {
+const DrugSearchComboBox: React.FC<DrugSearchComboBoxProps> = ({
+  initialOrderBasketItem,
+  setSelectedDrugItem,
+  visit,
+}) => {
   const { daysDurationUnit } = useConfig<ConfigObject>();
   const { t } = useTranslation();
   const [drugSearchTerm, setDrugSearchTerm] = useState('');
@@ -42,10 +47,17 @@ const DrugSearchComboBox: React.FC<DrugSearchComboBoxProps> = ({ setSelectedDrug
       onChange={({ selectedItem }) => {
         setSelectedDrugItem(selectedItem);
       }}
+      initialSelectedItem={initialOrderBasketItem}
       onInputChange={(inputText) => {
         setDrugSearchTerm(inputText);
       }}
-      itemToString={(item: DrugOrderBasketItem) => item?.display ?? ''}
+      itemToString={(item: DrugOrderBasketItem) =>
+        item.display +
+        ' — ' +
+        item.drug?.strength?.toLowerCase() +
+        ' — ' +
+        item.drug?.dosageForm?.display?.toLowerCase()
+      }
       placeholder={t('searchFieldPlaceholder', 'Search for a drug or orderset (e.g. "Aspirin")')}
       titleText={t('drugName', 'Drug name')}
     />

package/src/add-drug-order/drug-search/drug-search-combobox.test.tsx

@@ -52,5 +52,7 @@ describe('DrugSearchComboBox', () => {
 });
 
 function renderDrugSearchComboBox() {
-  render(<DrugSearchComboBox setSelectedDrugItem={mockSetSelectedDrugItem} visit={null} />);
+  render(
+    <DrugSearchComboBox initialOrderBasketItem={null} setSelectedDrugItem={mockSetSelectedDrugItem} visit={null} />,
+  );
 }

package/src/add-drug-order/drug-search/drug-search.resource.tsx

@@ -180,8 +180,6 @@ export function getTemplateOrderBasketItem(
         freeTextDosage: '',
         indication: '',
         template: template.template,
-        orderer: null,
-        careSetting: null,
         quantityUnits:
           getDefault(template.template, 'quantityUnits') ?? drug?.dosageForm
             ? {
@@ -221,8 +219,6 @@ export function getTemplateOrderBasketItem(
         numRefills: null,
         freeTextDosage: '',
         indication: '',
-        orderer: null,
-        careSetting: null,
         quantityUnits: drug?.dosageForm
           ? {
               value: drug?.dosageForm?.display,

package/src/add-drug-order/exported-add-drug-order.workspace.tsx

@@ -4,7 +4,8 @@ import { type ExportedOrderBasketWindowProps, type DrugOrderBasketItem } from '@
 import AddDrugOrder from './add-drug-order.component';
 
 export interface AddDrugOrderWorkspaceAdditionalProps {
-  order: DrugOrderBasketItem;
+  order?: DrugOrderBasketItem;
+  orderToEditOrdererUuid?: string;
 }
 
 /**
@@ -12,13 +13,14 @@ export interface AddDrugOrderWorkspaceAdditionalProps {
  * @see add-drug-order.workspace.tsx
  */
 export default function ExportedAddDrugOrderWorkspace({
-  workspaceProps: { order: initialOrder },
+  workspaceProps: { order, orderToEditOrdererUuid },
   windowProps: { patient, patientUuid, visitContext },
   closeWorkspace,
-}: Workspace2DefinitionProps<AddDrugOrderWorkspaceAdditionalProps, ExportedOrderBasketWindowProps, {}>) {
+}: Workspace2DefinitionProps<AddDrugOrderWorkspaceAdditionalProps, ExportedOrderBasketWindowProps>) {
   return (
     <AddDrugOrder
-      initialOrder={initialOrder}
+      initialOrder={order}
+      orderToEditOrdererUuid={orderToEditOrdererUuid}
       patient={patient}
       patientUuid={patientUuid}
       visitContext={visitContext}

package/src/api/api.ts

@@ -1,24 +1,25 @@
 import { useCallback, useMemo } from 'react';
 import useSWR, { useSWRConfig } from 'swr';
 import useSWRImmutable from 'swr/immutable';
-import { openmrsFetch, restBaseUrl, useConfig, useOpenmrsFetchAll, type FetchResponse } from '@openmrs/esm-framework';
-import type {
-  DrugOrderBasketItem,
-  DrugOrderPost,
-  PatientOrderFetchResponse,
-  Order,
+import { openmrsFetch, restBaseUrl, useConfig, type FetchResponse } from '@openmrs/esm-framework';
+import {
+  type DrugOrderBasketItem,
+  type DrugOrderPost,
+  type PatientOrderFetchResponse,
+  type Order,
+  type PostDataPrepFunction,
+  careSettingUuid,
+  type OrderAction,
 } from '@openmrs/esm-patient-common-lib';
 import { type ConfigObject } from '../config-schema';
 
-export const careSettingUuid = '6f0c9a92-6f24-11e3-af88-005056821db0';
-
 const customRepresentation =
   'custom:(uuid,dosingType,orderNumber,accessionNumber,' +
   'patient:ref,action,careSetting:ref,previousOrder:ref,dateActivated,scheduledDate,dateStopped,autoExpireDate,' +
   'orderType:ref,encounter:(uuid,display,visit),orderer:(uuid,display,person:(display)),orderReason,orderReasonNonCoded,orderType,urgency,instructions,' +
   'commentToFulfiller,fulfillerStatus,drug:(uuid,display,strength,dosageForm:(display,uuid),concept),dose,doseUnits:ref,' +
   'frequency:ref,asNeeded,asNeededCondition,quantity,quantityUnits:ref,numRefills,dosingInstructions,' +
-  'duration,durationUnits:ref,route:ref,brandName,dispenseAsWritten)';
+  'duration,durationUnits:ref,route:ref,brandName,dispenseAsWritten,concept)';
 
 /**
  * Sorts orders by date activated in descending order.
@@ -130,18 +131,22 @@ export function usePastPatientOrders(patientUuid: string) {
   };
 }
 
-export function prepMedicationOrderPostData(
+/**
+ * Converts a DrugOrderBasketItem into an Order POST payload
+ */
+export const prepMedicationOrderPostData: PostDataPrepFunction = (
   order: DrugOrderBasketItem,
-  patientUuid: string,
-  encounterUuid: string | null,
-): DrugOrderPost {
+  patientUuid,
+  encounterUuid,
+  orderingProviderUuid,
+): DrugOrderPost => {
   if (order.action === 'NEW' || order.action === 'RENEW') {
     return {
       action: 'NEW',
       patient: patientUuid,
       type: 'drugorder',
-      careSetting: order.careSetting,
-      orderer: order.orderer,
+      careSetting: careSettingUuid,
+      orderer: orderingProviderUuid,
       encounter: encounterUuid,
       drug: order.drug.uuid,
       dose: order.dosage,
@@ -168,8 +173,8 @@ export function prepMedicationOrderPostData(
       patient: patientUuid,
       type: 'drugorder',
       previousOrder: order.previousOrder,
-      careSetting: order.careSetting,
-      orderer: order.orderer,
+      careSetting: careSettingUuid,
+      orderer: orderingProviderUuid,
       encounter: encounterUuid,
       drug: order.drug.uuid,
       dose: order.dosage,
@@ -196,9 +201,9 @@ export function prepMedicationOrderPostData(
       type: 'drugorder',
       previousOrder: order.previousOrder,
       patient: patientUuid,
-      careSetting: order.careSetting,
+      careSetting: careSettingUuid,
       encounter: encounterUuid,
-      orderer: order.orderer,
+      orderer: orderingProviderUuid,
       concept: order.drug.concept.uuid,
       drug: order.drug.uuid,
       orderReasonNonCoded: null,
@@ -206,6 +211,53 @@ export function prepMedicationOrderPostData(
   } else {
     throw new Error(`Unknown order action ${order.action}. This is a development error.`);
   }
+};
+
+/**
+ * The inverse of prepMedicationOrderPostData - converts an Order into a DrugOrderBasketItem
+ * See also the same function defined in esm-patient-orders-app/src/utils/index.ts
+ */
+export function buildMedicationOrder(order: Order, action: OrderAction): DrugOrderBasketItem {
+  return {
+    display: order.drug?.display,
+    previousOrder: action !== 'NEW' ? order.uuid : null,
+    action: action,
+    drug: order.drug,
+    dosage: order.dose,
+    unit: {
+      value: order.doseUnits?.display,
+      valueCoded: order.doseUnits?.uuid,
+    },
+    frequency: {
+      valueCoded: order.frequency?.uuid,
+      value: order.frequency?.display,
+    },
+    route: {
+      valueCoded: order.route?.uuid,
+      value: order.route?.display,
+    },
+    commonMedicationName: order.drug?.display,
+    isFreeTextDosage: order.dosingType === 'org.openmrs.FreeTextDosingInstructions',
+    freeTextDosage: order.dosingType === 'org.openmrs.FreeTextDosingInstructions' ? order.dosingInstructions : '',
+    patientInstructions: order.dosingType !== 'org.openmrs.FreeTextDosingInstructions' ? order.dosingInstructions : '',
+    asNeeded: order.asNeeded,
+    asNeededCondition: order.asNeededCondition,
+    startDate: action === 'DISCONTINUE' ? order.dateActivated : new Date(),
+    duration: order.duration,
+    durationUnit: {
+      valueCoded: order.durationUnits?.uuid,
+      value: order.durationUnits?.display,
+    },
+    pillsDispensed: order.quantity,
+    numRefills: order.numRefills,
+    indication: order.orderReasonNonCoded,
+    quantityUnits: {
+      value: order.quantityUnits?.display,
+      valueCoded: order.quantityUnits?.uuid,
+    },
+    encounterUuid: order.encounter?.uuid,
+    visit: order.encounter.visit,
+  };
 }
 
 /**
@@ -238,20 +290,3 @@ export function useRequireOutpatientQuantity(): {
 
   return results;
 }
-
-export interface Provider {
-  uuid: string;
-  person: {
-    display?: string;
-  };
-}
-
-export function useProviders(providerRoles: Array<string>) {
-  const rep = 'custom:(uuid,person:(display)';
-  const ret = useOpenmrsFetchAll<Provider>(
-    providerRoles != null ? `${restBaseUrl}/provider?providerRoles=${providerRoles.join(',')}&v=${rep})` : null,
-  );
-
-  ret.data?.sort((a, b) => (a.person?.display ?? '').localeCompare(b.person?.display ?? ''));
-  return ret;
-}

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

@@ -43,6 +43,7 @@ import {
   UserIcon,
   launchWorkspace2,
   type Encounter,
+  showModal,
 } from '@openmrs/esm-framework';
 import { useTranslation } from 'react-i18next';
 import { useReactToPrint } from 'react-to-print';
@@ -51,6 +52,7 @@ import PrintComponent from '../print/print.component';
 import styles from './medications-details-table.scss';
 import { useSWRConfig } from 'swr';
 import { type AddDrugOrderWorkspaceProps } from '../add-drug-order/add-drug-order.workspace';
+import { buildMedicationOrder } from '../api';
 
 export interface MedicationsDetailsTableProps {
   isValidating?: boolean;
@@ -414,8 +416,6 @@ function OrderBasketItemActions({
         pillsDispensed: medication.quantity,
         numRefills: medication.numRefills,
         indication: medication.orderReasonNonCoded,
-        orderer: medication.orderer.uuid,
-        careSetting: medication.careSetting.uuid,
         quantityUnits: {
           value: medication.quantityUnits?.display,
           valueCoded: medication.quantityUnits?.uuid,
@@ -433,60 +433,16 @@ function OrderBasketItemActions({
   }, [items, setItems, medication, workspaceGroupProps]);
 
   const handleModifyClick = useCallback(() => {
-    const newItem: DrugOrderBasketItem = {
-      uuid: medication.uuid,
-      display: medication.drug?.display,
-      previousOrder: medication.uuid,
-      startDate: new Date(),
-      action: 'REVISE',
-      drug: medication.drug,
-      dosage: medication.dose,
-      unit: {
-        value: medication.doseUnits?.display,
-        valueCoded: medication.doseUnits?.uuid,
-      },
-      frequency: {
-        valueCoded: medication.frequency?.uuid,
-        value: medication.frequency?.display,
-      },
-      route: {
-        valueCoded: medication.route?.uuid,
-        value: medication.route?.display,
-      },
-      commonMedicationName: medication.drug?.display,
-      isFreeTextDosage: medication.dosingType === 'org.openmrs.FreeTextDosingInstructions',
-      freeTextDosage:
-        medication.dosingType === 'org.openmrs.FreeTextDosingInstructions' ? medication.dosingInstructions : '',
-      patientInstructions:
-        medication.dosingType !== 'org.openmrs.FreeTextDosingInstructions' ? medication.dosingInstructions : '',
-      asNeeded: medication.asNeeded,
-      asNeededCondition: medication.asNeededCondition,
-      duration: medication.duration,
-      durationUnit: {
-        valueCoded: medication.durationUnits?.uuid,
-        value: medication.durationUnits?.display,
-      },
-      pillsDispensed: medication.quantity,
-      numRefills: medication.numRefills,
-      indication: medication.orderReasonNonCoded,
-      orderer: medication.orderer?.uuid,
-      careSetting: medication.careSetting?.uuid,
-      quantityUnits: {
-        value: medication.quantityUnits?.display,
-        valueCoded: medication.quantityUnits?.uuid,
-      },
-      encounterUuid: medication.encounter?.uuid,
-      visit: medication.encounter?.visit,
-    };
-    setItems([...items, newItem]);
-
     launchWorkspace2<AddDrugOrderWorkspaceProps, OrderBasketWindowProps, PatientWorkspaceGroupProps>(
       'add-drug-order',
-      { order: newItem },
+      {
+        order: buildMedicationOrder(medication, 'REVISE'),
+        orderToEditOrdererUuid: medication.orderer.uuid,
+      },
       { encounterUuid: medication.encounter.uuid },
       workspaceGroupProps,
     );
-  }, [items, setItems, medication, workspaceGroupProps]);
+  }, [medication, workspaceGroupProps]);
 
   const handleReorderClick = useCallback(() => {
     setItems([
@@ -527,8 +483,6 @@ function OrderBasketItemActions({
         pillsDispensed: medication.quantity,
         numRefills: medication.numRefills,
         indication: medication.orderReasonNonCoded,
-        orderer: medication.orderer?.uuid,
-        careSetting: medication.careSetting?.uuid,
         quantityUnits: {
           value: medication.quantityUnits?.display,
           valueCoded: medication.quantityUnits?.uuid,

package/src/config-schema.ts

@@ -36,18 +36,6 @@ export const configSchema = {
     _description: 'Whether to require an indication when placing a medication order',
     _default: true,
   },
-  prescriberProviderRoles: {
-    _type: Type.Array,
-    _description:
-      'Array of provider roles uuids. If specified, the drug order form 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 the drug order form may still do so with themselves as the prescriber.',
-    _default: [],
-  },
-  drugOrderEncounterType: {
-    _type: Type.UUID,
-    _description:
-      'The encounter type of the encounter for the Fill Prescription form. Defaults to the "Order" encounter type.',
-    _default: '39da3525-afe4-45ff-8977-c53b7b359158',
-  },
 };
 
 export interface ConfigObject {
@@ -59,6 +47,4 @@ export interface ConfigObject {
   showPrintButton: boolean;
   debounceDelayInMs: number;
   requireIndication: boolean;
-  prescriberProviderRoles: Array<string>;
-  drugOrderEncounterType: string;
 }

package/src/index.ts

@@ -46,8 +46,3 @@ export const exportedAddDrugOrderWorkspace = getAsyncLifecycle(
   () => import('./add-drug-order/exported-add-drug-order.workspace'),
   options,
 );
-
-export const fillPrescriptionFormWorkspace = getAsyncLifecycle(
-  () => import('./add-drug-order/fill-prescription-form.workspace'),
-  options,
-);

package/src/routes.json

@@ -73,14 +73,6 @@
       "component": "drugSearchComboBox"
     }
   ],
-  "workspaces": [
-    {
-      "name": "fill-prescription-form",
-      "title": "fillPrescription",
-      "component": "fillPrescriptionFormWorkspace",
-      "type": "order"
-    }
-  ],
   "workspaces2": [
     {
       "name": "add-drug-order",