@kenyaemr/esm-billing-app 5.4.2-pre.2746 → 5.4.2-pre.2748

package/src/hooks/useOTP.ts

@@ -1,18 +1,6 @@
 import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
-import { OtpPayload, OtpResponse, ClaimSummary } from '../types';
-
-/**
- * Generates a random OTP of a specified length.
- */
-export function generateOTP(length = 5) {
-  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;
-}
+import { ClaimSummary } from '../types';
+import { formatKenyanPhoneNumber } from '../invoice/payments/utils';
 
 /**
  * Replaces placeholders in a template string with values from a given context.
@@ -31,35 +19,96 @@ export function parseMessage<T extends Record<string, string | number>>(context:
 }
 
 /**
- * Builds a URL for sending an SMS message.
+ * Builds a URL for sending an SMS message using the KenyaEMR SMS API.
  */
-function buildSmsUrl(message: string, receiver: string): string {
+function buildSmsUrl(message: string, receiver: string, nationalId: string | null = null): string {
   const encodedMessage = encodeURIComponent(message);
-  return `${restBaseUrl}/kenyaemr/send-kenyaemr-sms?message=${encodedMessage}&phone=${receiver}`;
+  const formattedReceiver = formatKenyanPhoneNumber(receiver);
+  let url = `${restBaseUrl}/kenyaemr/send-kenyaemr-sms?message=${encodedMessage}&phone=${formattedReceiver}`;
+
+  if (nationalId?.trim()) {
+    url += `&nationalId=${encodeURIComponent(nationalId)}`;
+  }
+  return url;
 }
 
 /**
  * Validates that the required parameters for sending an OTP message are present.
  */
-function validateOtpInputs(otp: string, receiver: string, patientName: string): void {
-  if (!otp?.trim() || !receiver?.trim() || !patientName?.trim()) {
-    throw new Error('Missing required parameters: otp, receiver, or patientName');
+function validateOtpInputs(receiver: string, patientName: string): void {
+  if (!receiver?.trim() || !patientName?.trim()) {
+    throw new Error('Missing required parameters: receiver or patientName');
+  }
+}
+
+/**
+ * Verifies the OTP by calling the server's validation endpoint.
+ */
+export 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);
   }
 }
 
 /**
- * Sends an OTP message to a patient's phone number with claim details.
+ * 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.
  */
-export async function sendOtp(
-  payload: OtpPayload,
+export async function requestOtpFromServer(
+  receiver: string,
   patientName: string,
   claimSummary: ClaimSummary,
   expiryMinutes: number = 5,
-): Promise<OtpResponse> {
-  const { otp, receiver } = payload;
-  validateOtpInputs(otp, receiver, patientName);
+  nationalId: string | null = null,
+): Promise<{ id: string; message: string }> {
+  validateOtpInputs(receiver, patientName);
 
-  const otpContext = {
+  const formattedPhone = formatKenyanPhoneNumber(receiver);
+
+  const context = {
     patientName: patientName,
     claimAmount: `KES ${claimSummary.totalAmount.toLocaleString()}`,
     servicesSummary:
@@ -68,7 +117,7 @@ export async function sendOtp(
     endDate: claimSummary.endDate,
     facility: claimSummary.facility,
     expiryTime: expiryMinutes,
-    otp: otp,
+    otp: '{{OTP}}',
   };
 
   const claimConsentTemplate =
@@ -79,8 +128,8 @@ export async function sendOtp(
     'Your OTP for consent is {{otp}} (valid {{expiryTime}} mins). ';
 
   try {
-    const message = parseMessage(otpContext, claimConsentTemplate);
-    const url = buildSmsUrl(message, receiver);
+    const message = parseMessage(context, claimConsentTemplate);
+    const url = buildSmsUrl(message, formattedPhone, nationalId);
 
     const response = await openmrsFetch(url, {
       method: 'POST',
@@ -91,162 +140,211 @@ export async function sendOtp(
       throw new Error(`HTTP error! status: ${response.status}`);
     }
 
-    return response.json();
+    let responseText = await response.text();
+
+    let unwrappedText: string;
+    try {
+      unwrappedText = JSON.parse(responseText);
+    } catch (e) {
+      unwrappedText = responseText;
+    }
+
+    const jsonMatch = unwrappedText.match(/\{.*\}/);
+    if (!jsonMatch) {
+      throw new Error('No valid JSON in server response');
+    }
+
+    let data;
+    try {
+      data = JSON.parse(jsonMatch[0]);
+    } catch (parseError) {
+      throw new Error('Invalid JSON response from server');
+    }
+
+    if (data.status === 'success' && data.id) {
+      return {
+        id: data.id,
+        message: data.message || 'OTP sent successfully',
+      };
+    } else {
+      const errorMessage = data.message || 'Failed to send OTP - no ID returned';
+      throw new Error(errorMessage);
+    }
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-    throw new Error(`Failed to send OTP: ${errorMessage}`);
+    if (error instanceof Error) {
+      if (error.message.startsWith('Failed to send OTP')) {
+        throw error;
+      }
+      throw new Error(`Failed to send OTP: ${error.message}`);
+    }
+
+    throw new Error('Failed to send OTP: Unknown error occurred');
   }
 }
 
 export class OTPManager {
-  private otpStore: Map<string, { otp: string; timestamp: number; attempts: number; expiryTime: number }> = new Map();
+  private otpSessions: Map<
+    string,
+    {
+      otpId: string;
+      timestamp: number;
+      attempts: number;
+      expiryTime: number;
+      nationalId?: string | null;
+      phoneNumber: string;
+    }
+  > = new Map();
   private readonly MAX_ATTEMPTS = 3;
-  private readonly DEFAULT_EXPIRY_TIME = 5 * 60 * 1000;
 
   async requestOTP(
     phoneNumber: string,
     patientName: string,
     claimSummary: ClaimSummary,
-    expiryMinutes: number = this.DEFAULT_EXPIRY_TIME,
+    expiryMinutes: number = 5,
+    nationalId: string | null = null,
   ): Promise<void> {
-    const otp = generateOTP(5);
     const expiryTime = expiryMinutes * 60 * 1000;
-
-    const normalizedPhone = this.normalizePhoneNumber(phoneNumber);
-
-    const otpData = {
-      otp,
-      timestamp: Date.now(),
-      attempts: 0,
-      expiryTime,
-    };
-
-    this.otpStore.set(normalizedPhone, otpData);
-
-    await sendOtp({ otp, receiver: phoneNumber }, patientName, claimSummary, expiryMinutes);
+    const formattedPhone = formatKenyanPhoneNumber(phoneNumber);
+
+    try {
+      const { id, message } = await requestOtpFromServer(
+        formattedPhone,
+        patientName,
+        claimSummary,
+        expiryMinutes,
+        nationalId,
+      );
+
+      const sessionData = {
+        otpId: id,
+        timestamp: Date.now(),
+        attempts: 0,
+        expiryTime,
+        nationalId,
+        phoneNumber: formattedPhone,
+      };
+
+      this.otpSessions.set(formattedPhone, sessionData);
+    } catch (error) {
+      throw error;
+    }
   }
 
   async verifyOTP(phoneNumber: string, inputOtp: string): Promise<boolean> {
-    const normalizedPhone = this.normalizePhoneNumber(phoneNumber);
-
-    const storedData = this.otpStore.get(normalizedPhone);
+    const formattedPhone = formatKenyanPhoneNumber(phoneNumber);
+    const sessionData = this.otpSessions.get(formattedPhone);
 
-    if (!storedData) {
-      throw new Error('No OTP found for this phone number. Please request a new OTP.');
+    if (!sessionData) {
+      throw new Error('No OTP session found for this phone number. Please request a new OTP.');
     }
 
-    if (Date.now() - storedData.timestamp > storedData.expiryTime) {
-      this.otpStore.delete(normalizedPhone);
+    if (Date.now() - sessionData.timestamp > sessionData.expiryTime) {
+      this.otpSessions.delete(formattedPhone);
       throw new Error('OTP has expired. Please request a new OTP.');
     }
 
-    storedData.attempts++;
+    sessionData.attempts++;
 
-    if (storedData.attempts > this.MAX_ATTEMPTS) {
-      this.otpStore.delete(normalizedPhone);
+    if (sessionData.attempts > this.MAX_ATTEMPTS) {
+      this.otpSessions.delete(formattedPhone);
       throw new Error('Maximum OTP attempts exceeded. Please request a new OTP.');
     }
 
-    if (storedData.otp === inputOtp.trim()) {
-      this.otpStore.delete(normalizedPhone);
-      return true;
-    } else {
-      this.otpStore.set(normalizedPhone, storedData);
-      throw new Error(`Invalid OTP. ${this.MAX_ATTEMPTS - storedData.attempts} attempts remaining.`);
+    try {
+      const isValid = await verifyOtpWithServer(sessionData.otpId, inputOtp);
+
+      if (isValid) {
+        this.otpSessions.delete(formattedPhone);
+        return true;
+      } else {
+        this.otpSessions.set(formattedPhone, sessionData);
+        throw new Error(`Invalid OTP. ${this.MAX_ATTEMPTS - sessionData.attempts} attempts remaining.`);
+      }
+    } catch (error) {
+      this.otpSessions.set(formattedPhone, sessionData);
+
+      const errorMessage = error instanceof Error ? error.message : 'Invalid OTP';
+      const remainingAttempts = this.MAX_ATTEMPTS - sessionData.attempts;
+
+      if (remainingAttempts > 0) {
+        throw new Error(`${errorMessage} ${remainingAttempts} attempts remaining.`);
+      } else {
+        this.otpSessions.delete(formattedPhone);
+        throw new Error('Maximum OTP attempts exceeded. Please request a new OTP.');
+      }
     }
   }
 
   clearOTP(phoneNumber: string): void {
-    const normalizedPhone = this.normalizePhoneNumber(phoneNumber);
-    this.otpStore.delete(normalizedPhone);
+    const formattedPhone = formatKenyanPhoneNumber(phoneNumber);
+    this.otpSessions.delete(formattedPhone);
   }
 
   clearAllOTPs(): void {
-    this.otpStore.clear();
+    this.otpSessions.clear();
   }
 
   cleanupExpiredOTPs(): void {
     const now = Date.now();
-    for (const [phoneNumber, data] of this.otpStore.entries()) {
+    for (const [phoneNumber, data] of this.otpSessions.entries()) {
       if (now - data.timestamp > data.expiryTime) {
-        this.otpStore.delete(phoneNumber);
+        this.otpSessions.delete(phoneNumber);
       }
     }
   }
 
   hasValidOTP(phoneNumber: string): boolean {
-    const normalizedPhone = this.normalizePhoneNumber(phoneNumber);
-    const storedData = this.otpStore.get(normalizedPhone);
-    if (!storedData) {
+    const formattedPhone = formatKenyanPhoneNumber(phoneNumber);
+    const sessionData = this.otpSessions.get(formattedPhone);
+    if (!sessionData) {
       return false;
     }
 
-    return Date.now() - storedData.timestamp <= storedData.expiryTime;
+    return Date.now() - sessionData.timestamp <= sessionData.expiryTime;
   }
 
   getRemainingTimeMinutes(phoneNumber: string): number {
-    const normalizedPhone = this.normalizePhoneNumber(phoneNumber);
-    const storedData = this.otpStore.get(normalizedPhone);
-    if (!storedData) {
+    const formattedPhone = formatKenyanPhoneNumber(phoneNumber);
+    const sessionData = this.otpSessions.get(formattedPhone);
+    if (!sessionData) {
       return 0;
     }
 
-    const elapsed = Date.now() - storedData.timestamp;
-    const remaining = Math.max(0, storedData.expiryTime - elapsed);
+    const elapsed = Date.now() - sessionData.timestamp;
+    const remaining = Math.max(0, sessionData.expiryTime - elapsed);
     return Math.ceil(remaining / (60 * 1000));
   }
 
   getRemainingAttempts(phoneNumber: string): number {
-    const normalizedPhone = this.normalizePhoneNumber(phoneNumber);
-    const storedData = this.otpStore.get(normalizedPhone);
-    if (!storedData) {
+    const formattedPhone = formatKenyanPhoneNumber(phoneNumber);
+    const sessionData = this.otpSessions.get(formattedPhone);
+    if (!sessionData) {
       return 0;
     }
 
-    return Math.max(0, this.MAX_ATTEMPTS - storedData.attempts);
-  }
-
-  getStoredOTP(phoneNumber: string): string | null {
-    const normalizedPhone = this.normalizePhoneNumber(phoneNumber);
-    const storedData = this.otpStore.get(normalizedPhone);
-    return storedData ? storedData.otp : null;
+    return Math.max(0, this.MAX_ATTEMPTS - sessionData.attempts);
   }
 
   transferOTP(oldPhoneNumber: string, newPhoneNumber: string): boolean {
-    const oldNormalized = this.normalizePhoneNumber(oldPhoneNumber);
-    const newNormalized = this.normalizePhoneNumber(newPhoneNumber);
+    const oldFormatted = formatKenyanPhoneNumber(oldPhoneNumber);
+    const newFormatted = formatKenyanPhoneNumber(newPhoneNumber);
 
-    if (oldNormalized === newNormalized) {
+    if (oldFormatted === newFormatted) {
       return true;
     }
 
-    const storedData = this.otpStore.get(oldNormalized);
-    if (!storedData) {
+    const sessionData = this.otpSessions.get(oldFormatted);
+    if (!sessionData) {
       return false;
     }
 
-    this.otpStore.set(newNormalized, storedData);
-    this.otpStore.delete(oldNormalized);
+    this.otpSessions.set(newFormatted, { ...sessionData, phoneNumber: newFormatted });
+    this.otpSessions.delete(oldFormatted);
 
     return true;
   }
-
-  private normalizePhoneNumber(phoneNumber: string): string {
-    if (!phoneNumber) {
-      return '';
-    }
-
-    let normalized = phoneNumber.replace(/\D/g, '');
-
-    if (normalized.startsWith('254') && normalized.length === 12) {
-      return normalized;
-    } else if (normalized.startsWith('0') && normalized.length === 10) {
-      return '254' + normalized.substring(1);
-    } else if (normalized.length === 9) {
-      return '254' + normalized;
-    }
-
-    return normalized;
+  formatPhone(phoneNumber: string): string {
+    return formatKenyanPhoneNumber(phoneNumber);
   }
 }
 
@@ -255,38 +353,3 @@ export const otpManager = new OTPManager();
 setInterval(() => {
   otpManager.cleanupExpiredOTPs();
 }, 2 * 60 * 1000);
-
-export function createOtpHandlers(patientName: string, expiryMinutes: number) {
-  return {
-    onRequestOtp: async (phone: string, claimSummary: ClaimSummary): Promise<void> => {
-      await otpManager.requestOTP(phone, patientName, claimSummary, expiryMinutes);
-    },
-    onVerify: async (otp: string, phoneNumber: string): Promise<void> => {
-      const isValid = await otpManager.verifyOTP(phoneNumber, otp);
-      if (!isValid) {
-        throw new Error('OTP verification failed');
-      }
-    },
-    hasValidOTP: (phone: string): boolean => {
-      return otpManager.hasValidOTP(phone);
-    },
-    getRemainingTime: (phone: string): number => {
-      return otpManager.getRemainingTimeMinutes(phone);
-    },
-    getRemainingAttempts: (phone: string): number => {
-      return otpManager.getRemainingAttempts(phone);
-    },
-    clearOTP: (phone: string): void => {
-      otpManager.clearOTP(phone);
-    },
-    clearAllOTPs: (): void => {
-      otpManager.clearAllOTPs();
-    },
-    getStoredOTP: (phone: string): string | null => {
-      return otpManager.getStoredOTP(phone);
-    },
-    transferOTP: (oldPhone: string, newPhone: string): boolean => {
-      return otpManager.transferOTP(oldPhone, newPhone);
-    },
-  };
-}

package/src/hooks/usePatientIdentifierType.ts

@@ -0,0 +1,26 @@
+import { openmrsFetch, restBaseUrl, useConfig } from '@openmrs/esm-framework';
+import { BillingConfig } from '../config-schema';
+import { type PatientIdentifierResponse } from '../types';
+import useSWR from 'swr';
+
+export const usePatientIdentifier = (patientUuid: string) => {
+  const url = `${restBaseUrl}/patient/${patientUuid}/identifier?v=custom:(uuid,identifier,identifierType:(uuid,required,name),preferred)`;
+  const { nationalIdIdentifierTypeUUID } = useConfig<BillingConfig>();
+
+  const { data, isLoading, error } = useSWR<{ data: PatientIdentifierResponse }>(
+    patientUuid ? url : null,
+    openmrsFetch,
+  );
+
+  const nationalIdIdentifier = data?.data?.results?.find(
+    (identifier) => identifier.identifierType?.uuid === nationalIdIdentifierTypeUUID,
+  );
+
+  return {
+    identifier: nationalIdIdentifier,
+    nationalId: nationalIdIdentifier?.identifier || null,
+    isLoading,
+    error,
+    allIdentifiers: data?.data?.results,
+  };
+};

package/src/types/index.ts

@@ -672,3 +672,20 @@ export interface DashboardConfig {
   slot: string;
   title: string;
 }
+
+interface IdentifierType {
+  uuid: string;
+  required: boolean;
+  name: string;
+}
+
+interface PatientIdentifier {
+  uuid: string;
+  identifier: string;
+  identifierType: IdentifierType;
+  preferred: boolean;
+}
+
+export interface PatientIdentifierResponse {
+  results: Array<PatientIdentifier>;
+}

package/translations/am.json

@@ -82,6 +82,7 @@
   "claimsItems": "የጥያቄ ዕቃዎች",
   "claimsManagement": "የጥያቄዎች አስተዳደር",
   "claimSummary": "የጥያቄ ማጠቃለያ",
+  "claimSummaryMissing": "Claim summary is missing. Please try again.",
   "clear": "ይጽዳ",
   "clearSearch": "የፍለጋ ግቤት ይጽዳ",
   "clinicalCharges": "የክሊኒክ ክፍያዎች",
@@ -203,6 +204,8 @@
   "noItemsSelected": "ምንም ዕቃዎች አልተመረጡም",
   "noMatchingBillsToDisplay": "የሚታዩ ተመሳሳይ ሂሳቦች የሉም",
   "noMatchingItemsToDisplay": "የሚታዩ ተመሳሳይ ዕቃዎች የሉም",
+  "noNationalId": "No National ID",
+  "noNationalIdFound": "No national ID found for this patient. This may affect claim processing.",
   "noPaymentModes": "ምንም የክፍያ ዘዴዎች አልተገኙም",
   "noPaymentModesSubtitle": "ለተመረጡ ማጣሪያዎች ምንም የክፍያ ዘዴዎች አልተገኙም",
   "noPhoneNumber": "ስልክ ቁጥር የለም",
@@ -357,4 +360,4 @@
   "visittype": "የጉብኝት ዓይነት",
   "waiveBill": "ሂሳብ ይቅር",
   "yes": "አዎ"
-}
+}

package/translations/en.json

@@ -82,6 +82,7 @@
   "claimsItems": "Claims Items",
   "claimsManagement": "Claims management",
   "claimSummary": "Claim Summary",
+  "claimSummaryMissing": "Claim summary is missing. Please try again.",
   "clear": "Clear",
   "clearSearch": "Clear search input",
   "clinicalCharges": "Clinical Charges",
@@ -203,6 +204,8 @@
   "noItemsSelected": "No items selected",
   "noMatchingBillsToDisplay": "No matching bills to display",
   "noMatchingItemsToDisplay": "No matching items to display",
+  "noNationalId": "No National ID",
+  "noNationalIdFound": "No national ID found for this patient. This may affect claim processing.",
   "noPaymentModes": "No payment modes found",
   "noPaymentModesSubtitle": "No payment modes found for the selected filters",
   "noPhoneNumber": "No Phone Number",

package/translations/sw.json

@@ -82,6 +82,7 @@
   "claimsItems": "Claims Items",
   "claimsManagement": "Claims management",
   "claimSummary": "Claim Summary",
+  "claimSummaryMissing": "Claim summary is missing. Please try again.",
   "clear": "Clear",
   "clearSearch": "Clear search input",
   "clinicalCharges": "Clinical Charges",
@@ -203,6 +204,8 @@
   "noItemsSelected": "No items selected",
   "noMatchingBillsToDisplay": "No matching bills to display",
   "noMatchingItemsToDisplay": "No matching items to display",
+  "noNationalId": "No National ID",
+  "noNationalIdFound": "No national ID found for this patient. This may affect claim processing.",
   "noPaymentModes": "No payment modes found",
   "noPaymentModesSubtitle": "No payment modes found for the selected filters",
   "noPhoneNumber": "No Phone Number",