@kenyaemr/esm-shr-app 5.4.4-pre.43 → 5.4.4-pre.430

package/src/shr-summary/shr-summary.resource.ts

@@ -1,91 +1,91 @@
 import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
-import dayjs from 'dayjs';
-import { z } from 'zod';
-import { PHONE_NUMBER_REGEX } from '../constants';
 
-export const authorizationSchema = z
-  .object({
-    otp: z.string().min(1, 'Required'),
-    receiver: z.string().regex(PHONE_NUMBER_REGEX).optional(),
-    authMethod: z.string(),
-  })
-  .refine(
-    (data) => {
-      if (data.authMethod === 'otp') {
-        return data.receiver;
-      }
-      return true;
-    },
+interface SmsResponseData {
+  status: string;
+  message: string;
+  id: string;
+}
+interface TokenResponse {
+  token: string;
+  issued: number; // Unix timestamp in milliseconds
+  expires: number; // Unix timestamp in milliseconds
+  status: string; // e.g., "success"
+  expires_in: number; // Expiration duration in milliseconds (e.g., 1440000 ms = 24 minutes)
+}
+
+interface VerifyResponseData {
+  response: string;
+}
+
+export const sendSHAOtp = async (phoneNumber: string, nationalId: string): Promise<SmsResponseData> => {
+  const messageTemplate = 'Message template';
+  const response = await openmrsFetch(
+    `${restBaseUrl}/kenyaemr/send-kenyaemr-sms?phone=${phoneNumber}&nationalId=${nationalId}&message=${messageTemplate}`,
     {
-      message: 'Required',
-      path: ['receiver'],
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
     },
   );
 
-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;
-}
+  const rawResponseText = response.data;
 
-export function persistOTP(otp: string, patientUuid: string) {
-  sessionStorage.setItem(
-    patientUuid,
-    JSON.stringify({
-      otp,
-      timestamp: new Date().toISOString(),
-    }),
-  );
-}
+  if (!rawResponseText) {
+    throw new Error('SMS Gateway returned an empty response.');
+  }
 
-export async function sendOtp({ otp, receiver }: z.infer<typeof authorizationSchema>, patientName: string) {
-  const payload = parseMessage(
-    { otp, patient_name: patientName, expiry_time: 5 },
-    'Dear {{patient_name}}, your OTP for accessing your Shared Health Records (SHR) is {{otp}}. Please enter this code to proceed. The code is valid for {{expiry_time}} minutes.',
-  );
+  // Use the extraction logic
+  const extractedData = extractSmsData(rawResponseText);
 
-  const url = `${restBaseUrl}/kenyaemr/send-kenyaemr-sms?message=${payload}&phone=${receiver}`;
+  // Throw an error if parsing failed or the payload was missing
+  if (!extractedData) {
+    throw new Error(`Failed to parse SMS gateway response. Raw response: ${rawResponseText}`);
+  }
 
-  const res = await openmrsFetch(url, {
-    method: 'POST',
-    redirect: 'follow',
-  });
-  if (res.ok) {
-    return await res.json();
+  // Explicitly check for successful status from the gateway payload
+  if (extractedData.status !== 'success') {
+    throw new Error(`SMS delivery failed with status: ${extractedData.status}. Message: ${extractedData.message}`);
   }
-  throw new Error('Error sending otp');
-}
 
-function parseMessage(object, template) {
-  const placeholderRegex = /{{(.*?)}}/g;
+  // Return the strongly-typed data to the caller
+  return extractedData;
+};
 
-  const parsedMessage = template.replace(placeholderRegex, (match, fieldName) => {
-    if (object.hasOwnProperty(fieldName)) {
-      return object[fieldName];
-    } else {
-      return match;
+/**
+ * Extracts and parses the JSON payload from a mixed-text SMS API response.
+ * @param responseString The raw string response from the provider
+ * @returns SmsResponseData object or null if parsing fails
+ */
+export function extractSmsData(responseString: string): SmsResponseData | null {
+  try {
+    // Regex to capture everything between the first '{' and the last '}'
+    const jsonMatch = responseString.match(/\{.*\}/);
+
+    if (!jsonMatch) {
+      console.error('No JSON payload found in the response string.');
+      return null;
     }
-  });
 
-  return parsedMessage;
-}
-export function verifyOtp(otp: string, patientUuid: string) {
-  const data = sessionStorage.getItem(patientUuid);
-  if (!data) {
-    throw new Error('Invalid OTP');
+    // Parse the extracted JSON string
+    const parsedData: SmsResponseData = JSON.parse(jsonMatch[0]);
+    return parsedData;
+  } catch (error) {
+    console.error('Failed to parse SMS response data:', error);
+    return null;
   }
-  const { otp: storedOtp, timestamp } = JSON.parse(data);
-  const isExpired = dayjs(timestamp).add(5, 'minutes').isBefore(dayjs());
-  if (storedOtp !== otp) {
-    throw new Error('Invalid OTP');
-  }
-  if (isExpired) {
-    throw new Error('OTP Expired');
-  }
-  sessionStorage.removeItem(patientUuid);
-  return 'Verification success';
 }
+
+export const verifyOtp = async (otp: string, uuid: string) => {
+  const url = `${restBaseUrl}/kenyaemr/validate-otp`;
+  const res = await openmrsFetch<VerifyResponseData>(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: { id: uuid, otp },
+  });
+  const data = res?.data?.response;
+  try {
+    const _data = JSON.parse(data) as TokenResponse;
+    return { status: 'success', data: _data };
+  } catch (error) {
+    return { status: 'error', error: data };
+  }
+};

package/src/shr-summary/tables/shr-summary-table.component.tsx

@@ -1,29 +1,25 @@
 import { Button, DataTableSkeleton, Layer, Tile } from '@carbon/react';
 import { ArrowRight } from '@carbon/react/icons';
-import { launchWorkspace, useLayoutType } from '@openmrs/esm-framework';
-import {
-  CardHeader,
-  EmptyDataIllustration,
-  ErrorState,
-  getPatientUuidFromStore,
-} from '@openmrs/esm-patient-common-lib';
-import React, { useState } from 'react';
+import { showModal, showSnackbar } from '@openmrs/esm-framework';
+import { CardHeader, EmptyDataIllustration, ErrorState } from '@openmrs/esm-patient-common-lib';
+import React, { useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import usePatient from '../../hooks/usePatient';
 import SharedHealthRecordsSummary from '../../shrpatient-summary/shrpatient-summary.component';
+import { sendSHAOtp, verifyOtp } from '../shr-summary.resource';
 import styles from './shr-tables.scss';
 
-interface PatientSHRSummaryTableProps {}
+interface PatientSHRSummaryTableProps {
+  patientUuid: string;
+  patient: fhir.Patient;
+}
 
-const PatientSHRSummaryTable: React.FC<PatientSHRSummaryTableProps> = () => {
+const PatientSHRSummaryTable: React.FC<PatientSHRSummaryTableProps> = ({ patient, patientUuid }) => {
   const { t } = useTranslation();
-  const [pageSize, setPageSize] = useState(10);
-  const layout = useLayoutType();
-  const headerTitle = t('shrRecords', 'SHR Records');
-
-  const patientUuid = getPatientUuidFromStore();
-  const [accessGranted, setAccessGranted] = useState(false);
-  const { error, isLoading, patientPhoneNumber, patientName } = usePatient(patientUuid);
+  const idRef = useRef<string>();
+  const [accessGranted, setAccessGranted] = useState(true);
+  const [isAuthorizing, setIsAuthorizing] = useState(false);
+  const { error, isLoading, patientPhoneNumber, patientName, nationalId } = usePatient(patientUuid);
 
   if (isLoading) {
     return <DataTableSkeleton />;
@@ -33,14 +29,48 @@ const PatientSHRSummaryTable: React.FC<PatientSHRSummaryTableProps> = () => {
   }
 
   const handleInitiateAuthorization = () => {
-    launchWorkspace('shr-authorization-form', {
-      workspaceTitle: 'SHR Pull Authorization Form',
-      patientUuid,
-      onVerified: () => {
+    const dispose = showModal('otp-verification-modal', {
+      onClose: () => {
+        if (!accessGranted) {
+          setIsAuthorizing(false);
+        }
+        dispose();
+      },
+      phoneNumber: patientPhoneNumber || '',
+      otpLength: 5,
+      expiryMinutes: 5,
+      centerBoxes: true,
+      onRequestOtp: async (_phone: string) => {
+        const { status, id } = await sendSHAOtp(_phone, nationalId as string);
+        idRef.current = id;
+        if (status !== 'success') {
+          throw new Error(t('otpFailed', 'Failed to send OTP'));
+        }
+      },
+
+      onVerify: async (enteredOtp: string) => {
+        const { status, data, error } = await verifyOtp(enteredOtp, idRef.current as string);
+        if (status !== 'success') {
+          throw new Error(t('authorizeFailed', 'Authorization failed'));
+        }
+      },
+
+      onVerificationSuccess: () => {
+        dispose();
+        setIsAuthorizing(false);
         setAccessGranted(true);
+        showSnackbar({
+          title: t('success', 'Success'),
+          subtitle: t('otpVerificationSuccessMessage', 'OTP Vefification succesfull'),
+          kind: 'success',
+        });
+      },
+
+      onCleanup: () => {
+        if (!accessGranted) {
+          setIsAuthorizing(false);
+        }
       },
-      patientPhoneNumber,
-      patientName,
     });
   };
 

package/src/utils/function.tsx

@@ -139,11 +139,10 @@ export const getPatientAddress = (patient: Patient) => {
 
 export const getPatientIdentifiers = (patient: Patient) => {
   const identifiers = [];
-
-  if (patient?.identifiers?.length) {
+  if (patient?.identifiers?.length && patient.identifiers.length > 0) {
     patient.identifiers.forEach((id) => {
-      if (id.identifier && id.identifierType?.name) {
-        const idTypeName = id.identifierType.name.toUpperCase();
+      if (id.identifier && id.identifierType?.display) {
+        const idTypeName = id.identifierType.display.toUpperCase();
 
         if (
           idTypeName.includes('CCC') ||
@@ -168,6 +167,12 @@ export const getPatientIdentifiers = (patient: Patient) => {
             IDENTIFIER_TYPE: 'FACILITY_ID',
             ASSIGNING_AUTHORITY: 'FACILITY',
           });
+        } else if (idTypeName.includes('CR')) {
+          identifiers.push({
+            ID: id.identifier,
+            IDENTIFIER_TYPE: 'CR_NUMBER',
+            ASSIGNING_AUTHORITY: 'SHA',
+          });
         }
       }
     });

package/src/workspace/referral-workspace.resource.ts

@@ -20,10 +20,9 @@ export const useFacilities = (searchTerm: string) => {
 };
 
 export const useSendReferralToArtDirectory = () => {
-  const { artDirectoryUrl } = useConfig<ReferralConfigObject>();
-
   const sendReferral = async (apiPayload: ReferralPayload): Promise<ReferralResponse> => {
     try {
+      const artDirectoryUrl = `${restBaseUrl}/kenyaemril/outboundReferral`;
       const response = await openmrsFetch(artDirectoryUrl, {
         method: 'POST',
         headers: {

package/src/workspace/referral.workspace.scss

@@ -23,14 +23,16 @@
   display: flex;
   flex-direction: column;
   height: 100%;
-  padding-bottom: 20px;
 }
 
 .buttonSet {
   margin-top: auto;
   display: flex;
   justify-content: flex-end;
-  margin-right: layout.$spacing-04;
+
+  & > button {
+    min-width: 50%;
+  }
 }
 
 .grid {