@kenyaemr/esm-billing-app 5.4.2-pre.2805 → 5.4.2-pre.2821

package/src/hooks/useOTP.ts

@@ -1,6 +1,22 @@
-import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
-import { ClaimSummary } from '../types';
+import { FetchResponse, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import useSWR from 'swr';
+import { ClaimSummary, OTPSource } from '../types';
 import { formatKenyanPhoneNumber } from '../invoice/payments/utils';
+import { TFunction } from 'i18next';
+import { getCurrencyForLocale } from '../helpers/currency';
+
+/**
+ * Generates a random OTP of a specified length.
+ */
+export function generateOTP(length = 5): string {
+  let otpNumbers = '0123456789';
+  let OTP = '';
+  const len = otpNumbers.length;
+  for (let i = 0; i < length; i++) {
+    OTP += otpNumbers[Math.floor(Math.random() * len)];
+  }
+  return OTP;
+}
 
 /**
  * Replaces placeholders in a template string with values from a given context.
@@ -42,62 +58,218 @@ function validateOtpInputs(receiver: string, patientName: string): void {
 }
 
 /**
- * Verifies the OTP by calling the server's validation endpoint.
+ * Hook to get OTP source configuration
+ */
+export const useOtpSource = () => {
+  const url = `${restBaseUrl}/kenyaemr/checkotpsource`;
+
+  const { data, error, isLoading } = useSWR<FetchResponse<OTPSource>>(url, openmrsFetch);
+
+  return {
+    otpSource: data?.data?.otpSource,
+    data,
+    error,
+    isLoading,
+  };
+};
+
+/**
+ * Sends OTP via SMS for KEHMIS workflow (client generates OTP)
  */
-export async function verifyOtpWithServer(otpId: string, otp: string): Promise<boolean> {
+async function sendOtpKehmis(
+  otp: string,
+  receiver: string,
+  patientName: string,
+  claimSummary: ClaimSummary,
+  expiryMinutes: number = 5,
+  nationalId: string | null = null,
+  t: TFunction,
+): Promise<void> {
+  validateOtpInputs(receiver, patientName);
+
+  // Get currency based on current locale
+  const currency = getCurrencyForLocale();
+
+  const context = {
+    patientName: patientName,
+    claimAmount: `${currency} ${claimSummary.totalAmount.toLocaleString()}`,
+    servicesSummary:
+      claimSummary.services.length > 100 ? claimSummary.services.substring(0, 97) + '...' : claimSummary.services,
+    startDate: claimSummary.startDate,
+    endDate: claimSummary.endDate,
+    facility: claimSummary.facility,
+    expiryTime: expiryMinutes,
+    otp: otp,
+  };
+
+  const claimConsentTemplate =
+    'Dear {{patientName}}, ' +
+    'We are submitting a claim to your insurance for services provided from {{startDate}} to {{endDate}} at {{facility}}. ' +
+    'Total claim amount: {{claimAmount}}. ' +
+    'Services: {{servicesSummary}}. ' +
+    'Your OTP for consent is {{otp}} (valid {{expiryTime}} mins). ';
+
   try {
-    const url = `${restBaseUrl}/kenyaemr/validate-otp`;
+    const message = parseMessage(context, claimConsentTemplate);
+    const url = buildSmsUrl(message, receiver, nationalId);
 
     const response = await openmrsFetch(url, {
       method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        id: otpId,
-        otp: otp.trim(),
-      }),
+      redirect: 'follow',
     });
 
     if (!response.ok) {
       throw new Error(`HTTP error! status: ${response.status}`);
     }
+  } catch (error) {
+    const errorMessage =
+      error instanceof Error
+        ? error.message
+        : t?.('unknownErrorOccurred', 'Unknown error occurred') || 'Unknown error occurred';
+    throw new Error(`Failed to send OTP: ${errorMessage}`);
+  }
+}
 
-    const rawText = await response.text();
+class KehmisOTPManager {
+  private otpStore: Map<
+    string,
+    { otp: string; timestamp: number; attempts: number; expiryTime: number; claimSummary: ClaimSummary }
+  > = new Map();
+  private readonly MAX_ATTEMPTS = 3;
 
-    let parsedResponse;
-    try {
-      parsedResponse = JSON.parse(rawText);
-    } catch (e) {
-      throw new Error('Invalid response from server');
+  async requestOTP(
+    phoneNumber: string,
+    patientName: string,
+    claimSummary: ClaimSummary,
+    expiryMinutes: number = 5,
+    nationalId: string | null = null,
+    t: TFunction,
+  ): Promise<void> {
+    const otp = generateOTP(5);
+    const expiryTime = expiryMinutes * 60 * 1000;
+    const formattedPhone = formatKenyanPhoneNumber(phoneNumber);
+
+    const otpData = {
+      otp,
+      timestamp: Date.now(),
+      attempts: 0,
+      expiryTime,
+      claimSummary,
+    };
+
+    this.otpStore.set(formattedPhone, otpData);
+
+    await sendOtpKehmis(otp, formattedPhone, patientName, claimSummary, expiryMinutes, nationalId, t);
+  }
+
+  async verifyOTP(phoneNumber: string, inputOtp: string): Promise<boolean> {
+    const formattedPhone = formatKenyanPhoneNumber(phoneNumber);
+    const storedData = this.otpStore.get(formattedPhone);
+
+    if (!storedData) {
+      throw new Error('No OTP found for this phone number. Please request a new OTP.');
     }
 
-    let data = parsedResponse;
-    if (parsedResponse.response && typeof parsedResponse.response === 'string') {
-      try {
-        data = JSON.parse(parsedResponse.response);
-      } catch (e) {
-        throw new Error('Invalid nested response from server');
-      }
+    if (Date.now() - storedData.timestamp > storedData.expiryTime) {
+      this.otpStore.delete(formattedPhone);
+      throw new Error('OTP has expired. Please request a new OTP.');
     }
 
-    if (data.status === 'success' || data.valid === true) {
+    storedData.attempts++;
+
+    if (storedData.attempts > this.MAX_ATTEMPTS) {
+      this.otpStore.delete(formattedPhone);
+      throw new Error('Maximum OTP attempts exceeded. Please request a new OTP.');
+    }
+
+    if (storedData.otp === inputOtp.trim()) {
+      this.otpStore.delete(formattedPhone);
       return true;
     } else {
-      const errorMessage = data.message || 'Invalid OTP';
-      throw new Error(errorMessage);
+      this.otpStore.set(formattedPhone, storedData);
+      throw new Error(`Invalid OTP. ${this.MAX_ATTEMPTS - storedData.attempts} attempts remaining.`);
     }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : 'OTP verification failed';
-    throw new Error(errorMessage);
+  }
+
+  clearOTP(phoneNumber: string): void {
+    const formattedPhone = formatKenyanPhoneNumber(phoneNumber);
+    this.otpStore.delete(formattedPhone);
+  }
+
+  clearAllOTPs(): void {
+    this.otpStore.clear();
+  }
+
+  cleanupExpiredOTPs(): void {
+    const now = Date.now();
+    for (const [phoneNumber, data] of this.otpStore.entries()) {
+      if (now - data.timestamp > data.expiryTime) {
+        this.otpStore.delete(phoneNumber);
+      }
+    }
+  }
+
+  hasValidOTP(phoneNumber: string): boolean {
+    const formattedPhone = formatKenyanPhoneNumber(phoneNumber);
+    const storedData = this.otpStore.get(formattedPhone);
+    if (!storedData) {
+      return false;
+    }
+    return Date.now() - storedData.timestamp <= storedData.expiryTime;
+  }
+
+  getRemainingTimeMinutes(phoneNumber: string): number {
+    const formattedPhone = formatKenyanPhoneNumber(phoneNumber);
+    const storedData = this.otpStore.get(formattedPhone);
+    if (!storedData) {
+      return 0;
+    }
+    const elapsed = Date.now() - storedData.timestamp;
+    const remaining = Math.max(0, storedData.expiryTime - elapsed);
+    return Math.ceil(remaining / (60 * 1000));
+  }
+
+  getRemainingAttempts(phoneNumber: string): number {
+    const formattedPhone = formatKenyanPhoneNumber(phoneNumber);
+    const storedData = this.otpStore.get(formattedPhone);
+    if (!storedData) {
+      return 0;
+    }
+    return Math.max(0, this.MAX_ATTEMPTS - storedData.attempts);
+  }
+
+  transferOTP(oldPhoneNumber: string, newPhoneNumber: string): boolean {
+    const oldFormatted = formatKenyanPhoneNumber(oldPhoneNumber);
+    const newFormatted = formatKenyanPhoneNumber(newPhoneNumber);
+
+    if (oldFormatted === newFormatted) {
+      return true;
+    }
+
+    const sessionData = this.otpStore.get(oldFormatted);
+    if (!sessionData) {
+      return false;
+    }
+
+    this.otpStore.set(newFormatted, sessionData);
+    this.otpStore.delete(oldFormatted);
+
+    return true;
+  }
+
+  formatPhone(phoneNumber: string): string {
+    return formatKenyanPhoneNumber(phoneNumber);
   }
 }
 
+// ============================================================================
+// HIE STRATEGY (Server-side OTP generation and validation)
+// ============================================================================
+
 /**
- * Sends an OTP request to the server with claim details which generates and sends the OTP via SMS.
- * Returns the OTP session ID needed for verification.
+ * Requests OTP from server (server generates and sends OTP)
  */
-export async function requestOtpFromServer(
+async function requestOtpFromServer(
   receiver: string,
   patientName: string,
   claimSummary: ClaimSummary,
@@ -108,9 +280,12 @@ export async function requestOtpFromServer(
 
   const formattedPhone = formatKenyanPhoneNumber(receiver);
 
+  // Get currency based on current locale
+  const currency = getCurrencyForLocale();
+
   const context = {
     patientName: patientName,
-    claimAmount: `KES ${claimSummary.totalAmount.toLocaleString()}`,
+    claimAmount: `${currency} ${claimSummary.totalAmount.toLocaleString()}`,
     servicesSummary:
       claimSummary.services.length > 100 ? claimSummary.services.substring(0, 97) + '...' : claimSummary.services,
     startDate: claimSummary.startDate,
@@ -177,12 +352,63 @@ export async function requestOtpFromServer(
       }
       throw new Error(`Failed to send OTP: ${error.message}`);
     }
-
     throw new Error('Failed to send OTP: Unknown error occurred');
   }
 }
 
-export class OTPManager {
+/**
+ * Verifies OTP with server
+ */
+async function verifyOtpWithServer(otpId: string, otp: string): Promise<boolean> {
+  try {
+    const url = `${restBaseUrl}/kenyaemr/validate-otp`;
+
+    const response = await openmrsFetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        id: otpId,
+        otp: otp.trim(),
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const rawText = await response.text();
+
+    let parsedResponse;
+    try {
+      parsedResponse = JSON.parse(rawText);
+    } catch (e) {
+      throw new Error('Invalid response from server');
+    }
+
+    let data = parsedResponse;
+    if (parsedResponse.response && typeof parsedResponse.response === 'string') {
+      try {
+        data = JSON.parse(parsedResponse.response);
+      } catch (e) {
+        throw new Error('Invalid nested response from server');
+      }
+    }
+
+    if (data.status === 'success' || data.valid === true) {
+      return true;
+    } else {
+      const errorMessage = data.message || 'Invalid OTP';
+      throw new Error(errorMessage);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'OTP verification failed';
+    throw new Error(errorMessage);
+  }
+}
+
+class HieOTPManager {
   private otpSessions: Map<
     string,
     {
@@ -192,6 +418,7 @@ export class OTPManager {
       expiryTime: number;
       nationalId?: string | null;
       phoneNumber: string;
+      claimSummary: ClaimSummary;
     }
   > = new Map();
   private readonly MAX_ATTEMPTS = 3;
@@ -222,6 +449,7 @@ export class OTPManager {
         expiryTime,
         nationalId,
         phoneNumber: formattedPhone,
+        claimSummary,
       };
 
       this.otpSessions.set(formattedPhone, sessionData);
@@ -299,7 +527,6 @@ export class OTPManager {
     if (!sessionData) {
       return false;
     }
-
     return Date.now() - sessionData.timestamp <= sessionData.expiryTime;
   }
 
@@ -309,7 +536,6 @@ export class OTPManager {
     if (!sessionData) {
       return 0;
     }
-
     const elapsed = Date.now() - sessionData.timestamp;
     const remaining = Math.max(0, sessionData.expiryTime - elapsed);
     return Math.ceil(remaining / (60 * 1000));
@@ -321,7 +547,6 @@ export class OTPManager {
     if (!sessionData) {
       return 0;
     }
-
     return Math.max(0, this.MAX_ATTEMPTS - sessionData.attempts);
   }
 
@@ -343,13 +568,110 @@ export class OTPManager {
 
     return true;
   }
+
+  formatPhone(phoneNumber: string): string {
+    return formatKenyanPhoneNumber(phoneNumber);
+  }
+}
+
+// ============================================================================
+// ADAPTER - Unified OTP Manager Interface
+// ============================================================================
+
+interface IOTPManager {
+  requestOTP(
+    phoneNumber: string,
+    patientName: string,
+    claimSummary: ClaimSummary,
+    expiryMinutes?: number,
+    nationalId?: string | null,
+    t?: TFunction,
+  ): Promise<void>;
+  verifyOTP(phoneNumber: string, inputOtp: string): Promise<boolean>;
+  clearOTP(phoneNumber: string): void;
+  clearAllOTPs(): void;
+  cleanupExpiredOTPs(): void;
+  hasValidOTP(phoneNumber: string): boolean;
+  getRemainingTimeMinutes(phoneNumber: string): number;
+  getRemainingAttempts(phoneNumber: string): number;
+  transferOTP(oldPhoneNumber: string, newPhoneNumber: string): boolean;
+  formatPhone(phoneNumber: string): string;
+}
+
+class OTPManagerAdapter implements IOTPManager {
+  private kehmisManager: KehmisOTPManager;
+  private hieManager: HieOTPManager;
+  private currentSource: string;
+
+  constructor(otpSource: string = 'kehmis') {
+    this.kehmisManager = new KehmisOTPManager();
+    this.hieManager = new HieOTPManager();
+    this.currentSource = otpSource;
+  }
+
+  setOtpSource(source: string) {
+    this.currentSource = source;
+  }
+
+  private getManager(): IOTPManager {
+    return this.currentSource === 'hie' ? this.hieManager : this.kehmisManager;
+  }
+
+  async requestOTP(
+    phoneNumber: string,
+    patientName: string,
+    claimSummary: ClaimSummary,
+    expiryMinutes: number = 5,
+    nationalId: string | null = null,
+    t: TFunction,
+  ): Promise<void> {
+    return this.getManager().requestOTP(phoneNumber, patientName, claimSummary, expiryMinutes, nationalId, t);
+  }
+
+  async verifyOTP(phoneNumber: string, inputOtp: string): Promise<boolean> {
+    return this.getManager().verifyOTP(phoneNumber, inputOtp);
+  }
+
+  clearOTP(phoneNumber: string): void {
+    this.kehmisManager.clearOTP(phoneNumber);
+    this.hieManager.clearOTP(phoneNumber);
+  }
+
+  clearAllOTPs(): void {
+    this.kehmisManager.clearAllOTPs();
+    this.hieManager.clearAllOTPs();
+  }
+
+  cleanupExpiredOTPs(): void {
+    this.kehmisManager.cleanupExpiredOTPs();
+    this.hieManager.cleanupExpiredOTPs();
+  }
+
+  hasValidOTP(phoneNumber: string): boolean {
+    return this.getManager().hasValidOTP(phoneNumber);
+  }
+
+  getRemainingTimeMinutes(phoneNumber: string): number {
+    return this.getManager().getRemainingTimeMinutes(phoneNumber);
+  }
+
+  getRemainingAttempts(phoneNumber: string): number {
+    return this.getManager().getRemainingAttempts(phoneNumber);
+  }
+
+  transferOTP(oldPhoneNumber: string, newPhoneNumber: string): boolean {
+    return this.getManager().transferOTP(oldPhoneNumber, newPhoneNumber);
+  }
+
   formatPhone(phoneNumber: string): string {
     return formatKenyanPhoneNumber(phoneNumber);
   }
 }
 
-export const otpManager = new OTPManager();
+// Export singleton instance
+export const otpManager = new OTPManagerAdapter();
 
+// Cleanup interval
 setInterval(() => {
   otpManager.cleanupExpiredOTPs();
 }, 2 * 60 * 1000);

package/src/index.ts

@@ -69,6 +69,7 @@ import { ClockOut } from './bill-administration/payment-points/payment-point/clo
 // Print Preview Components
 import PrintPreviewModal from './print-preview/print-preview.modal';
 import PaymentWorkspace from './invoice/payments/payment-form/payment.workspace';
+import { ClaimSummaryModal } from './claims/claims-management/table/claim-summary-modal/claim-summary.modal';
 
 // Translation
 export const importTranslation = require.context('../translations', false, /.json$/, 'lazy');
@@ -132,6 +133,7 @@ export const bulkImportBillableServicesModal = getSyncLifecycle(BulkImportBillab
 // Claims Management Components
 export const claimsOverview = getSyncLifecycle(ClaimsManagementOverview, options);
 export const manageClaimRequestModal = getSyncLifecycle(ManageClaimRequest, options);
+export const claimSummaryModal = getSyncLifecycle(ClaimSummaryModal, options);
 
 // Print Preview Components
 export const printPreviewModal = getSyncLifecycle(PrintPreviewModal, options);

package/src/routes.json

@@ -390,6 +390,10 @@
       "name": "manage-claim-request-modal",
       "component": "manageClaimRequestModal"
     },
+    {
+      "name": "claim-summary-modal",
+      "component": "claimSummaryModal"
+    },
     {
       "name": "clock-in-modal",
       "component": "clockIn"

package/src/types/index.ts

@@ -563,6 +563,7 @@ export type FacilityClaim = {
   externalId: string;
   responseUUID: string;
   insurer?: string;
+  visitType?: { uuid: string; display: string };
 };
 export type BillingPromptType = 'patient-chart' | 'billing-orders';
 
@@ -689,3 +690,7 @@ interface PatientIdentifier {
 export interface PatientIdentifierResponse {
   results: Array<PatientIdentifier>;
 }
+
+export interface OTPSource {
+  otpSource?: string;
+}