@kenyaemr/esm-express-workflow-app 5.4.4-pre.299 → 5.4.4-pre.3

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;
+}

package/src/components/registration/end-visit-modal/sha-end-visit.resource.ts

@@ -0,0 +1,285 @@
+import { openmrsFetch, restBaseUrl, useConfig, usePatient, type FetchResponse } from '@openmrs/esm-framework';
+import useSWR from 'swr';
+import { type ExpressWorkflowConfig } from '../../../config-schema';
+import {
+  AuthorizingDeviceOS,
+  BiometricAuthorizationStatus,
+  BiometricAuthorizeRequest,
+  BiometricAuthorizeResponse,
+  BiometricConfigResponse,
+  OTPResponse,
+  ProviderAttributesResponse,
+  WhitelistReason,
+  WhitelistStatusPoll,
+  WhitelistSubmitResponse,
+} from '../type';
+
+const virtualClaimBaseUrl = `${restBaseUrl}/virtualclaims`;
+
+export const usePatientPhone = (patientUuid: string): string => {
+  const { data } = useSWR<
+    FetchResponse<{ person: { attributes: Array<{ attributeType: { display: string }; value: string }> } }>
+  >(
+    patientUuid
+      ? `${restBaseUrl}/patient/${patientUuid}?v=custom:(person:(attributes:(attributeType:(display),value)))`
+      : null,
+    openmrsFetch,
+  );
+  return (
+    data?.data?.person?.attributes?.find(
+      (attr) =>
+        attr.attributeType?.display?.toLowerCase().includes('phone') ||
+        attr.attributeType?.display?.toLowerCase().includes('telephone'),
+    )?.value ?? ''
+  );
+};
+
+export const usePatientCRId = (patientUuid: string): string | null => {
+  const { crIdentificationNumberUUID } = useConfig<ExpressWorkflowConfig>();
+  const { data } = useSWR<
+    FetchResponse<{ identifiers: Array<{ identifierType: { uuid: string }; identifier: string }> }>
+  >(
+    patientUuid
+      ? `${restBaseUrl}/patient/${patientUuid}?v=custom:(identifiers:(identifierType:(uuid),identifier))`
+      : null,
+    openmrsFetch,
+  );
+  return (
+    data?.data?.identifiers?.find((id) => id.identifierType?.uuid === crIdentificationNumberUUID)?.identifier ?? null
+  );
+};
+
+export interface EligibilityResponse {
+  requestIdType: number;
+  requestIdNumber: string;
+  memberCrNumber: string;
+  whitelistedForOTP: boolean;
+  facilityBiometricsEnforced: boolean;
+  fullName: string;
+  statusCode: string;
+  statusDesc: string;
+  schemes: Array<any>;
+  dateOfBirth?: string;
+  gender?: string;
+  age?: number;
+}
+
+export const useSHAEligibility = (patientUuid: string) => {
+  const { patient } = usePatient(patientUuid);
+  const { nationalIdUUID } = useConfig<ExpressWorkflowConfig>();
+
+  const nationalId = patient?.identifier?.find((id: any) =>
+    id?.type?.coding?.some((c: any) => c?.code === nationalIdUUID),
+  )?.value;
+
+  const url = nationalId
+    ? `${virtualClaimBaseUrl}/eligibility?identification_number=${encodeURIComponent(
+        nationalId,
+      )}&identification_type=${encodeURIComponent('National ID')}`
+    : null;
+
+  const { data, error, isLoading, mutate } = useSWR<{ data: EligibilityResponse }>(url, openmrsFetch, {
+    errorRetryCount: 0,
+    revalidateOnFocus: false,
+    dedupingInterval: 60_000,
+  });
+
+  return {
+    data: data?.data,
+    isPatientWhiteListed: data?.data?.whitelistedForOTP ?? false,
+    facilityBiometricsEnforced: data?.data?.facilityBiometricsEnforced ?? false,
+    isLoading,
+    error,
+    mutate,
+  };
+};
+
+export const useProviderNationalId = (providerUuid: string) => {
+  const { providerNationalIdUuid } = useConfig<ExpressWorkflowConfig>();
+  const customRep = 'custom:(attributes:(attributeType:(uuid,display),value))';
+  const url = providerUuid ? `${restBaseUrl}/provider/${providerUuid}?v=${customRep}` : null;
+  const { data, isLoading, error } = useSWR<FetchResponse<ProviderAttributesResponse>>(url, openmrsFetch);
+  const providerNationalid = data?.data?.attributes?.find(
+    (attr) => attr.attributeType.uuid === providerNationalIdUuid,
+  )?.value;
+  return { providerNationalid, isLoading, error };
+};
+
+export const useBiometricConfig = () => {
+  const { data, error, isLoading } = useSWR<FetchResponse<BiometricConfigResponse>>(
+    `${virtualClaimBaseUrl}/biometric-config`,
+    openmrsFetch,
+  );
+  return {
+    agentUrl: data?.data?.agent_url,
+    agentTimeoutMs: data?.data?.agent_timeout_ms,
+    isLoading,
+    error,
+  };
+};
+
+export interface BiometricAgentStatus {
+  devices: any[];
+  card_readers: any[];
+  isAuthed: boolean;
+  workstationID: string;
+  version: string;
+}
+
+export const useBiometricAgentStatus = (agentUrl: string | undefined) => {
+  const { data, error, isLoading } = useSWR<BiometricAgentStatus>(
+    agentUrl ?? null,
+    async (url: string) => {
+      const res = await fetch(url, { method: 'GET', headers: { Accept: 'application/json' } });
+      if (!res.ok) {
+        throw new Error(`Biometric agent returned ${res.status}`);
+      }
+      return res.json();
+    },
+    { revalidateOnFocus: false, shouldRetryOnError: false, dedupingInterval: 30_000 },
+  );
+  return {
+    workstationId: data?.workstationID,
+    isAuthed: data?.isAuthed ?? false,
+    isLoading,
+    error,
+  };
+};
+
+export const useOtpWhitelistReasons = () => {
+  const { data, isLoading, error } = useSWR<FetchResponse<{ count: number; reasons: Array<WhitelistReason> }>>(
+    `${virtualClaimBaseUrl}/otp-whitelist-reasons`,
+    openmrsFetch,
+    {
+      revalidateOnFocus: false,
+      dedupingInterval: 5 * 60_000,
+    },
+  );
+  return { reasons: data?.data?.reasons ?? [], isLoading, error };
+};
+
+export const detectAuthorizingDeviceOS = (): AuthorizingDeviceOS => {
+  if (typeof navigator === 'undefined') {
+    return 'windows';
+  }
+  const uaDataPlatform = (
+    navigator as Navigator & { userAgentData?: { platform?: string } }
+  ).userAgentData?.platform?.toLowerCase();
+  if (uaDataPlatform?.includes('android')) {
+    return 'android';
+  }
+  if (uaDataPlatform?.includes('windows')) {
+    return 'windows';
+  }
+  const userAgent = navigator.userAgent?.toLowerCase() ?? '';
+  if (userAgent.includes('android')) {
+    return 'android';
+  }
+  return 'windows';
+};
+
+export const sendSHAOtp = async (
+  patientCRId: string,
+  options: string[] | { consentToken: string },
+): Promise<OTPResponse> => {
+  const body = Array.isArray(options)
+    ? { patient_id: patientCRId, intervention_codes: options }
+    : { patient_id: patientCRId, consent_token: options.consentToken };
+
+  const response = await openmrsFetch(`${virtualClaimBaseUrl}/otp`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body,
+  });
+  return response.data;
+};
+
+export const createSHABiometricAuthorize = async (
+  payload: BiometricAuthorizeRequest,
+): Promise<BiometricAuthorizeResponse> => {
+  const response = await openmrsFetch(`${virtualClaimBaseUrl}/biometric-authorize`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: payload,
+  });
+  return response.data;
+};
+
+export const checkBiometricAuthorizationStatus = async (token: string): Promise<BiometricAuthorizationStatus> => {
+  const response = await openmrsFetch<BiometricAuthorizationStatus>(
+    `${virtualClaimBaseUrl}/biometric-authorization-status?token=${encodeURIComponent(token)}`,
+  );
+  return response.data;
+};
+
+export const rejectBiometricAuthorization = async (
+  token: string,
+): Promise<{ success: boolean; message?: string; error?: string }> => {
+  const response = await openmrsFetch(`${virtualClaimBaseUrl}/biometric-reject`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: { token },
+  });
+  return response.data;
+};
+
+export const fetchWhitelistStatus = async (beneficiaryCrId: string): Promise<WhitelistStatusPoll> => {
+  const response = await openmrsFetch(
+    `${virtualClaimBaseUrl}/otp-whitelist-status?beneficiary_cr_id=${encodeURIComponent(beneficiaryCrId)}`,
+  );
+  return response.data;
+};
+
+/**
+ * Submits a visit insurance claim and ends the visit in a single call.
+ * Call this after obtaining OTP or biometric authorisation.
+ *
+ * @param visitUuid        - UUID of the active visit to end.
+ * @param otp              - OTP supplied by the patient (optional — omit when using biometric auth).
+ * @param dischargeReason  - Discharge reason code (e.g. RECOVERED, REFERRED, ABSCONDED, OTHER).
+ * @param dischargeAuthGuid - GUID returned by the biometric authorisation flow (optional — omit when using OTP).
+ */
+export const submitVisitClaim = async (params: {
+  visitUuid: string;
+  otp?: string;
+  dischargeReason?: string;
+  dischargeAuthGuid?: string;
+}): Promise<{ success: boolean; message?: string; error?: string }> => {
+  const query = new URLSearchParams({ visitUuid: params.visitUuid });
+  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(`${restBaseUrl}/insuranceclaims/phc/submitVisit?${query.toString()}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+  });
+  return response.data;
+};
+
+export const submitOtpWhitelist = async (params: {
+  beneficiaryCrId: string;
+  reasonType: string;
+  reason: string;
+  biometricAttempts: number;
+  attachment: File | null;
+}): Promise<WhitelistSubmitResponse> => {
+  const formData = new FormData();
+  formData.append('beneficiary_cr_id', params.beneficiaryCrId);
+  formData.append('reason_type', params.reasonType);
+  formData.append('reason', params.reason);
+  formData.append('biometric_attempts', String(params.biometricAttempts));
+  if (params.attachment && params.attachment.size > 0) {
+    formData.append('attachment', params.attachment, params.attachment.name);
+  }
+  const response = await openmrsFetch(`${virtualClaimBaseUrl}/otp-whitelists`, {
+    method: 'POST',
+    body: formData,
+  });
+  return response.data;
+};