@kenyaemr/esm-express-workflow-app 5.4.3 → 5.4.4-pre.1

package/src/components/registration/dependants/dependants.resource.ts

@@ -1,8 +1,17 @@
-import { getSessionLocation, launchWorkspace, openmrsFetch, restBaseUrl, showSnackbar } from '@openmrs/esm-framework';
+import {
+  getSessionLocation,
+  launchWorkspace2,
+  launchWorkspaceGroup2,
+  openmrsFetch,
+  restBaseUrl,
+  showSnackbar,
+  type Visit,
+} from '@openmrs/esm-framework';
 import { DependentPayload, HIEPatient } from '../type';
-import { generateIdentifier, getIdentifierTypeUUID } from '../helper';
+import { generateIdentifier, getIdentifierTypeUUID, sanitizeName } from '../helper';
 import { openmrsId, openmrsIdSource } from '../constant';
 import { useEffect, useState } from 'react';
+import { VisitFormProps } from '../start-visit-form/visit-form-workspace/visit-form.workspace';
 
 export interface PatientRegistrationPayload {
   name: string;
@@ -12,18 +21,34 @@ export interface PatientRegistrationPayload {
   type: 'hie-patient' | 'dependent';
 }
 
+interface AddressPayload {
+  address1: string;
+  address2?: string;
+  cityVillage: string;
+  country: string;
+  postalCode: string;
+  stateProvince: string;
+  countyDistrict?: string;
+}
+
 export async function createPatient(payload: PatientRegistrationPayload, t: any) {
   try {
-    const { patientData, type, name, gender, birthDate } = payload;
-    const locationUuid = (await getSessionLocation()).uuid;
-
-    let identifiers = [];
+    const { patientData, type, gender, birthDate } = payload;
+    const sessionLocation = await getSessionLocation();
+    const locationUuid = sessionLocation?.uuid ?? '';
+
+    let identifiers: Array<{
+      identifier: string;
+      identifierType: string;
+      location: string;
+      preferred: boolean;
+    }> = [];
     let givenName = '';
     let middleName = '';
     let familyName = '';
     let patientBirthDate = birthDate;
     let patientGender = gender;
-    let addresses = [];
+    let addresses: AddressPayload[] = [];
 
     if (type === 'hie-patient') {
       const hiePatient = patientData as HIEPatient;
@@ -37,13 +62,13 @@ export async function createPatient(payload: PatientRegistrationPayload, t: any)
             preferred: false,
           }))
           .filter((identifier) => identifier.identifierType) || [];
-      const crIdentifier = {
+
+      identifiers.push({
         identifier: hiePatient?.id,
         identifierType: getIdentifierTypeUUID('sha-id-number'),
         location: locationUuid,
         preferred: false,
-      };
-      identifiers.push(crIdentifier);
+      });
 
       const patientName = hiePatient.name?.[0];
       if (patientName) {
@@ -85,13 +110,13 @@ export async function createPatient(payload: PatientRegistrationPayload, t: any)
             preferred: false,
           }))
           .filter((identifier: any) => identifier.identifierType) || [];
-      const crIdentifier = {
+
+      identifiers.push({
         identifier: dependentInfo?.id,
         identifierType: getIdentifierTypeUUID('sha-id-number'),
         location: locationUuid,
         preferred: false,
-      };
-      identifiers.push(crIdentifier);
+      });
 
       const birthdate = dependentInfo.extension?.find(
         (ext: any) => ext.url === 'https://ts.kenya-hie.health/fhir/StructureDefinition/date_of_birth',
@@ -129,7 +154,7 @@ export async function createPatient(payload: PatientRegistrationPayload, t: any)
       identifiers[0].preferred = true;
     }
 
-    const phoneAttributes = [];
+    const phoneAttributes: Array<{ attributeType: string; value: string }> = [];
     if (type === 'hie-patient') {
       const phoneContact = patientData.telecom?.find((t: any) => t.system === 'phone');
       if (phoneContact?.value) {
@@ -140,32 +165,29 @@ export async function createPatient(payload: PatientRegistrationPayload, t: any)
       }
     }
 
+    const defaultAddress: AddressPayload = {
+      address1: '',
+      cityVillage: '',
+      country: '',
+      postalCode: '',
+      stateProvince: '',
+    };
+
     const registrationPayload = {
       person: {
         names: [
           {
             preferred: true,
-            givenName: givenName || 'Unknown',
-            middleName: middleName || '',
-            familyName: familyName || 'Unknown',
+            givenName: sanitizeName(givenName) || 'Unknown',
+            middleName: sanitizeName(middleName) || '',
+            familyName: sanitizeName(familyName) || 'Unknown',
           },
         ],
         gender: patientGender?.charAt(0).toUpperCase() || 'U',
         birthdate: patientBirthDate || null,
         birthdateEstimated: !patientBirthDate,
         attributes: phoneAttributes,
-        addresses:
-          addresses.length > 0
-            ? addresses
-            : [
-                {
-                  address1: '',
-                  cityVillage: '',
-                  country: '',
-                  postalCode: '',
-                  stateProvince: '',
-                },
-              ],
+        addresses: addresses.length > 0 ? addresses : [defaultAddress],
       },
       identifiers: [...identifiers],
     };
@@ -174,6 +196,10 @@ export async function createPatient(payload: PatientRegistrationPayload, t: any)
       const identifierResponse = await generateIdentifier(openmrsIdSource);
       const location = await getSessionLocation();
 
+      if (!location?.uuid) {
+        throw new Error('Could not determine session location');
+      }
+
       const openmrsIdentifier = {
         identifier: identifierResponse.data.identifier,
         identifierType: openmrsId,
@@ -199,7 +225,7 @@ export async function createPatient(payload: PatientRegistrationPayload, t: any)
       throw new Error('No valid identifiers found for the patient');
     }
 
-    const response = await openmrsFetch(`${restBaseUrl}/patient`, {
+    const response = await openmrsFetch<{ uuid: string }>(`${restBaseUrl}/patient`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -217,7 +243,7 @@ export async function createPatient(payload: PatientRegistrationPayload, t: any)
     });
 
     return response.data;
-  } catch (error) {
+  } catch (error: any) {
     console.error('Error creating patient:', error);
 
     const patientType = payload.type === 'hie-patient' ? 'Patient' : 'Dependent';
@@ -243,6 +269,25 @@ export async function createPatient(payload: PatientRegistrationPayload, t: any)
   }
 }
 
+async function launchCheckInWorkspace(patient: any, patientUuid: string) {
+  await launchWorkspaceGroup2('ewf-patient-chart', {
+    patient,
+    patientUuid,
+    visitContext: null as unknown as Visit,
+    mutateVisitContext: () => {},
+  });
+
+  launchWorkspace2<VisitFormProps, {}, {}>(
+    'custom-start-visit-workspace-form',
+    {
+      openedFrom: 'registration-check-in',
+      showPatientHeader: false,
+    },
+    {},
+    null,
+  );
+}
+
 export async function createDependentPatient(dependent: DependentPayload, t: any) {
   const payload: PatientRegistrationPayload = {
     name: dependent.name,
@@ -252,14 +297,7 @@ export async function createDependentPatient(dependent: DependentPayload, t: any
   };
 
   const result = await createPatient(payload, t);
-
-  launchWorkspace('start-visit-workspace-form', {
-    patientUuid: result.uuid,
-    workspaceTitle: t('startVisitWorkspaceTitle', 'Start Visit for {{patientName}}', {
-      patientName: dependent.name,
-    }),
-  });
-
+  await launchCheckInWorkspace(result, result.uuid);
   return result;
 }
 
@@ -278,14 +316,7 @@ export async function createHIEPatient(hiePatient: HIEPatient, t: any) {
   };
 
   const result = await createPatient(payload, t);
-
-  launchWorkspace('start-visit-workspace-form', {
-    patientUuid: result.uuid,
-    workspaceTitle: t('startVisitWorkspaceTitle', 'Start Visit for {{patientName}}', {
-      patientName: patientName,
-    }),
-  });
-
+  await launchCheckInWorkspace(result, result.uuid);
   return result;
 }
 
@@ -321,11 +352,9 @@ export const getDependentsFromContacts = (patient: HIEPatient) => {
     const shaIdNumber = identifierExtensions.find(
       (ext) => ext.valueIdentifier?.type?.coding?.[0]?.code === 'sha-id-number',
     )?.valueIdentifier?.value;
-
     const nationalId = identifierExtensions.find(
       (ext) => ext.valueIdentifier?.type?.coding?.[0]?.code === 'national-id',
     )?.valueIdentifier?.value;
-
     const birthCertificate = identifierExtensions.find(
       (ext) => ext.valueIdentifier?.type?.coding?.[0]?.code === 'birth-certificate',
     )?.valueIdentifier?.value;
@@ -372,7 +401,7 @@ export const useActiveVisit = (patientUuid: string | null) => {
         const data = await response.json();
         const visits = data?.results || [];
         setActiveVisit(visits.length > 0 ? visits[0] : null);
-      } catch (err) {
+      } catch (err: any) {
         console.warn(`Error fetching active visit for patient ${patientUuid}:`, err);
         setError(err);
         setActiveVisit(null);

package/src/components/registration/end-visit-modal/end-visit-dialog.modal.tsx

@@ -0,0 +1,320 @@
+import React, { useState, useCallback, useRef } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Button, Dropdown, ModalBody, ModalFooter, ModalHeader } from '@carbon/react';
+import { showModal, showSnackbar, useSession, useVisit } from '@openmrs/esm-framework';
+import { extractFetchError, extractUpstreamError } from '../../../shared/utils';
+import styles from './end-visit-dialog.scss';
+import { processVisitInsuranceClaim, sendDischargeOtp, submitVisitClaim } from './end-visit.resource';
+import {
+  checkBiometricAuthorizationStatus,
+  createSHABiometricAuthorize,
+  detectAuthorizingDeviceOS,
+  fetchWhitelistStatus,
+  rejectBiometricAuthorization,
+  submitOtpWhitelist,
+  useBiometricAgentStatus,
+  useBiometricConfig,
+  useOtpWhitelistReasons,
+  usePatientCRId,
+  usePatientPhone,
+  useSHAEligibility,
+  useProviderNationalId,
+} from './sha-end-visit.resource';
+import { DISCHARGE_REASONS } from '../type';
+
+interface EndVisitDialogProps {
+  patientUuid: string;
+  closeModal: () => void;
+}
+
+const EndVisitDialog: React.FC<EndVisitDialogProps> = ({ patientUuid, closeModal }) => {
+  const { t } = useTranslation();
+  const { activeVisit } = useVisit(patientUuid);
+  const [step, setStep] = useState<'confirm' | 'discharge-reason'>('confirm');
+  const [isProcessingClaim, setIsProcessingClaim] = useState(false);
+  const [reason, setReason] = useState('');
+  const processingClaimRef = useRef(false);
+  const serviceTypeRef = useRef('OUTPATIENT');
+  const consentTokenRef = useRef<string>('');
+  const invoiceNumberRef = useRef<string>('');
+  const interventionsRef = useRef<string[]>([]);
+  const phoneNumber = usePatientPhone(patientUuid);
+  const patientCRId = usePatientCRId(patientUuid);
+  const { isPatientWhiteListed, facilityBiometricsEnforced } = useSHAEligibility(patientUuid);
+  const { currentProvider } = useSession();
+  const { providerNationalid } = useProviderNationalId(currentProvider?.uuid ?? '');
+  const { agentUrl } = useBiometricConfig();
+  const { workstationId } = useBiometricAgentStatus(agentUrl);
+  const deviceOs = detectAuthorizingDeviceOS();
+  const { reasons: whitelistReasons } = useOtpWhitelistReasons();
+
+  const buildBiometricStarter = useCallback(
+    (crId: string) => {
+      return async () => {
+        if (!providerNationalid) {
+          throw new Error(
+            t(
+              'biometricMissingNationalId',
+              'Provider National ID not configured. Please add it to your provider profile.',
+            ),
+          );
+        }
+        if (!workstationId) {
+          throw new Error(
+            t(
+              'biometricAgentNotReachable',
+              'Biometric agent not running. Please start the agent on this workstation and try again.',
+            ),
+          );
+        }
+
+        const res = await createSHABiometricAuthorize({
+          agent_id: providerNationalid,
+          patient_id: crId,
+          interventions: interventionsRef.current,
+          service_type: serviceTypeRef.current,
+          workstation_id: workstationId,
+          authorizing_device_os: deviceOs,
+          patient_uuid: patientUuid,
+          is_biometrics_discharge_authorization: true,
+        });
+        if (!res.success || !res.embed_url || !res.token || !res.guid) {
+          throw new Error(
+            extractUpstreamError(res as any, t('biometricStartFailed', 'Could not start biometric session.')),
+          );
+        }
+        return {
+          embed_url: res.embed_url,
+          authorization_code: res.authorization_code ?? '',
+          consent_token: res.consent_token ?? res.token,
+          token: res.token,
+          guid: res.guid,
+        };
+      };
+    },
+    [providerNationalid, workstationId, deviceOs, patientUuid, t],
+  );
+
+  const handleSubmitWhitelist = useCallback(
+    async (params: { reasonType: string; reason: string; biometricAttempts: number; attachment: File | null }) => {
+      if (!patientCRId) {
+        return { success: false, error: t('noCRNumber', 'Patient has no SHA CR number.') };
+      }
+      return submitOtpWhitelist({
+        beneficiaryCrId: patientCRId,
+        reasonType: params.reasonType,
+        reason: params.reason,
+        biometricAttempts: params.biometricAttempts,
+        attachment: params.attachment,
+      });
+    },
+    [patientCRId, t],
+  );
+
+  const handleCheckWhitelistStatus = useCallback(async (crId: string) => {
+    const status = await fetchWhitelistStatus(crId);
+    return {
+      is_whitelisted: status.is_whitelisted,
+      has_pending: status.has_pending,
+      is_rejected: status.is_rejected,
+      latest_status: status.latest_status,
+      reviewer_note: status.requests?.[0]?.reviewer_note ?? null,
+    };
+  }, []);
+
+  const handleEndVisit = async () => {
+    if (!activeVisit || processingClaimRef.current) {
+      return;
+    }
+    processingClaimRef.current = true;
+    setIsProcessingClaim(true);
+
+    try {
+      const response = await processVisitInsuranceClaim(activeVisit.uuid);
+      serviceTypeRef.current = response?.data?.service_type ?? 'OUTPATIENT';
+      consentTokenRef.current = String(response?.data?.consentToken ?? '');
+      invoiceNumberRef.current = String(response?.data?.invoiceNumber ?? '');
+      interventionsRef.current = Array.isArray(response?.data?.intervention_codes)
+        ? response?.data?.intervention_codes
+        : [];
+      setStep('discharge-reason');
+    } catch (error) {
+      showSnackbar({
+        isLowContrast: true,
+        kind: 'error',
+        title: t('claimProcessingError', 'Error'),
+        subtitle: extractFetchError(error, t('insuranceClaimProcessingFailed', 'Insurance claim processing failed')),
+      });
+      closeModal();
+    } finally {
+      processingClaimRef.current = false;
+      setIsProcessingClaim(false);
+    }
+  };
+
+  const handleContinue = useCallback(() => {
+    if (!reason || !patientCRId || !activeVisit) {
+      return;
+    }
+
+    closeModal();
+
+    const crId = patientCRId;
+    const visitUuid = activeVisit.uuid;
+    const dischargeReason = reason;
+    const invoiceNumber = invoiceNumberRef.current;
+    let settled = false;
+
+    const settle = (fn?: () => void) => {
+      if (!settled) {
+        settled = true;
+        fn?.();
+      }
+    };
+
+    setTimeout(() => {
+      const dispose = showModal('otp-verification-modal', {
+        onClose: () => {
+          settle();
+          dispose();
+        },
+        phoneNumber,
+        otpLength: 6,
+        expiryMinutes: 5,
+        centerBoxes: true,
+        authMode: 'multi',
+        whitelistedForOTP: isPatientWhiteListed,
+        facilityBiometricsEnforced,
+        patientCRId: crId,
+        visitAction: 'end',
+
+        onRequestOtp: async () => {
+          const res = await sendDischargeOtp(crId, consentTokenRef.current);
+          if (res.success === false) {
+            throw new Error(res.error ?? t('otpRequestFailed', 'Failed to send OTP. Please try again.'));
+          }
+        },
+
+        onVerify: async (otp: string) => {
+          const res = await submitVisitClaim({ visitUuid, otp, dischargeReason, invoiceNumber });
+          showSnackbar({
+            isLowContrast: true,
+            kind: res?.success === true ? 'success' : 'error',
+            title: t('visitEnded', 'Visit ended'),
+            subtitle: res?.message ?? res?.error ?? '',
+          });
+        },
+
+        onVerificationSuccess: () => {
+          settle(() => {
+            dispose();
+          });
+        },
+
+        onCleanup: () => {},
+
+        onStartBiometric: buildBiometricStarter(crId),
+        onCheckBiometricStatus: checkBiometricAuthorizationStatus,
+
+        onBiometricSuccess: async (result: { authorization_code: string; consent_token: string; guid: string }) => {
+          const res = await submitVisitClaim({
+            visitUuid,
+            dischargeAuthGuid: result.guid,
+            dischargeReason,
+            invoiceNumber,
+          });
+          showSnackbar({
+            isLowContrast: true,
+            kind: res?.success === true ? 'success' : 'error',
+            title: t('visitEnded', 'Visit ended'),
+            subtitle: res?.message ?? res?.error ?? '',
+          });
+        },
+
+        onBiometricCancel: async (biometricConsentToken: string | null) => {
+          if (biometricConsentToken) {
+            try {
+              await rejectBiometricAuthorization(biometricConsentToken);
+            } catch (err) {
+              console.warn('Failed to reject biometric auth:', err);
+            }
+          }
+        },
+
+        whitelistReasons,
+        onSubmitWhitelist: handleSubmitWhitelist,
+        onCheckWhitelistStatus: handleCheckWhitelistStatus,
+      });
+    }, 300);
+  }, [
+    reason,
+    patientCRId,
+    activeVisit,
+    closeModal,
+    phoneNumber,
+    isPatientWhiteListed,
+    facilityBiometricsEnforced,
+    buildBiometricStarter,
+    whitelistReasons,
+    handleSubmitWhitelist,
+    handleCheckWhitelistStatus,
+    t,
+  ]);
+
+  if (step === 'discharge-reason') {
+    return (
+      <div>
+        <ModalHeader closeModal={closeModal} title={t('endVisitTitle', 'End Visit')} />
+        <ModalBody className={styles.dischargeModalBody}>
+          <p className={styles.bodyShort02}>
+            {t(
+              'dischargeReasonIntro',
+              'Select the reason for ending this visit. You will then be asked to verify your identity.',
+            )}
+          </p>
+          <Dropdown
+            id="discharge-reason-dropdown"
+            titleText={t('dischargeReason', 'Discharge reason')}
+            label={t('selectDischargeReason', 'Select a reason')}
+            items={[...DISCHARGE_REASONS]}
+            itemToString={(item) => (item ? item.label : '')}
+            selectedItem={DISCHARGE_REASONS.find((r) => r.id === reason) ?? null}
+            onChange={({ selectedItem }) => setReason(selectedItem?.id ?? '')}
+          />
+        </ModalBody>
+        <ModalFooter>
+          <Button kind="secondary" onClick={closeModal}>
+            {t('cancel', 'Cancel')}
+          </Button>
+          <Button kind="primary" disabled={!reason} onClick={handleContinue}>
+            {t('continue', 'Continue')}
+          </Button>
+        </ModalFooter>
+      </div>
+    );
+  }
+
+  return (
+    <div>
+      <ModalHeader
+        closeModal={closeModal}
+        title={t('endActiveVisitConfirmation', 'Are you sure you want to end this active visit?')}
+      />
+      <ModalBody>
+        <p className={styles.bodyShort02}>
+          {t('youWillProcessTheClaim', 'You will process the insurance claim for this visit.')}
+        </p>
+      </ModalBody>
+      <ModalFooter>
+        <Button kind="secondary" onClick={closeModal}>
+          {t('cancel', 'Cancel')}
+        </Button>
+        <Button kind="danger" disabled={!activeVisit || isProcessingClaim} onClick={handleEndVisit}>
+          {t('endVisit_title', 'End Visit')}
+        </Button>
+      </ModalFooter>
+    </div>
+  );
+};
+
+export default EndVisitDialog;

package/src/components/registration/end-visit-modal/end-visit-dialog.scss

@@ -0,0 +1,12 @@
+@use '@carbon/type';
+@use '@carbon/colors';
+
+.bodyShort02 {
+  @include type.type-style('body-compact-02');
+  color: colors.$gray-70;
+}
+
+.dischargeModalBody {
+  overflow: visible;
+  min-height: 14rem;
+}

package/src/components/registration/end-visit-modal/end-visit.resource.tsx

@@ -0,0 +1,59 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+
+export type ProcessVisitResponse = {
+  service_type: string;
+  consentToken?: string;
+  invoiceNumber?: string | null;
+  interventions?: string[];
+  message?: string;
+  [key: string]: unknown;
+};
+
+export type SubmitVisitResponse = {
+  success?: boolean;
+  message?: string;
+  error?: string;
+};
+
+export function processVisitInsuranceClaim(visitUuid: string) {
+  return openmrsFetch<ProcessVisitResponse>(`${restBaseUrl}/insuranceclaims/phc/processVisit?visitUuid=${visitUuid}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+export async function sendDischargeOtp(
+  patientCRId: string,
+  consentToken: string,
+): Promise<{ success?: boolean; error?: string }> {
+  const params = new URLSearchParams({ patientId: patientCRId, consentToken });
+  const response = await openmrsFetch<{ success?: boolean; error?: string }>(
+    `${restBaseUrl}/insuranceclaims/phc/sendDischargeOtp?${params.toString()}`,
+    { method: 'POST' },
+  );
+  return response.data;
+}
+
+export async function submitVisitClaim(params: {
+  visitUuid: string;
+  otp?: string;
+  dischargeReason?: string;
+  dischargeAuthGuid?: string;
+  invoiceNumber?: string;
+}): Promise<SubmitVisitResponse> {
+  const query = new URLSearchParams({ visitUuid: params.visitUuid, invoiceNumber: params.invoiceNumber ?? '' });
+  if (params.otp) {
+    query.set('otp', params.otp);
+  }
+  if (params.dischargeReason) {
+    query.set('dischargeReason', params.dischargeReason);
+  }
+  if (params.dischargeAuthGuid) {
+    query.set('dischargeAuthGuid', params.dischargeAuthGuid);
+  }
+  const response = await openmrsFetch<SubmitVisitResponse>(
+    `${restBaseUrl}/insuranceclaims/phc/submitVisit?${query.toString()}`,
+    { method: 'POST', headers: { 'Content-Type': 'application/json' } },
+  );
+  return response.data;
+}