@palladium-ethiopia/esm-billing-app 5.4.2-pre.30

package/src/billable-services/billable-orders/order-actions/hooks/useMedicationOrderAction.ts

@@ -0,0 +1,128 @@
+import { useTranslation } from 'react-i18next';
+import { useStockItemQuantity } from '../../useBillableItem';
+import { useBillableServices } from '../../../../bill-administration/service-catalog/billable-service.resource';
+
+import { useBillStatus } from './useBillStatus';
+import { createMedicationDispenseProps } from '../../test-order/dispense.resource';
+
+interface MedicationRequest {
+  request: fhir.MedicationRequest;
+  dispenses: Array<fhir.MedicationDispense>;
+}
+
+export function useMedicationOrderAction(medicationRequestBundle?: MedicationRequest) {
+  const { t } = useTranslation();
+  const request = medicationRequestBundle?.request;
+  const orderUuid = request?.id;
+  const patientUuid = request?.subject?.reference?.split('/')[1];
+  const drugUuid = request?.medicationReference?.reference?.split('/')[1];
+
+  const { isLoading, hasPendingPayment, itemHasBill } = useBillStatus(orderUuid, patientUuid);
+  const { stockItemQuantity, stockItemUuid } = useStockItemQuantity(drugUuid);
+  const { billableServices } = useBillableServices();
+
+  const billableItem =
+    billableServices?.filter((service) => {
+      if (service?.stockItem !== null && service?.stockItem !== undefined) {
+        const serviceStockItemUuid = service?.stockItem?.uuid;
+        return serviceStockItemUuid === stockItemUuid;
+      }
+      return false;
+    }) || [];
+  const billableItemServiceStatus = billableItem.some((item) => item.serviceStatus === 'DISABLED');
+
+  const dispenseFormProps = medicationRequestBundle ? createMedicationDispenseProps({ medicationRequestBundle }) : null;
+
+  const shouldShowBillModal =
+    stockItemQuantity > 0 && itemHasBill.length < 1 && billableItem.length > 0 && !billableItemServiceStatus;
+  const isDisabled = hasPendingPayment || (stockItemQuantity < 1 && !!drugUuid);
+  const isANonBillableItem = billableItem.length === 0;
+  const hasBeenDispensed = medicationRequestBundle?.dispenses?.length > 0;
+
+  /**
+   * Determines if modification of the medication order is allowed based on several conditions:
+   * 1. No pending payments exist
+   * 2. Stock item is available (quantity > 0)
+   * 3. Item hasn't been billed yet (no existing bills)
+   * 4. Item exists in billable items list
+   * 5. Special case: Non-billable items that haven't been dispensed can be modified
+   */
+  const shouldAllowModify = (() => {
+    // Special case: Non-billable items that haven't been dispensed can always be modified
+    if (!hasBeenDispensed && isANonBillableItem) {
+      return true;
+    }
+
+    // For all other cases, check the standard conditions
+    const hasNoPendingPayments = !hasPendingPayment;
+    const hasAvailableStock = stockItemQuantity > 0;
+    const hasNoExistingBills = itemHasBill.length < 1;
+    const isBillableItem = billableItem.length > 0;
+
+    return hasNoPendingPayments && hasAvailableStock && hasNoExistingBills && isBillableItem;
+  })();
+
+  const getButtonText = () => {
+    if (hasPendingPayment) {
+      return t('unsettledBill', 'Unsettled bill');
+    }
+
+    if (stockItemQuantity < 1 && drugUuid) {
+      return t('outOfStock', 'Out of Stock');
+    }
+
+    if (shouldShowBillModal) {
+      return t('bill', 'Bill');
+    }
+
+    return t('dispense', 'Dispense');
+  };
+  return {
+    isLoading,
+    isDisabled,
+    buttonText: getButtonText(),
+    shouldShowBillModal,
+    dispenseFormProps,
+    orderUuid,
+    patientUuid,
+    billableItem,
+    itemHasBill,
+    medicationRequestBundle,
+    hasPendingPayment,
+    shouldAllowModify,
+  };
+}
+
+import { useMemo } from 'react';
+import { FetchResponse, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { Order } from '@openmrs/esm-patient-common-lib';
+import useSWR from 'swr';
+
+const customRepresentation =
+  'custom:(uuid,dosingType,orderNumber,accessionNumber,' +
+  'patient:ref,action,careSetting:ref,previousOrder:ref,dateActivated,scheduledDate,dateStopped,autoExpireDate,' +
+  'orderType:ref,encounter:ref,orderer:(uuid,display,person:(display)),orderReason,orderReasonNonCoded,orderType,urgency,instructions,' +
+  'commentToFulfiller,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)';
+
+/**
+ * Hook to get a single order by UUID.
+ *
+ * @param orderUuid The UUID of the order to fetch.
+ */
+export function useOrderByUuid(orderUuid: string) {
+  const ordersUrl = useMemo(
+    () => (orderUuid ? `${restBaseUrl}/order/${orderUuid}?v=${customRepresentation}` : null),
+    [orderUuid],
+  );
+  const { data, error, isLoading, isValidating, mutate } = useSWR<FetchResponse<Order>, Error>(ordersUrl, openmrsFetch);
+
+  return {
+    data: data?.data,
+    error,
+    isLoading,
+    isValidating,
+    mutate,
+  };
+}

package/src/billable-services/billable-orders/order-actions/hooks/useModalHandler.ts

@@ -0,0 +1,103 @@
+import { launchWorkspace, navigate, getGlobalStore } from '@openmrs/esm-framework';
+import { Order } from '@openmrs/esm-patient-common-lib';
+import { useCallback } from 'react';
+import { mutate } from 'swr';
+
+export function useModalHandler(mutateUrl?: string) {
+  const handleModalClose = useCallback(() => {
+    if (!mutateUrl) {
+      return;
+    }
+
+    mutate((key) => typeof key === 'string' && key.startsWith(mutateUrl), undefined, {
+      revalidate: true,
+    });
+  }, [mutateUrl]);
+
+  return {
+    handleModalClose,
+  };
+}
+
+export const getWorkspaceStore = () => {
+  return getGlobalStore('workspace');
+};
+
+export const launchPrescriptionEditWorkspace = (order: Order, patientUuid: string) => {
+  const newItem = {
+    uuid: order.uuid,
+    display: order.drug?.display,
+    previousOrder: order.uuid,
+    startDate: new Date(),
+    action: 'REVISE',
+    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,
+    duration: order.duration,
+    durationUnit: {
+      valueCoded: order.durationUnits?.uuid,
+      value: order.durationUnits?.display,
+    },
+    pillsDispensed: order.quantity,
+    numRefills: order.numRefills,
+    indication: order.orderReasonNonCoded,
+    orderer: order.orderer?.uuid,
+    careSetting: order.careSetting?.uuid,
+    quantityUnits: {
+      value: order.quantityUnits?.display,
+      valueCoded: order.quantityUnits?.uuid,
+    },
+  };
+
+  const targetUrl = `\${openmrsSpaBase}/patient/${patientUuid}/chart/Medications`;
+  const workspaceName = 'add-drug-order';
+  const additionalProps = {
+    patientUuid,
+    order: newItem,
+  };
+
+  navigateAndLaunchWorkspace(targetUrl, `patient/${patientUuid}`, workspaceName, additionalProps, patientUuid);
+};
+
+export const navigateAndLaunchWorkspace = (
+  targetUrl: string,
+  contextKey: string,
+  workspaceName: string,
+  additionalProps: any,
+  patientUuid: string,
+) => {
+  const workspaceStore = getWorkspaceStore();
+
+  // Set up a one-time event listener for when navigation completes
+  const handleRoutingComplete = (event: Event) => {
+    // Remove the listener after it fires once
+    window.removeEventListener('single-spa:routing-event', handleRoutingComplete);
+
+    // Now that navigation is complete, change context and launch workspace
+    workspaceStore.setState({ context: `patient/${patientUuid}`, openWorkspaces: [], prompt: null });
+    launchWorkspace(workspaceName, additionalProps);
+  };
+
+  // Add the event listener before navigating
+  window.addEventListener('single-spa:routing-event', handleRoutingComplete);
+
+  // Navigate to the target URL
+  navigate({ to: targetUrl });
+};

package/src/billable-services/billable-orders/test-order/dispense.resource.tsx

@@ -0,0 +1,89 @@
+import dayjs from 'dayjs';
+
+type MedicationDispense = {
+  resourceType: string;
+  status: any;
+  authorizingPrescription: Array<{ reference: string; type: string }>;
+  medicationReference: any;
+  medicationCodeableConcept: any;
+  subject: any;
+  performer: Array<{ actor: { reference: string } }>;
+  location: { reference: string };
+  whenHandedOver: string;
+  quantity?: {
+    value: unknown;
+    code: unknown;
+    unit: unknown;
+    system: unknown;
+  };
+  dosageInstruction?: Array<unknown>;
+  substitution?: unknown;
+};
+
+export const createMedicationDispenseProps = (props) => {
+  const { medicationRequestBundle, quantityRemaining, session, providers = [] } = props;
+  const request = medicationRequestBundle.request;
+  const patientUuid = request?.subject?.reference?.split('/')?.[1] || null;
+  const encounterUuid = request?.encounter?.reference?.split('/')?.[1] || null;
+
+  return {
+    patientUuid,
+    encounterUuid,
+    medicationDispense: initiateMedicationDispenseBody(medicationRequestBundle.request, session, providers, true),
+    medicationRequestBundle,
+    quantityRemaining,
+    mode: 'enter',
+  };
+};
+
+export function initiateMedicationDispenseBody(medicationRequest, session, providers, populateDispenseInformation) {
+  let medicationDispense: MedicationDispense = {
+    resourceType: 'MedicationDispense',
+    status: null,
+    authorizingPrescription: [{ reference: 'MedicationRequest/' + medicationRequest.id, type: 'MedicationRequest' }],
+    medicationReference: medicationRequest.medicationReference,
+    medicationCodeableConcept: medicationRequest.medicationCodeableConcept,
+    subject: medicationRequest.subject,
+    performer: [
+      {
+        actor: {
+          reference:
+            session?.currentProvider && providers.some((provider) => provider.uuid == session.currentProvider.uuid)
+              ? `Practitioner/${session.currentProvider.uuid}`
+              : '',
+        },
+      },
+    ],
+    location: { reference: session?.sessionLocation ? `Location/${session.sessionLocation.uuid}` : '' },
+    whenHandedOver: dayjs().format(),
+  };
+
+  if (populateDispenseInformation) {
+    medicationDispense = {
+      ...medicationDispense,
+      quantity: medicationRequest.dispenseRequest?.quantity,
+      dosageInstruction: [
+        {
+          text: [
+            medicationRequest.dosageInstruction[0].text,
+            medicationRequest.dosageInstruction[0].additionalInstruction?.[0]?.text,
+          ]
+            .filter(Boolean)
+            .join(' '),
+          timing: medicationRequest.dosageInstruction[0].timing,
+          asNeededBoolean: false,
+          route: medicationRequest.dosageInstruction[0].route,
+          doseAndRate: medicationRequest.dosageInstruction[0].doseAndRate || [
+            { doseQuantity: { value: null, code: null, unit: null } },
+          ],
+        },
+      ],
+      substitution: {
+        wasSubstituted: false,
+        reason: [{ coding: [{ code: null }] }],
+        type: { coding: [{ code: null }] },
+      },
+    };
+  }
+  return medicationDispense;
+}

package/src/billable-services/billable-orders/test-order/imaging-order.component.tsx

@@ -0,0 +1,34 @@
+import React from 'react';
+import { useBillableItem } from '../useBillableItem';
+import { useTranslation } from 'react-i18next';
+import { InlineLoading } from '@carbon/react';
+import PriceInfoOrder from './price-info-order.componet';
+
+type ImagingOrderProps = {
+  order: {
+    testType?: {
+      label: string;
+      conceptUuid: string;
+    };
+  };
+  setHasPrice: (hasPrice: boolean) => void;
+};
+
+const ImagingOrder: React.FC<ImagingOrderProps> = ({ order, setHasPrice }) => {
+  const { t } = useTranslation();
+  const { billableItem, isLoading, error } = useBillableItem(order?.testType?.conceptUuid);
+
+  if (isLoading) {
+    return (
+      <InlineLoading
+        status="active"
+        iconDescription={t('loading', 'Loading')}
+        description={t('loadingData', 'Loading data...')}
+      />
+    );
+  }
+
+  return <PriceInfoOrder billableItem={billableItem} error={error} />;
+};
+
+export default ImagingOrder;

package/src/billable-services/billable-orders/test-order/lab-order.component.tsx

@@ -0,0 +1,34 @@
+import React from 'react';
+import { useBillableItem } from '../useBillableItem';
+import { useTranslation } from 'react-i18next';
+import { InlineLoading } from '@carbon/react';
+import PriceInfoOrder from './price-info-order.componet';
+
+type LabOrderProps = {
+  order: {
+    testType?: {
+      label: string;
+      conceptUuid: string;
+    };
+  };
+  setHasPrice: (hasPrice: boolean) => void;
+};
+
+const LabOrder: React.FC<LabOrderProps> = ({ order, setHasPrice }) => {
+  const { t } = useTranslation();
+  const { billableItem, isLoading, error } = useBillableItem(order?.testType?.conceptUuid);
+
+  if (isLoading) {
+    return (
+      <InlineLoading
+        status="active"
+        iconDescription={t('loading', 'Loading')}
+        description={t('loadingData', 'Loading data...')}
+      />
+    );
+  }
+
+  return <PriceInfoOrder billableItem={billableItem} error={error} />;
+};
+
+export default LabOrder;

package/src/billable-services/billable-orders/test-order/price-info-order.componet.tsx

@@ -0,0 +1,60 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import styles from './price-info-order.scss';
+import {
+  StructuredListWrapper,
+  StructuredListHead,
+  StructuredListRow,
+  StructuredListCell,
+  StructuredListBody,
+  Tile,
+  InlineNotification,
+} from '@carbon/react';
+import { useCurrencyFormatting } from '../../../helpers/currency';
+
+type PriceInfoOrderProps = {
+  billableItem: any;
+  error?: boolean;
+};
+
+const PriceInfoOrder: React.FC<PriceInfoOrderProps> = ({ billableItem, error }) => {
+  const { t } = useTranslation();
+  const { format: formatCurrency } = useCurrencyFormatting();
+
+  const hasPrice = billableItem?.servicePrices?.length > 0;
+
+  if (error || !hasPrice) {
+    return (
+      <InlineNotification kind="warning" title={t('noprice', 'No price configured for this service')} lowContrast />
+    );
+  }
+
+  return (
+    <Tile id="" className={styles.prices}>
+      <div className={styles.listContainer}>
+        <StructuredListWrapper isCondensed>
+          <StructuredListHead>
+            <StructuredListRow head>
+              <StructuredListCell head className={styles.cell}>
+                {t('paymentMethods', 'Payment methods')}
+              </StructuredListCell>
+              <StructuredListCell head className={styles.cell}>
+                {t('prices', 'Prices (Ksh)')}
+              </StructuredListCell>
+            </StructuredListRow>
+          </StructuredListHead>
+          <StructuredListBody>
+            {billableItem.servicePrices.map((priceItem: any) => (
+              <StructuredListRow key={priceItem.uuid}>
+                <StructuredListCell className={styles.cell}>{priceItem.paymentMode.name}</StructuredListCell>
+                <StructuredListCell className={styles.cell}>{formatCurrency(priceItem.price)}</StructuredListCell>
+              </StructuredListRow>
+            ))}
+          </StructuredListBody>
+        </StructuredListWrapper>
+      </div>
+    </Tile>
+  );
+};
+
+export default PriceInfoOrder;

package/src/billable-services/billable-orders/test-order/price-info-order.scss

@@ -0,0 +1,20 @@
+@use '@carbon/styles/scss/type';
+@use '@carbon/styles/scss/spacing';
+@use '@carbon/layout';
+@use '@carbon/colors';
+
+.prices {
+  justify-content: center;
+  align-items: center;
+  margin: layout.$spacing-03;
+}
+
+.listContainer {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+.cell {
+  padding: spacing.$spacing-05;
+}

package/src/billable-services/billable-orders/test-order/procedure-order.component.tsx

@@ -0,0 +1,34 @@
+import React from 'react';
+import { useBillableItem } from '../useBillableItem';
+import { useTranslation } from 'react-i18next';
+import { InlineLoading } from '@carbon/react';
+import PriceInfoOrder from './price-info-order.componet';
+
+type ProcedureOrderProps = {
+  order: {
+    testType?: {
+      label: string;
+      conceptUuid: string;
+    };
+  };
+  setHasPrice: (hasPrice: boolean) => void;
+};
+
+const ProcedureOrder: React.FC<ProcedureOrderProps> = ({ order, setHasPrice }) => {
+  const { t } = useTranslation();
+  const { billableItem, isLoading, error } = useBillableItem(order?.testType?.conceptUuid);
+
+  if (isLoading) {
+    return (
+      <InlineLoading
+        status="active"
+        iconDescription={t('loading', 'Loading')}
+        description={t('loadingData', 'Loading data...')}
+      />
+    );
+  }
+
+  return <PriceInfoOrder billableItem={billableItem} error={error} />;
+};
+
+export default ProcedureOrder;

package/src/billable-services/billable-orders/test-order/test-order-action.resource.tsx

@@ -0,0 +1,86 @@
+import { openmrsFetch, restBaseUrl, useConfig, useVisit } from '@openmrs/esm-framework';
+import useSWR from 'swr';
+import { QueueEntry } from '../../../types';
+import { BillingConfig } from '../../../config-schema';
+import { useMemo } from 'react';
+import { checkPaymentMethodExclusion, usePatientBills } from '../../../prompt-payment/prompt-payment.resource';
+
+export const useTestOrderBillStatus = (orderUuid: string, patientUuid: string) => {
+  const config = useConfig<BillingConfig>();
+  const { currentVisit, activeVisit } = useVisit(patientUuid);
+  const { isEmergencyPatient, isLoading: isLoadingQueue } = usePatientQueue(patientUuid);
+  const { isLoading, hasPendingPayment } = useOrderPendingPaymentStatus(patientUuid, orderUuid);
+
+  // We want to check if the payment method is in the excluded list this includes insurances, where patient do not need to pay immediately
+  const isExcludedPaymentMethod = checkPaymentMethodExclusion(
+    activeVisit,
+    config?.paymentMethodsUuidsThatShouldNotShowPrompt,
+  );
+
+  return useMemo(() => {
+    if (isLoading || isLoadingQueue) {
+      return { hasPendingPayment: false, isLoading: true };
+    }
+    if (activeVisit?.visitType?.uuid === config?.inPatientVisitTypeUuid || isEmergencyPatient) {
+      return { hasPendingPayment: false, isLoading: false };
+    }
+
+    if (isExcludedPaymentMethod) {
+      return { hasPendingPayment: false, isLoading: false };
+    }
+
+    return { hasPendingPayment, isLoading: false };
+  }, [
+    isLoadingQueue,
+    isLoading,
+    activeVisit?.visitType?.uuid,
+    config?.inPatientVisitTypeUuid,
+    isExcludedPaymentMethod,
+    isEmergencyPatient,
+    hasPendingPayment,
+  ]);
+};
+
+export const usePatientQueue = (patientUuid: string) => {
+  const config = useConfig<BillingConfig>();
+  const url = `${restBaseUrl}/visit-queue-entry?patient=${patientUuid}`;
+  const { data, isLoading, error } = useSWR<{
+    data: { results: Array<QueueEntry> };
+  }>(url, openmrsFetch);
+
+  return useMemo(() => {
+    const isEmergencyPatient =
+      data?.data?.results?.[0]?.queueEntry?.priority?.uuid === config?.concepts?.emergencyPriorityConceptUuid;
+    const isInQueue = data?.data?.results?.length > 0;
+    return { isInQueue, isLoading, error, isEmergencyPatient };
+  }, [data, isLoading, error, config?.concepts?.emergencyPriorityConceptUuid]);
+};
+
+export const useOrderPendingPaymentStatus = (patientUuid: string, orderUuid: string) => {
+  const { patientBills, isLoading, error } = usePatientBills(patientUuid);
+  const flattenedLineItems = useMemo(() => {
+    return patientBills
+      ?.map((bill) => bill.lineItems)
+      .flat()
+      .filter((lineItem) => lineItem.order && lineItem.order.uuid === orderUuid);
+  }, [patientBills, orderUuid]);
+
+  const hasPendingPayment = useMemo(() => {
+    return flattenedLineItems?.some(
+      (lineItem) => lineItem.paymentStatus === 'PENDING' || lineItem.paymentStatus === 'POSTED',
+    );
+  }, [flattenedLineItems]);
+
+  return useMemo(() => ({ hasPendingPayment, isLoading, error }), [hasPendingPayment, isLoading, error]);
+};
+
+export const useOrderBill = (patientUuid: string, orderUuid: string) => {
+  const { patientBills, isLoading, error } = usePatientBills(patientUuid);
+  const itemHasBill = useMemo(() => {
+    return patientBills
+      ?.map((bill) => bill.lineItems)
+      .flat()
+      .filter((lineItem) => lineItem.order && lineItem.order.uuid === orderUuid);
+  }, [patientBills, orderUuid]);
+  return { itemHasBill };
+};

package/src/billable-services/billable-orders/test-order/test-order-action.scss

@@ -0,0 +1,12 @@
+@use '@carbon/type';
+@use '@carbon/layout';
+@use '@carbon/colors';
+
+.actionButton {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  text-align: center;
+  padding: 0 layout.$spacing-04;
+  font-size: type.type-scale(2);
+}

package/src/billable-services/billable-orders/useBillableItem.tsx

@@ -0,0 +1,69 @@
+import useSWRImmutable from 'swr/immutable';
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import useSWR from 'swr';
+import first from 'lodash-es/first';
+
+type BillableItemResponse = {
+  uuid: string;
+  name: string;
+  concept: {
+    uuid: string;
+    display: string;
+  };
+  servicePrices: Array<{
+    uuid: string;
+    price: number;
+    paymentMode: {
+      uuid: string;
+      name: string;
+    };
+  }>;
+};
+
+export const useBillableItem = (billableItemId: string, drugUuid?: string) => {
+  const customRepresentation = `v=custom:(uuid,name,concept:(uuid,display),servicePrices:(uuid,price,paymentMode:(uuid,name)))`;
+  const url = drugUuid
+    ? `${restBaseUrl}/cashier/billableService?${customRepresentation}&drugUuid=${drugUuid}`
+    : `${restBaseUrl}/cashier/billableService?${customRepresentation}`;
+  const { data, error, isLoading } = useSWRImmutable<{ data: { results: Array<BillableItemResponse> } }>(
+    url,
+    openmrsFetch,
+  );
+  const billableItem = drugUuid
+    ? first(data?.data?.results)
+    : data?.data?.results?.find((item) => item?.concept?.uuid === billableItemId);
+
+  return {
+    billableItem: billableItem,
+    isLoading: isLoading,
+    error,
+  };
+};
+
+export const useSockItemInventory = (stockItemId: string) => {
+  const url = `/ws/rest/v1/stockmanagement/stockiteminventory?v=default&limit=10&totalCount=true&drugUuid=${stockItemId}`;
+  const { data, error, isLoading } = useSWR<{
+    data: { results: Array<{ quantityUoM: string; quantity: number; partyName: string }> };
+  }>(url, openmrsFetch);
+  return {
+    stockItem: (data?.data?.results as Array<any>) ?? [],
+    isLoading: isLoading,
+    error,
+  };
+};
+
+export const useStockItemQuantity = (drugUuid: string) => {
+  const url = `/ws/rest/v1/stockmanagement/stockiteminventory?v=default&limit=10&totalCount=true&drugUuid=${drugUuid}`;
+  const { data, error, isLoading } = useSWR<{
+    data: {
+      results: Array<{ quantityUoM: string; quantity: number; partyName: string; stockItemUuid: string }>;
+      total: number;
+    };
+  }>(url, openmrsFetch);
+  return {
+    stockItemQuantity: data?.data?.total ?? 0,
+    stockItemUuid: data?.data?.results[0]?.stockItemUuid ?? '',
+    isLoading: isLoading,
+    error,
+  };
+};