@kenyaemr/esm-patient-clinical-view-app 5.4.2-pre.2714 → 5.4.2-pre.2722

package/src/maternal-and-child-health/partography/resources/drugs-fluids.resource.ts

@@ -0,0 +1,88 @@
+import { useMemo } from 'react';
+import useSWR from 'swr';
+
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { createPartographyEncounter } from '../partography.resource';
+import { useTranslation } from 'react-i18next';
+import { DRUG_ORDER_TYPE_UUID } from '../../../config-schema';
+
+export async function saveDrugOrderData(
+  patientUuid: string,
+  formData: {
+    drugName: string;
+    dosage: string;
+    route: string;
+    frequency: string;
+  },
+  t: (key: string, defaultValue?: string) => string,
+): Promise<{ success: boolean; message: string }> {
+  try {
+    const result = await createPartographyEncounter(patientUuid, 'drugs-fluids', formData);
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      message: error?.message || t('Failed to save drug order data'),
+    };
+  }
+}
+
+export function useDrugOrders(patientUuid: string) {
+  const { t } = useTranslation();
+  const apiUrl = patientUuid
+    ? `${restBaseUrl}/order?patient=${patientUuid}&orderType=${DRUG_ORDER_TYPE_UUID}&v=full&limit=50`
+    : null;
+
+  const { data, error, isLoading, mutate } = useSWR(apiUrl, openmrsFetch);
+
+  const drugOrders = useMemo(() => {
+    const responseData = data?.data as any;
+
+    if (!responseData?.results || !Array.isArray(responseData.results)) {
+      return [];
+    }
+
+    const allOrders = responseData.results;
+    const activeOrders = allOrders
+      .filter((order: any) => order.action === 'NEW' && !order.dateStopped)
+      .sort((a: any, b: any) => {
+        const dateA = a.dateActivated ? new Date(a.dateActivated).getTime() : 0;
+        const dateB = b.dateActivated ? new Date(b.dateActivated).getTime() : 0;
+        return dateB - dateA;
+      });
+
+    const processedOrders = activeOrders.map((order: any) => {
+      const processed = {
+        id: order.uuid,
+        drugName: order.drug?.display || order.drugNonCoded || t('Unknown Drug'),
+        dosage: `${order.dose || ''} ${order.doseUnits?.display || ''}`.trim(),
+        route: order.route?.display || '',
+        frequency: order.frequency?.display || '',
+        date: order.dateActivated ? new Date(order.dateActivated).toLocaleDateString() : '',
+        orderNumber: order.orderNumber,
+        display: order.display,
+        quantity: order.quantity,
+        duration: order.duration,
+        durationUnits: order.durationUnits?.display,
+        asNeeded: order.asNeeded,
+        instructions: order.instructions,
+        orderer: order.orderer?.display,
+      };
+      return processed;
+    });
+
+    return processedOrders;
+  }, [data, t]);
+
+  let localizedError = error;
+  if (error) {
+    localizedError = t('Failed to load drug orders');
+  }
+
+  return {
+    drugOrders,
+    isLoading,
+    error: localizedError,
+    mutate,
+  };
+}

package/src/maternal-and-child-health/partography/resources/fetal-heart-rate.resource.ts

@@ -0,0 +1,122 @@
+import React from 'react';
+import { openmrsFetch, restBaseUrl, toOmrsIsoString } from '@openmrs/esm-framework';
+import useSWR from 'swr';
+import { MCH_PARTOGRAPHY_ENCOUNTER_UUID, PARTOGRAPHY_CONCEPTS } from '../types';
+import { createPartographyEncounter } from '../partography.resource';
+import { useTranslation } from 'react-i18next';
+
+export interface FetalHeartRateEntry {
+  id: string;
+  uuid: string;
+  encounterUuid: string;
+  fetalHeartRate: number;
+  hour: number;
+  time: string;
+  date: string;
+  encounterDatetime: string;
+  obsDatetime: string;
+}
+
+export function useFetalHeartRateData(patientUuid: string) {
+  const { t } = useTranslation();
+  const fetcher = (url: string) => openmrsFetch(url).then((res) => res.json());
+  const { data, error, isLoading, mutate } = useSWR(
+    patientUuid
+      ? `${restBaseUrl}/encounter?patient=${patientUuid}&encounterType=${MCH_PARTOGRAPHY_ENCOUNTER_UUID}&v=full&limit=100&order=desc`
+      : null,
+    fetcher,
+  );
+  const fetalHeartRateData: FetalHeartRateEntry[] = React.useMemo(() => {
+    if (!data?.results || !Array.isArray(data.results)) {
+      return [];
+    }
+    const fetalHeartRateEntries: FetalHeartRateEntry[] = [];
+    for (const encounter of data.results) {
+      if (!encounter.obs || !Array.isArray(encounter.obs)) {
+        continue;
+      }
+      const fetalHeartRateObs = encounter.obs.find(
+        (obs) => obs.concept.uuid === PARTOGRAPHY_CONCEPTS['fetal-heart-rate'],
+      );
+      if (fetalHeartRateObs) {
+        const encounterDatetime = new Date(encounter.encounterDatetime);
+        let hour = 0;
+        let time = '';
+        const hourObs = encounter.obs.find(
+          (obs) =>
+            obs.concept.uuid === PARTOGRAPHY_CONCEPTS['fetal-heart-rate-hour'] &&
+            obs.value &&
+            typeof obs.value === 'string' &&
+            obs.value.startsWith('Hour:'),
+        );
+        const timeObs = encounter.obs.find(
+          (obs) =>
+            obs.concept.uuid === PARTOGRAPHY_CONCEPTS['fetal-heart-rate-time'] &&
+            obs.value &&
+            typeof obs.value === 'string' &&
+            obs.value.startsWith('Time:'),
+        );
+        if (hourObs && typeof hourObs.value === 'string') {
+          const hourMatch = hourObs.value.match(/Hour:\s*([0-9.]+)/);
+          if (hourMatch) {
+            hour = parseFloat(hourMatch[1]) || 0;
+          }
+        }
+        if (timeObs && typeof timeObs.value === 'string') {
+          const timeMatch = timeObs.value.match(/Time:\s*(.+)/);
+          if (timeMatch) {
+            time = timeMatch[1].trim();
+          }
+        }
+        fetalHeartRateEntries.push({
+          id: `fhr-${fetalHeartRateObs.uuid}`,
+          uuid: fetalHeartRateObs.uuid,
+          encounterUuid: encounter.uuid,
+          fetalHeartRate: parseFloat(fetalHeartRateObs.value) || 0,
+          hour,
+          time,
+          date: encounterDatetime.toLocaleDateString(),
+          encounterDatetime: encounterDatetime.toISOString(),
+          obsDatetime: fetalHeartRateObs.obsDatetime,
+        });
+      }
+    }
+    return fetalHeartRateEntries.sort(
+      (a, b) => new Date(b.encounterDatetime).getTime() - new Date(a.encounterDatetime).getTime(),
+    );
+  }, [data]);
+  let localizedError = error;
+  if (error) {
+    localizedError = t('Failed to load fetal heart rate data');
+  }
+  return {
+    fetalHeartRateData,
+    isLoading,
+    error: localizedError,
+    mutate,
+  };
+}
+
+export async function saveFetalHeartRateData(
+  patientUuid: string,
+  formData: { hour: number; time: string; fetalHeartRate: number },
+  t: (key: string, defaultValue?: string, options?: any) => string,
+  locationUuid?: string,
+  providerUuid?: string,
+): Promise<{ success: boolean; message: string }> {
+  try {
+    const result = await createPartographyEncounter(
+      patientUuid,
+      'fetal-heart-rate',
+      formData,
+      locationUuid,
+      providerUuid,
+    );
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      message: error?.message || t('Failed to save fetal heart rate data'),
+    };
+  }
+}

package/src/maternal-and-child-health/partography/resources/maternal-pulse.resource.ts

@@ -0,0 +1,77 @@
+import { useTranslation } from 'react-i18next';
+import { usePartographyEncounters } from '../partography.resource';
+import { PARTOGRAPHY_CONCEPTS } from '../types';
+import { toOmrsIsoString } from '@openmrs/esm-framework';
+
+export function transformMaternalPulseEncounterToChartData(
+  encounters: any[],
+  t: (key: string, defaultValue?: string, options?: any) => string,
+): any[] {
+  const chartData = [];
+  encounters.forEach((encounter) => {
+    const encounterTime = new Date(encounter.encounterDatetime).toLocaleTimeString('en-US', {
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false,
+    });
+    encounter.obs?.forEach((obs) => {
+      if (obs.concept.uuid === PARTOGRAPHY_CONCEPTS['maternal-pulse']) {
+        chartData.push({ group: t('Maternal Pulse'), time: encounterTime, value: parseFloat(obs.value) });
+      }
+    });
+  });
+  return chartData;
+}
+
+export function transformMaternalPulseEncounterToTableData(
+  encounters: any[],
+  t: (key: string, defaultValue?: string, options?: any) => string,
+): any[] {
+  const tableData = [];
+  encounters.forEach((encounter, index) => {
+    const encounterDate = new Date(encounter.encounterDatetime);
+    const dateTime = `${encounterDate.toLocaleDateString()}  ${encounterDate.toLocaleTimeString('en-US', {
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false,
+    })}`;
+    encounter.obs?.forEach((obs, obsIndex) => {
+      if (obs.concept.uuid === PARTOGRAPHY_CONCEPTS['maternal-pulse']) {
+        tableData.push({
+          id: `maternal-pulse-${index}-${obsIndex}`,
+          dateTime,
+          value: parseFloat(obs.value),
+          unit: t('BPM'),
+        });
+      }
+    });
+  });
+  return tableData;
+}
+
+export function useMaternalPulseData(patientUuid: string) {
+  const { encounters, isLoading, error, mutate } = usePartographyEncounters(patientUuid, 'maternal-pulse');
+  return { data: encounters, isLoading, error, mutate };
+}
+
+export function buildMaternalPulseObservation(formData: any): any[] {
+  const timeConfig = { defaultEncounterOffset: 0 };
+  const obsDatetime = toOmrsIsoString(new Date(Date.now() - timeConfig.defaultEncounterOffset));
+  const observations = [];
+  if (formData.value || formData.measurementValue) {
+    observations.push({
+      concept: PARTOGRAPHY_CONCEPTS['maternal-pulse'],
+      value: parseFloat(formData.value || formData.measurementValue),
+      obsDatetime,
+    });
+  }
+  // Optional time slot observation for pulse/BP graph (if provided by the form)
+  if (formData.time || formData.timeSlot) {
+    observations.push({
+      concept: PARTOGRAPHY_CONCEPTS['pulse-time-slot'] || PARTOGRAPHY_CONCEPTS['time-slot'],
+      value: formData.time || formData.timeSlot,
+      obsDatetime,
+    });
+  }
+  return observations;
+}

package/src/maternal-and-child-health/partography/resources/membrane-amniotic-fluid.resource.ts

@@ -0,0 +1,108 @@
+import { useMemo } from 'react';
+import useSWR from 'swr';
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { PARTOGRAPHY_CONCEPTS, MCH_PARTOGRAPHY_ENCOUNTER_UUID } from '../types';
+import { createPartographyEncounter } from '../partography.resource';
+import { useTranslation } from 'react-i18next';
+
+export function useMembraneAmnioticFluidData(patientUuid: string) {
+  const { t } = useTranslation();
+  const fetcher = (url: string) => openmrsFetch(url).then((res) => res.json());
+
+  const { data, error, isLoading, mutate } = useSWR(
+    patientUuid
+      ? `${restBaseUrl}/encounter?patient=${patientUuid}&encounterType=${MCH_PARTOGRAPHY_ENCOUNTER_UUID}&v=full&limit=100&order=desc`
+      : null,
+    fetcher,
+    {
+      revalidateOnFocus: true,
+      revalidateOnReconnect: true,
+    },
+  );
+
+  const membraneAmnioticFluidEntries = useMemo(() => {
+    if (!data?.results || !Array.isArray(data.results)) {
+      return [];
+    }
+
+    const entries = [];
+    for (const encounter of data.results) {
+      if (!encounter.obs || !Array.isArray(encounter.obs)) {
+        continue;
+      }
+
+      const amnioticFluidObs = encounter.obs.find((obs) => obs.concept.uuid === PARTOGRAPHY_CONCEPTS['amniotic-fluid']);
+      const mouldingObs = encounter.obs.find((obs) => obs.concept.uuid === PARTOGRAPHY_CONCEPTS['moulding']);
+      const timeObs = encounter.obs.find(
+        (obs) =>
+          obs.concept.uuid === PARTOGRAPHY_CONCEPTS['fetal-heart-rate-time'] &&
+          typeof obs.value === 'string' &&
+          obs.value.startsWith('Time:'),
+      );
+
+      let time = '';
+      if (timeObs && typeof timeObs.value === 'string') {
+        const timeMatch = timeObs.value.match(/Time:\s*(.+)/);
+        if (timeMatch) {
+          time = timeMatch[1].trim();
+        }
+      }
+
+      if (amnioticFluidObs || mouldingObs) {
+        entries.push({
+          id: `maf-${encounter.uuid}`,
+          uuid: encounter.uuid,
+          amnioticFluid: amnioticFluidObs?.value?.display || amnioticFluidObs?.value || '',
+          moulding: mouldingObs?.value?.display || mouldingObs?.value || '',
+          time,
+          date: new Date(encounter.encounterDatetime).toLocaleDateString(),
+          encounterDatetime: encounter.encounterDatetime,
+        });
+      }
+    }
+    return entries;
+  }, [data]);
+
+  let localizedError = error;
+  if (error) {
+    localizedError = t('Failed to load membrane amniotic fluid data');
+  }
+
+  return {
+    membraneAmnioticFluidEntries,
+    isLoading,
+    error: localizedError,
+    mutate,
+  };
+}
+
+export async function saveMembraneAmnioticFluidData(
+  patientUuid: string,
+  formData: { amnioticFluid: string; moulding: string; time: string },
+  t: (key: string, defaultValue?: string, options?: any) => string,
+  locationUuid?: string,
+  providerUuid?: string,
+): Promise<{ success: boolean; message: string }> {
+  try {
+    const result = await createPartographyEncounter(
+      patientUuid,
+      'membrane-amniotic-fluid',
+      formData,
+      locationUuid,
+      providerUuid,
+    );
+    if (result?.success && result?.encounter) {
+      return result;
+    } else {
+      return {
+        success: false,
+        message: result?.message || t('Failed to save membrane amniotic fluid data'),
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      message: error?.message || t('Failed to save membrane amniotic fluid data'),
+    };
+  }
+}

package/src/maternal-and-child-health/partography/resources/oxytocin.resource.ts

@@ -0,0 +1,159 @@
+import { openmrsFetch, restBaseUrl, toOmrsIsoString } from '@openmrs/esm-framework';
+import useSWR from 'swr';
+import { useTranslation } from 'react-i18next';
+import { MCH_PARTOGRAPHY_ENCOUNTER_UUID } from '../forms/useCervixData';
+import { ENCOUNTER_ROLE } from '../../../config-schema';
+import { OXYTOCIN_FORM_CONCEPTS } from '../types';
+
+export interface OxytocinFormData {
+  time: string;
+  dropsPerMinute: string;
+}
+
+export interface SaveOxytocinDataResponse {
+  success: boolean;
+  message: string;
+  encounter?: any;
+  error?: string;
+}
+
+export function useOxytocinData(patientUuid: string) {
+  const { t } = useTranslation();
+  const encounterRepresentation =
+    'custom:(uuid,encounterDatetime,encounterType:(uuid,display),' +
+    'obs:(uuid,concept:(uuid,display),value,obsDatetime,display),' +
+    'patient:(uuid))';
+
+  const url = `/ws/rest/v1/encounter?patient=${patientUuid}&encounterType=${MCH_PARTOGRAPHY_ENCOUNTER_UUID}&v=${encounterRepresentation}`;
+
+  const { data, error, isLoading, mutate } = useSWR<{ data: { results: any[] } }>(
+    patientUuid ? url : null,
+    openmrsFetch,
+  );
+  const oxytocinData = data?.data?.results || [];
+  const sortedEncounters = oxytocinData.sort(
+    (a, b) => new Date(b.encounterDatetime).getTime() - new Date(a.encounterDatetime).getTime(),
+  );
+  const transformedData = sortedEncounters.map((encounter) => {
+    const observations = encounter.obs || [];
+    const timeObs = observations.find((obs) => obs.concept.uuid === OXYTOCIN_FORM_CONCEPTS.time);
+    const dropsObs = observations.find((obs) => obs.concept.uuid === OXYTOCIN_FORM_CONCEPTS.oxytocinDropsPerMinute);
+    return {
+      uuid: encounter.uuid,
+      encounterDatetime: encounter.encounterDatetime,
+      time: timeObs?.value ? String(timeObs.value) : null,
+      dropsPerMinute: dropsObs?.value ? Number(dropsObs.value) : null,
+      timeDisplay: timeObs?.value ? `${timeObs.value}` : null,
+    };
+  });
+  const existingOxytocinEntries = transformedData
+    .filter((data) => data.time !== null && data.dropsPerMinute !== null)
+    .map((data) => ({ time: data.time!, dropsPerMinute: data.dropsPerMinute! }));
+
+  let localizedError = error;
+  if (error) {
+    localizedError = t('Failed to load oxytocin data');
+  }
+
+  return {
+    encounters: sortedEncounters,
+    oxytocinData: transformedData,
+    existingOxytocinEntries,
+    isLoading,
+    error: localizedError,
+    mutate,
+  };
+}
+
+export async function saveOxytocinFormData(
+  patientUuid: string,
+  formData: OxytocinFormData,
+  t: (key: string, defaultValue?: string, options?: any) => string,
+  providerUuid?: string,
+  locationUuid?: string,
+): Promise<SaveOxytocinDataResponse> {
+  const observations = buildOxytocinObservations(formData);
+  const missingFields = [];
+  if (!formData.time || formData.time.trim() === '') {
+    missingFields.push('time');
+  }
+  if (!formData.dropsPerMinute || isNaN(parseFloat(formData.dropsPerMinute))) {
+    missingFields.push('dropsPerMinute');
+  }
+  if (missingFields.length > 0) {
+    return {
+      success: false,
+      message: t(`Missing or invalid fields: ${missingFields.join(', ')}`),
+      error: 'INVALID_FIELDS',
+    };
+  }
+  const session = await getCurrentSession();
+  const finalProviderUuid = providerUuid || session?.currentProvider?.uuid;
+  const finalLocationUuid = locationUuid || session?.sessionLocation?.uuid;
+  if (!finalProviderUuid) {
+    return { success: false, message: t('Provider information is required'), error: 'NO_PROVIDER' };
+  }
+  if (!finalLocationUuid) {
+    return { success: false, message: t('Location information is required'), error: 'NO_LOCATION' };
+  }
+  const now = new Date();
+  now.setMinutes(now.getMinutes() - 1);
+  const encounterPayload = {
+    patient: patientUuid,
+    encounterType: MCH_PARTOGRAPHY_ENCOUNTER_UUID,
+    location: finalLocationUuid,
+    encounterDatetime: toOmrsIsoString(now),
+    obs: observations,
+    encounterProviders: [
+      {
+        provider: finalProviderUuid,
+        encounterRole: ENCOUNTER_ROLE,
+      },
+    ],
+  };
+  const response = await openmrsFetch(`${restBaseUrl}/encounter`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(encounterPayload),
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = t(`Failed to save oxytocin data: ${response.status} ${response.statusText}`);
+    try {
+      const errorData = JSON.parse(errorText);
+      if (errorData.error?.message) {
+        errorMessage = t(`Failed to save oxytocin data: ${errorData.error.message}`);
+      }
+    } catch (e) {}
+    return { success: false, message: errorMessage, error: 'SAVE_FAILED' };
+  }
+  const encounter = await response.json();
+  return { success: true, message: t('Oxytocin data saved successfully'), encounter };
+}
+
+function buildOxytocinObservations(formData: OxytocinFormData): any[] {
+  const observations = [];
+  const obsDatetime = toOmrsIsoString(new Date());
+  if (formData.time && formData.time !== '') {
+    observations.push({ concept: OXYTOCIN_FORM_CONCEPTS.time, value: formData.time, obsDatetime });
+  }
+  if (formData.dropsPerMinute && formData.dropsPerMinute !== '') {
+    const dropsValue = parseFloat(formData.dropsPerMinute);
+    if (!isNaN(dropsValue)) {
+      observations.push({ concept: OXYTOCIN_FORM_CONCEPTS.oxytocinDropsPerMinute, value: dropsValue, obsDatetime });
+    }
+  }
+  return observations;
+}
+
+async function getCurrentSession() {
+  try {
+    const response = await openmrsFetch(`${restBaseUrl}/session`);
+    if (response.ok) {
+      return await response.json();
+    }
+  } catch {
+    // Swallow error silently
+  }
+  return null;
+}

package/src/maternal-and-child-health/partography/resources/progress-events.resource.ts

@@ -0,0 +1,6 @@
+// Resource file for progress events graph
+
+// TODO: Move progress events hooks and logic here from partography.resource.ts
+
+// Placeholder export to resolve module error
+export const progressEventsResource = {};

package/src/maternal-and-child-health/partography/resources/pulse-bp-combined.resource.ts

@@ -0,0 +1,53 @@
+import {
+  useMaternalPulseData,
+  transformMaternalPulseEncounterToChartData,
+  transformMaternalPulseEncounterToTableData,
+} from './maternal-pulse.resource';
+import {
+  useBloodPressureData,
+  transformBloodPressureEncounterToChartData,
+  transformBloodPressureEncounterToTableData,
+} from './blood-pressure.resource';
+import { useTranslation } from 'react-i18next';
+
+export function usePulseBpCombinedData(patientUuid: string) {
+  const { t } = useTranslation();
+  const pulse = useMaternalPulseData(patientUuid);
+  const bp = useBloodPressureData(patientUuid);
+  let localizedError = pulse.error || bp.error;
+  if (pulse.error || bp.error) {
+    localizedError = t('Failed to load pulse or blood pressure data');
+  }
+  return {
+    pulse,
+    bp,
+    isLoading: pulse.isLoading || bp.isLoading,
+    error: localizedError,
+    mutate: async () => {
+      await pulse.mutate();
+      await bp.mutate();
+    },
+  };
+}
+
+export function transformPulseBpCombinedToChartData(
+  pulseEncounters: any[],
+  bpEncounters: any[],
+  t: (key: string, defaultValue?: string, options?: any) => string,
+): { pulse: any; bloodPressure: any } {
+  return {
+    pulse: transformMaternalPulseEncounterToChartData(pulseEncounters, t),
+    bloodPressure: transformBloodPressureEncounterToChartData(bpEncounters, t),
+  };
+}
+
+export function transformPulseBpCombinedToTableData(
+  pulseEncounters: any[],
+  bpEncounters: any[],
+  t: (key: string, defaultValue?: string, options?: any) => string,
+): { pulse: any; bloodPressure: any } {
+  return {
+    pulse: transformMaternalPulseEncounterToTableData(pulseEncounters, t),
+    bloodPressure: transformBloodPressureEncounterToTableData(bpEncounters, t),
+  };
+}