@kenyaemr/esm-admin-app 5.4.2-pre.2694 → 5.4.2-pre.2699

package/dist/routes.json

@@ -1 +1 @@
-{"$schema":"https://json.openmrs.org/routes.schema.json","backendDependencies":{"kenyaemrCharts":"^1.6.7"},"extensions":[{"component":"adminLeftPanelLink","name":"admin-left-panel-link","slot":"admin-left-panel-slot"},{"component":"userManagementLeftPannelLink","name":"user-management-left-panel-link","slot":"admin-left-panel-slot"},{"component":"etlAdministrationLeftPannelLink","name":"etl-administration-left-panel-link","slot":"admin-left-panel-slot"},{"component":"locationsLeftPanelLink","name":"locations-left-panel-link","slot":"admin-left-panel-slot"},{"component":"facilitySetupLeftPanelLink","name":"facility-setup-left-panel-link","slot":"admin-left-panel-slot"},{"component":"providerBanner","name":"provider-banner","slot":"provider-banner-info-slot","order":1}],"workspaces":[{"name":"manage-user-workspace","component":"manageUserWorkspace","title":"Manage User Workspace","type":"other-form","canMaximize":true,"width":"extra-wide"},{"name":"user-role-scope-workspace","component":"userRoleScopeWorkspace","title":"User Rple Scope Workspace","type":"other-form","canMaximize":true,"width":"extra-wide"},{"name":"add-location-workspace","title":"Add Location","component":"addLocation","type":"workspace"},{"name":"search-location-workspace","title":"Search Location","component":"searchLocationWorkspace","type":"workspace"},{"name":"hwr-sync-workspace","title":"HWR Sync Workspace","component":"hwrSyncWorkspace","type":"other-form"},{"name":"hwr-sync-modal","title":"HWR Sync Modal","component":"hwrSyncModal","type":"modal"}],"modals":[{"component":"operationConfirmationModal","name":"operation-confirmation-modal"},{"component":"hwrConfirmationModal","name":"hwr-confirmation-modal"},{"component":"hwrEmptyModal","name":"hwr-empty-modal"},{"component":"hwrSyncModal","name":"hwr-syncing-modal"}],"pages":[{"component":"root","route":"admin"}],"version":"5.4.2-pre.2694"}
+{"$schema":"https://json.openmrs.org/routes.schema.json","backendDependencies":{"kenyaemrCharts":"^1.6.7"},"extensions":[{"component":"adminLeftPanelLink","name":"admin-left-panel-link","slot":"admin-left-panel-slot"},{"component":"userManagementLeftPannelLink","name":"user-management-left-panel-link","slot":"admin-left-panel-slot"},{"component":"etlAdministrationLeftPannelLink","name":"etl-administration-left-panel-link","slot":"admin-left-panel-slot"},{"component":"locationsLeftPanelLink","name":"locations-left-panel-link","slot":"admin-left-panel-slot"},{"component":"facilitySetupLeftPanelLink","name":"facility-setup-left-panel-link","slot":"admin-left-panel-slot"},{"component":"providerBanner","name":"provider-banner","slot":"provider-banner-info-slot","order":1}],"workspaces":[{"name":"manage-user-workspace","component":"manageUserWorkspace","title":"Manage User Workspace","type":"other-form","canMaximize":true,"width":"extra-wide"},{"name":"user-role-scope-workspace","component":"userRoleScopeWorkspace","title":"User Rple Scope Workspace","type":"other-form","canMaximize":true,"width":"extra-wide"},{"name":"add-location-workspace","title":"Add Location","component":"addLocation","type":"workspace"},{"name":"search-location-workspace","title":"Search Location","component":"searchLocationWorkspace","type":"workspace"},{"name":"hwr-sync-workspace","title":"HWR Sync Workspace","component":"hwrSyncWorkspace","type":"other-form"},{"name":"hwr-sync-modal","title":"HWR Sync Modal","component":"hwrSyncModal","type":"modal"}],"modals":[{"component":"operationConfirmationModal","name":"operation-confirmation-modal"},{"component":"hwrConfirmationModal","name":"hwr-confirmation-modal"},{"component":"hwrEmptyModal","name":"hwr-empty-modal"},{"component":"hwrSyncModal","name":"hwr-syncing-modal"}],"pages":[{"component":"root","route":"admin"}],"version":"5.4.2-pre.2699"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kenyaemr/esm-admin-app",
-  "version": "5.4.2-pre.2694",
+  "version": "5.4.2-pre.2699",
   "description": "Facilitates the management of ETL tables",
   "keywords": [
     "openmrs"

package/src/components/hook/healthWorkerAdapter.ts

@@ -0,0 +1,213 @@
+import { FetchResponse, makeUrl, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { HWR_API_NO_CREDENTIALS, PROVIDER_NOT_FOUND, RESOURCE_NOT_FOUND, UNKNOWN } from '../../constants';
+import { CustomHIEPractitionerResponse, PractitionerResponse } from '../../types';
+import { useState } from 'react';
+
+/**
+ * Unified response type that can handle both FHIR and custom HIE formats
+ */
+export interface UnifiedHealthWorkerResponse {
+  fhirFormat: boolean;
+  data: PractitionerResponse | CustomHIEPractitionerResponse;
+}
+
+/**
+ * Adapter to normalize health worker data based on response format
+ */
+export class HealthWorkerAdapter {
+  /**
+   * Extracts common practitioner information from either response format
+   */
+  static normalize(response: UnifiedHealthWorkerResponse): NormalizedPractitioner {
+    if (response.fhirFormat) {
+      return this.normalizeFHIRResponse(response.data as PractitionerResponse);
+    } else {
+      return this.normalizeCustomResponse(response.data as CustomHIEPractitionerResponse);
+    }
+  }
+
+  private static normalizeFHIRResponse(data: PractitionerResponse): NormalizedPractitioner {
+    const resource = data.entry?.[0]?.resource;
+    if (!resource) {
+      throw new Error('Invalid FHIR response: No resource found');
+    }
+
+    const name = resource.name?.[0];
+    const identifierByType = (code: string) =>
+      resource.identifier?.find((id) => id.type?.coding?.[0]?.code === code)?.value;
+
+    const primaryQualification = resource.qualification?.[0];
+    const licenseExtension = primaryQualification?.extension?.find(
+      (ext) => ext.url.includes('license') || ext.url.includes('registration'),
+    );
+
+    return {
+      id: resource.id,
+      fullName: name?.text || '',
+      firstName: name?.text?.split(' ')[0] || '',
+      middleName: name?.text?.split(' ')[1] || '',
+      lastName: name?.text?.split(' ')[2] || name?.text?.split(' ')[1] || '',
+      gender: resource.gender || '',
+      registrationId: identifierByType('registration') || '',
+      externalReferenceId: identifierByType('license') || '',
+      nationalId: identifierByType('national_id') || '',
+      passportNumber: identifierByType('passport') || '',
+      licenseNumber: identifierByType('license') || '',
+      licensingBody: licenseExtension?.valueCoding?.display || '',
+      specialty: primaryQualification?.code?.coding?.[0]?.display || '',
+      qualification: primaryQualification?.code?.coding?.[0]?.display || '',
+      phoneNumber: resource.telecom?.find((t) => t.system === 'phone')?.value || '',
+      email: resource.telecom?.find((t) => t.system === 'email')?.value || '',
+      licenseStartDate: primaryQualification?.period?.start || '',
+      licenseEndDate: primaryQualification?.period?.end || '',
+      isActive: resource.active,
+      providerUniqueIdentifier: resource.id,
+      status: resource.active ? 'active' : 'inactive',
+    };
+  }
+
+  private static normalizeCustomResponse(data: CustomHIEPractitionerResponse): NormalizedPractitioner {
+    const { membership, licenses, contacts, identifiers, professional_details } = data.message;
+
+    const mostRecentLicense = licenses
+      ?.filter((l) => l.license_end)
+      .sort((a, b) => new Date(b.license_end).getTime() - new Date(a.license_end).getTime())[0];
+
+    return {
+      id: membership.id,
+      fullName: membership.full_name,
+      firstName: membership.first_name,
+      middleName: membership.middle_name,
+      lastName: membership.last_name,
+      gender: membership.gender,
+      registrationId: membership.registration_id,
+      externalReferenceId: membership.external_reference_id,
+      nationalId: identifiers.identification_number,
+      passportNumber: '',
+      licenseNumber: membership.external_reference_id,
+      licensingBody: membership.licensing_body,
+      specialty: membership.specialty || professional_details?.specialty,
+      qualification: professional_details?.educational_qualifications || membership.specialty,
+      phoneNumber: contacts.phone,
+      email: contacts.email,
+      licenseStartDate: mostRecentLicense?.license_start || '',
+      licenseEndDate: mostRecentLicense?.license_end || '',
+      isActive: membership.is_active === 1,
+      providerUniqueIdentifier: membership.id,
+      status: membership.status,
+      professionalCadre: professional_details?.professional_cadre,
+      practiceType: professional_details?.practice_type,
+      licenses: licenses,
+    };
+  }
+
+  /**
+   * Type guard to check if response is FHIR format
+   */
+  static isFHIRFormat(response: any): response is PractitionerResponse {
+    return response.resourceType === 'Bundle' || (response.entry && Array.isArray(response.entry));
+  }
+}
+
+/**
+ * Normalized practitioner data structure
+ */
+export interface NormalizedPractitioner {
+  id: string;
+  fullName: string;
+  firstName: string;
+  middleName: string;
+  lastName: string;
+  gender: string;
+  registrationId: string;
+  externalReferenceId: string;
+  nationalId: string;
+  passportNumber: string;
+  licenseNumber: string;
+  licensingBody: string;
+  specialty: string;
+  qualification: string;
+  phoneNumber: string;
+  email: string;
+  licenseStartDate: string;
+  licenseEndDate: string;
+  isActive: boolean;
+  providerUniqueIdentifier: string;
+  status: string;
+  professionalCadre?: string;
+  practiceType?: string;
+  licenses?: Array<{
+    id: string;
+    external_reference_id: string;
+    license_type: string;
+    license_start: string;
+    license_end: string;
+  }>;
+}
+
+/**
+ * Search for health care worker with automatic format detection
+ */
+export const searchHealthCareWork = async (
+  identifierType: string,
+  identifierNumber: string,
+  regulator: string,
+): Promise<UnifiedHealthWorkerResponse> => {
+  const url = `${restBaseUrl}/kenyaemr/practitionersearch?identifierType=${identifierType}&identifierNumber=${identifierNumber}&regulator=${regulator}`;
+
+  const response = await fetch(makeUrl(url));
+
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new Error(HWR_API_NO_CREDENTIALS);
+    } else if (response.status === 404) {
+      throw new Error(RESOURCE_NOT_FOUND);
+    }
+    throw new Error(UNKNOWN);
+  }
+
+  const responseData = await response.json();
+
+  // Check for error in response
+  if (responseData?.issue) {
+    throw new Error(PROVIDER_NOT_FOUND);
+  }
+
+  // Determine format based on fhirFormat flag or structure
+  const isFhir = responseData.fhirFormat === true || HealthWorkerAdapter.isFHIRFormat(responseData);
+
+  return {
+    fhirFormat: isFhir,
+    data: responseData,
+  };
+};
+
+/**
+ * Hook for searching health care worker with normalized data
+ */
+export const useHealthWorkerSearch = () => {
+  const [isSearching, setIsSearching] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const search = async (
+    identifierType: string,
+    identifierNumber: string,
+    regulator: string,
+  ): Promise<NormalizedPractitioner | null> => {
+    try {
+      setIsSearching(true);
+      setError(null);
+
+      const response = await searchHealthCareWork(identifierType, identifierNumber, regulator);
+      return HealthWorkerAdapter.normalize(response);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : UNKNOWN;
+      setError(errorMessage);
+      return null;
+    } finally {
+      setIsSearching(false);
+    }
+  };
+
+  return { search, isSearching, error };
+};

package/src/components/modal/hwr-confirmation.modal.tsx

@@ -4,6 +4,7 @@ import capitalize from 'lodash-es/capitalize';
 import React from 'react';
 import { useTranslation } from 'react-i18next';
 import { CustomHIEPractitionerResponse, type PractitionerResponse } from '../../types';
+import { NormalizedPractitioner } from '../hook/healthWorkerAdapter';
 import styles from './hwr-confirmation.modal.scss';
 import { formatDateTime } from '../../utils/utils';
 
@@ -24,19 +25,21 @@ const HealthWorkerInfo: React.FC<HealthWorkerInfoProps> = ({ label, value }) =>
 interface HWRConfirmModalProps {
   onConfirm: () => void;
   close: () => void;
-  healthWorker: CustomHIEPractitionerResponse;
+  healthWorker: CustomHIEPractitionerResponse | PractitionerResponse;
+  normalizedData: NormalizedPractitioner;
+  fhirFormat: boolean;
 }
 
-const HWRConfirmModal: React.FC<HWRConfirmModalProps> = ({ close, onConfirm, healthWorker }) => {
+const HWRConfirmModal: React.FC<HWRConfirmModalProps> = ({
+  close,
+  onConfirm,
+  healthWorker,
+  normalizedData,
+  fhirFormat,
+}) => {
   const { t } = useTranslation();
 
-  const { membership, licenses, contacts, identifiers, professional_details } = healthWorker?.message || {};
-
-  const mostRecentLicense = licenses
-    ?.filter((l) => l.license_end)
-    .sort((a, b) => new Date(b.license_end).getTime() - new Date(a.license_end).getTime())[0];
-
-  const isLicenseValid = mostRecentLicense?.license_end ? new Date(mostRecentLicense.license_end) > new Date() : false;
+  const isLicenseValid = normalizedData.licenseEndDate ? new Date(normalizedData.licenseEndDate) > new Date() : false;
 
   return (
     <>
@@ -55,69 +58,71 @@ const HWRConfirmModal: React.FC<HWRConfirmModalProps> = ({ close, onConfirm, hea
             className={styles.healthWorkerPhoto}
             name="patient-photo-slot"
             state={{
-              patientName: membership?.full_name || '',
+              patientName: normalizedData.fullName || '',
             }}
           />
           <div style={{ width: '100%', marginLeft: '0.625rem' }}>
             <HealthWorkerInfo
               label={t('healthWorkerName', 'Health worker name')}
-              value={membership?.full_name || '--'}
+              value={normalizedData.fullName || '--'}
             />
 
             <HealthWorkerInfo
               label={t('providerUniqueIdentifier', 'Provider unique identifier')}
-              value={membership?.id || '--'}
+              value={normalizedData.providerUniqueIdentifier || '--'}
             />
 
             <HealthWorkerInfo
               label={t('registrationId', 'Registration ID')}
-              value={membership?.registration_id || '--'}
+              value={normalizedData.registrationId || '--'}
             />
 
             <HealthWorkerInfo
               label={t('externalReferenceId', 'External Reference ID')}
-              value={membership?.external_reference_id || '--'}
+              value={normalizedData.externalReferenceId || '--'}
             />
 
-            <HealthWorkerInfo label={t('gender', 'Gender')} value={membership?.gender || '--'} />
+            <HealthWorkerInfo label={t('gender', 'Gender')} value={normalizedData.gender || '--'} />
 
-            <HealthWorkerInfo label={t('status', 'Status')} value={membership?.status || '--'} />
+            <HealthWorkerInfo label={t('status', 'Status')} value={normalizedData.status || '--'} />
 
-            {contacts?.phone && <HealthWorkerInfo label={t('phone', 'Phone')} value={contacts.phone} />}
+            {normalizedData.phoneNumber && (
+              <HealthWorkerInfo label={t('phone', 'Phone')} value={normalizedData.phoneNumber} />
+            )}
 
-            {contacts?.email && <HealthWorkerInfo label={t('email', 'Email')} value={contacts.email} />}
+            {normalizedData.email && <HealthWorkerInfo label={t('email', 'Email')} value={normalizedData.email} />}
 
-            {identifiers?.identification_number && (
+            {normalizedData.nationalId && (
               <HealthWorkerInfo
-                label={identifiers.identification_type || t('identificationNumber', 'Identification Number')}
-                value={identifiers.identification_number}
+                label={t('identificationNumber', 'Identification Number')}
+                value={normalizedData.nationalId}
               />
             )}
 
-            <HealthWorkerInfo label={t('licensingBody', 'Licensing Body')} value={membership?.licensing_body || '--'} />
-
             <HealthWorkerInfo
-              label={t('specialty', 'Specialty')}
-              value={membership?.specialty || professional_details?.specialty || '--'}
+              label={t('licensingBody', 'Licensing Body')}
+              value={normalizedData.licensingBody || '--'}
             />
 
-            {professional_details?.professional_cadre && (
+            <HealthWorkerInfo label={t('specialty', 'Specialty')} value={normalizedData.specialty || '--'} />
+
+            {normalizedData.professionalCadre && (
               <HealthWorkerInfo
                 label={t('professionalCadre', 'Professional Cadre')}
-                value={professional_details.professional_cadre}
+                value={normalizedData.professionalCadre}
               />
             )}
 
-            {professional_details?.practice_type && (
-              <HealthWorkerInfo label={t('practiceType', 'Practice Type')} value={professional_details.practice_type} />
+            {normalizedData.practiceType && (
+              <HealthWorkerInfo label={t('practiceType', 'Practice Type')} value={normalizedData.practiceType} />
             )}
 
-            {licenses && licenses.length > 0 && (
+            {normalizedData.licenses && normalizedData.licenses.length > 0 && (
               <>
                 <div style={{ marginTop: '1rem', marginBottom: '0.5rem' }}>
                   <strong>{t('licenses', 'Licenses')}</strong>
                 </div>
-                {licenses.map((license, index) => (
+                {normalizedData.licenses.map((license, index) => (
                   <div key={index} style={{ marginBottom: '0.5rem', paddingLeft: '1rem' }}>
                     <HealthWorkerInfo
                       label={`${license.license_type} ${t('license', 'License')}`}
@@ -132,6 +137,15 @@ const HWRConfirmModal: React.FC<HWRConfirmModalProps> = ({ close, onConfirm, hea
               </>
             )}
 
+            {normalizedData.licenseStartDate && normalizedData.licenseEndDate && (
+              <HealthWorkerInfo
+                label={t('licenseValidity', 'License Validity Period')}
+                value={`${formatDateTime(normalizedData.licenseStartDate)} - ${formatDateTime(
+                  normalizedData.licenseEndDate,
+                )}`}
+              />
+            )}
+
             <HealthWorkerInfo
               label={t('licenseValid', 'License Validity')}
               value={

package/src/components/modal/hwr-sync.modal.tsx

@@ -6,7 +6,7 @@ import { useConfig, showSnackbar, formatDate, parseDate, showToast, restBaseUrl
 import { mutate } from 'swr';
 import { CustomHIEPractitionerResponse, type PractitionerResponse, type ProviderResponse } from '../../types';
 import { ConfigObject } from '../../config-schema';
-import { searchHealthCareWork } from '../hook/searchHealthCareWork';
+import { searchHealthCareWork, HealthWorkerAdapter } from '../hook/healthWorkerAdapter';
 import { createProviderAttribute, updateProviderAttributes } from './hwr-sync.resource';
 
 interface HWRSyncModalProps {
@@ -71,57 +71,43 @@ const HWRSyncModal: React.FC<HWRSyncModalProps> = ({ close, provider }) => {
   const handleSync = async () => {
     try {
       setSyncLoading(true);
-      const healthWorker: CustomHIEPractitionerResponse = await searchHealthCareWork(
+      const unifiedResponse = await searchHealthCareWork(
         searchHWR.identifierType,
         searchHWR.identifier,
         searchHWR.regulator,
       );
 
-      if (!healthWorker?.message) {
+      const normalizedData = HealthWorkerAdapter.normalize(unifiedResponse);
+
+      if (!normalizedData) {
         throw new Error(t('noResults', 'No results found'));
       }
 
-      const { membership, licenses, contacts, identifiers } = healthWorker.message;
-
-      const mostRecentLicense = licenses
-        ?.filter((l) => l.license_end)
-        .sort((a, b) => new Date(b.license_end).getTime() - new Date(a.license_end).getTime())[0];
-
-      const extractedAttributes = {
-        licenseNumber: membership.external_reference_id,
-        regNumber: membership.registration_id,
-        licenseDate: mostRecentLicense?.license_end ? formatDate(new Date(mostRecentLicense.license_end)) : null,
-        phoneNumber: contacts.phone,
-        email: contacts.email,
-        qualification: membership.specialty,
-        nationalId: identifiers.identification_number,
-        providerUniqueIdentifier: membership.id,
-      };
-
       const updatableAttributes = [
-        { attributeType: licenseNumberUuid, value: extractedAttributes.licenseNumber },
-        { attributeType: licenseBodyUuid, value: extractedAttributes.regNumber },
+        { attributeType: licenseNumberUuid, value: normalizedData.licenseNumber },
+        { attributeType: licenseBodyUuid, value: normalizedData.registrationId },
         {
           attributeType: licenseExpiryDateUuid,
-          value: extractedAttributes.licenseDate ? parseDate(extractedAttributes.licenseDate) : null,
+          value: normalizedData.licenseEndDate ? parseDate(normalizedData.licenseEndDate) : null,
         },
-        { attributeType: phoneNumberUuid, value: extractedAttributes.phoneNumber },
-        { attributeType: qualificationUuid, value: extractedAttributes.qualification },
+        { attributeType: phoneNumberUuid, value: normalizedData.phoneNumber },
+        { attributeType: qualificationUuid, value: normalizedData.qualification },
         {
           attributeType: providerHieFhirReference,
           value: JSON.stringify({
-            ...healthWorker,
+            ...unifiedResponse.data,
+            fhirFormat: unifiedResponse.fhirFormat,
             searchParameters: {
               regulator: searchHWR.regulator,
               identifierType: searchHWR.identifierType,
             },
           }),
         },
-        { attributeType: providerAddressUuid, value: extractedAttributes.email },
-        { attributeType: providerNationalIdUuid, value: extractedAttributes.nationalId },
+        { attributeType: providerAddressUuid, value: normalizedData.email },
+        { attributeType: providerNationalIdUuid, value: normalizedData.nationalId },
         {
           attributeType: providerUniqueIdentifierAttributeTypeUuid,
-          value: extractedAttributes.providerUniqueIdentifier,
+          value: normalizedData.providerUniqueIdentifier,
         },
       ].filter((attr) => attr.value !== undefined && attr.value !== null && attr.value !== '');
 

package/src/components/users/manage-users/user-management.workspace.tsx

@@ -47,7 +47,7 @@ import UserManagementFormSchema from '../userManagementFormSchema';
 import { ChevronLeft, Query, ChevronRight } from '@carbon/react/icons';
 import { useSystemUserRoleConfigSetting } from '../../hook/useSystemRoleSetting';
 import { type CustomHIEPractitionerResponse, type PractitionerResponse, Provider, User } from '../../../types';
-import { searchHealthCareWork } from '../../hook/searchHealthCareWork';
+import { searchHealthCareWork, HealthWorkerAdapter, NormalizedPractitioner } from '../../hook/healthWorkerAdapter';
 import { ROLE_CATEGORIES, SECTIONS, today } from '../../../constants';
 import { ConfigObject } from '../../../config-schema';
 import { mutate } from 'swr';
@@ -230,10 +230,6 @@ const ManageUserWorkspace: React.FC<ManageUserWorkspaceProps> = ({
     providerUniqueIdentifier,
   ]);
 
-  function extractAttributeValue(attributes, prefix: string) {
-    return attributes?.find((attr) => attr.display.startsWith(prefix))?.display?.split(' ')[3] || '';
-  }
-
   const userFormMethods = useForm<UserFormSchema>({
     resolver: zodResolver(userManagementFormSchema),
     mode: 'all',
@@ -256,55 +252,48 @@ const ManageUserWorkspace: React.FC<ManageUserWorkspaceProps> = ({
     }
   }, [isDirty, promptBeforeClosing]);
 
-  const setPractitionerValues = (healthWorker: CustomHIEPractitionerResponse) => {
-    const { membership, licenses, contacts, identifiers } = healthWorker.message;
-
-    setValue('givenName', membership.first_name || '');
-    setValue('middleName', membership.middle_name || '');
-    setValue('familyName', membership.last_name || '');
-
-    setValue('nationalId', identifiers.identification_number || '');
-    setValue('providerLicense', membership.external_reference_id || '');
-    setValue('registrationNumber', membership.registration_id || '');
-    setValue('providerUniqueIdentifier', membership.id || '');
-
-    setValue('phoneNumber', contacts.phone || '');
-    setValue('email', contacts.email || '');
-
-    setValue('qualification', membership.specialty || '');
-
-    setValue('passportNumber', '');
-
-    const mostRecentLicense = licenses
-      .filter((l) => l.license_end)
-      .sort((a, b) => new Date(b.license_end).getTime() - new Date(a.license_end).getTime())[0];
-
+  const setPractitionerValuesFromNormalized = (normalized: NormalizedPractitioner) => {
+    setValue('givenName', normalized.firstName || '');
+    setValue('middleName', normalized.middleName || '');
+    setValue('familyName', normalized.lastName || '');
+    setValue('nationalId', normalized.nationalId || '');
+    setValue('providerLicense', normalized.licenseNumber || '');
+    setValue('registrationNumber', normalized.registrationId || '');
+    setValue('providerUniqueIdentifier', normalized.providerUniqueIdentifier || '');
+    setValue('phoneNumber', normalized.phoneNumber || '');
+    setValue('email', normalized.email || '');
+    setValue('qualification', normalized.qualification || '');
+    setValue('passportNumber', normalized.passportNumber || '');
     setValue(
       'licenseExpiryDate',
-      mostRecentLicense?.license_end ? parseDate(mostRecentLicense.license_end) : parseDate(t('unknown', 'Unknown')),
+      normalized.licenseEndDate ? parseDate(normalized.licenseEndDate) : parseDate(t('unknown', 'Unknown')),
     );
   };
 
   const handleSearch = async () => {
     try {
       setSearchHWR({ ...searchHWR, isHWRLoading: true });
-      const fetchedHealthWorker: CustomHIEPractitionerResponse = await searchHealthCareWork(
+      const unifiedResponse = await searchHealthCareWork(
         searchHWR.identifierType,
         searchHWR.identifier,
         searchHWR.regulator,
       );
 
-      if (!fetchedHealthWorker?.message) {
+      const normalizedData = HealthWorkerAdapter.normalize(unifiedResponse);
+
+      if (!normalizedData) {
         showModal('hwr-empty-modal', { errorCode: t('noResults', 'No results found') });
         return;
       }
 
       const dispose = showModal('hwr-confirmation-modal', {
-        healthWorker: fetchedHealthWorker,
+        healthWorker: unifiedResponse.data,
+        normalizedData: normalizedData,
+        fhirFormat: unifiedResponse.fhirFormat,
         onConfirm: () => {
           dispose();
-          setPractitionerValues(fetchedHealthWorker);
-          setHealthWorker(fetchedHealthWorker);
+          setPractitionerValuesFromNormalized(normalizedData);
+          setHealthWorker(unifiedResponse.data);
         },
       });
     } catch (error) {
@@ -313,6 +302,7 @@ const ManageUserWorkspace: React.FC<ManageUserWorkspaceProps> = ({
       setSearchHWR({ ...searchHWR, isHWRLoading: false });
     }
   };
+
   const onSubmit = async (data: UserFormSchema) => {
     const setProvider = data.providerIdentifiers;
     const editProvider = data.isEditProvider;
@@ -479,12 +469,6 @@ const ManageUserWorkspace: React.FC<ManageUserWorkspaceProps> = ({
     });
   };
 
-  useEffect(() => {
-    if (isDirty) {
-      promptBeforeClosing(() => isDirty);
-    }
-  }, [isDirty, promptBeforeClosing]);
-
   const toggleSection = (section: string) => {
     setActiveSection((prev) => (prev !== section ? section : prev));
   };