@kenyaemr/esm-morgue-app 5.4.2-pre.2279 → 5.4.2-pre.2288

package/src/bed-linelist-view/discharged/discharged-bed-line-view.component.tsx

@@ -0,0 +1,256 @@
+// DischargedBedLineListView.tsx
+import React, { useState, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import {
+  DataTable,
+  InlineLoading,
+  Table,
+  TableBody,
+  TableCell,
+  TableContainer,
+  TableHead,
+  TableHeader,
+  TableRow,
+  Button,
+  Pagination,
+  OverflowMenu,
+  OverflowMenuItem,
+  DataTableSkeleton,
+} from '@carbon/react';
+import { useConfig } from '@openmrs/esm-framework';
+import styles from '../bed-linelist-view.scss';
+import { formatDateTime } from '../../utils/utils';
+import { type MortuaryLocationResponse } from '../../types';
+import { ConfigObject } from '../../config-schema';
+import usePatients, { useMortuaryDischargeEncounter } from '../../bed-layout/discharged/discharged-bed-layout.resource';
+import { EmptyState } from '@openmrs/esm-patient-common-lib';
+
+interface DischargedBedLineListViewProps {
+  AdmittedDeceasedPatient: MortuaryLocationResponse | null;
+  isLoading: boolean;
+  paginated?: boolean;
+  initialPageSize?: number;
+  pageSizes?: number[];
+  onPrintGatePass?: (patientUuid: string) => void;
+  onPrintPostmortem?: (patientUuid: string) => void;
+  mutate?: () => void;
+}
+
+const DischargedBedLineListView: React.FC<DischargedBedLineListViewProps> = ({
+  AdmittedDeceasedPatient,
+  isLoading,
+  paginated = true,
+  initialPageSize = 10,
+  pageSizes = [10, 20, 30, 40, 50],
+  onPrintGatePass,
+  onPrintPostmortem,
+  mutate,
+}) => {
+  const { t } = useTranslation();
+  const { morgueDischargeEncounterTypeUuid } = useConfig<ConfigObject>();
+
+  const [currentPage, setCurrentPage] = useState(1);
+  const [currPageSize, setCurrPageSize] = useState(initialPageSize);
+
+  const {
+    dischargedPatientUuids,
+    isLoading: encountersLoading,
+    error: encountersError,
+  } = useMortuaryDischargeEncounter(morgueDischargeEncounterTypeUuid, AdmittedDeceasedPatient);
+
+  const {
+    patients: dischargedPatients,
+    isLoading: patientsLoading,
+    error: patientsError,
+  } = usePatients(dischargedPatientUuids || []);
+
+  const headers = [
+    { key: 'name', header: t('name', 'Name') },
+    { key: 'idNumber', header: t('idNumber', 'ID Number') },
+    { key: 'gender', header: t('gender', 'Gender') },
+    { key: 'age', header: t('age', 'Age') },
+    { key: 'causeOfDeath', header: t('causeOfDeath', 'Cause of Death') },
+    { key: 'dateOfDeath', header: t('dateOfDeath', 'Date of Death') },
+    { key: 'daysSinceDeath', header: t('daysSinceDeath', 'Days Since Death') },
+    { key: 'action', header: t('action', 'Action') },
+  ];
+
+  const calculateDaysSinceDeath = (dateOfDeath: string): number => {
+    if (!dateOfDeath) {
+      return 0;
+    }
+    const deathDate = new Date(dateOfDeath);
+    const currentDate = new Date();
+    const timeDiff = currentDate.getTime() - deathDate.getTime();
+    return Math.floor(timeDiff / (1000 * 3600 * 24));
+  };
+
+  const handlePrintGatePass = (patientUuid: string) => {
+    if (onPrintGatePass) {
+      onPrintGatePass(patientUuid);
+    }
+  };
+
+  const handlePrintPostmortem = (patientUuid: string) => {
+    if (onPrintPostmortem) {
+      onPrintPostmortem(patientUuid);
+    }
+  };
+
+  const allRows = useMemo(() => {
+    if (!dischargedPatients || dischargedPatients.length === 0) {
+      return [];
+    }
+
+    const rows = dischargedPatients.map((patient, index) => {
+      const patientUuid = patient?.uuid || `patient-${index}`;
+      const patientName = patient?.person?.display || '-';
+      const gender = patient?.person?.gender || '-';
+      const age = patient?.person?.age || '-';
+      const causeOfDeath = patient?.person?.causeOfDeath?.display || '-';
+      const dateOfDeath = patient?.person?.deathDate;
+      const daysSinceDeath = calculateDaysSinceDeath(dateOfDeath);
+
+      return {
+        id: patientUuid,
+        idNumber:
+          patient?.identifiers
+            ?.find((id) => id.display?.includes('OpenMRS ID'))
+            ?.display?.split('=')?.[1]
+            ?.trim() || '-',
+        name: patientName,
+        gender: gender,
+        age: age.toString(),
+        causeOfDeath: causeOfDeath,
+        dateOfDeath: formatDateTime(dateOfDeath),
+        daysSinceDeath: daysSinceDeath.toString(),
+        action: patientUuid,
+      };
+    });
+
+    return rows;
+  }, [dischargedPatients]);
+
+  const totalCount = allRows.length;
+  const startIndex = (currentPage - 1) * currPageSize;
+  const endIndex = startIndex + currPageSize;
+  const paginatedRows = paginated ? allRows.slice(startIndex, endIndex) : allRows;
+
+  const goTo = (page: number) => {
+    setCurrentPage(page);
+  };
+
+  const handlePaginationChange = ({ page: newPage, pageSize }: { page: number; pageSize: number }) => {
+    if (newPage !== currentPage) {
+      goTo(newPage);
+    }
+    if (pageSize !== currPageSize) {
+      setCurrPageSize(pageSize);
+      setCurrentPage(1);
+    }
+  };
+
+  const isLoadingData = isLoading || encountersLoading || patientsLoading;
+
+  if (isLoadingData) {
+    return (
+      <div className={styles.loadingContainer}>
+        <DataTableSkeleton columnCount={headers.length} rowCount={5} />
+      </div>
+    );
+  }
+
+  if (encountersError || patientsError) {
+    return (
+      <div className={styles.emptyState}>
+        <EmptyState
+          headerTitle={t('noDischargedPatients', 'No discharged patients found')}
+          displayText={t('noDischargedPatientsDescription', 'There are currently no discharged patients to display.')}
+        />{' '}
+      </div>
+    );
+  }
+
+  if (!dischargedPatients || dischargedPatients.length === 0) {
+    return (
+      <div className={styles.emptyState}>
+        <EmptyState
+          headerTitle={t('noDischargedPatients', 'No discharged patients found')}
+          displayText={t('noDischargedPatientsDescription', 'There are currently no discharged patients to display.')}
+        />
+      </div>
+    );
+  }
+
+  return (
+    <div className={styles.bedLayoutWrapper}>
+      <DataTable rows={paginatedRows} headers={headers} isSortable useZebraStyles>
+        {({ rows, headers, getHeaderProps, getRowProps, getTableProps, getCellProps }) => (
+          <TableContainer>
+            <Table {...getTableProps()} aria-label="discharged patients table">
+              <TableHead>
+                <TableRow>
+                  {headers.map((header) => (
+                    <TableHeader
+                      key={header.key}
+                      {...getHeaderProps({
+                        header,
+                      })}>
+                      {header.header}
+                    </TableHeader>
+                  ))}
+                </TableRow>
+              </TableHead>
+              <TableBody>
+                {rows.map((row) => {
+                  const patientData = dischargedPatients.find((patient) => patient?.uuid === row.id);
+                  const patientName = patientData?.person?.display || '';
+
+                  return (
+                    <TableRow key={row.id} {...getRowProps({ row })}>
+                      {row.cells.map((cell) => (
+                        <TableCell key={cell.id} {...getCellProps({ cell })}>
+                          {cell.info.header === 'action' ? (
+                            <div className={styles.actionButtons}>
+                              <OverflowMenu flipped>
+                                <OverflowMenuItem
+                                  onClick={() => handlePrintGatePass(row.id)}
+                                  itemText={t('printGatePass', 'Gate Pass')}
+                                  disabled={!patientData}
+                                />
+                                <OverflowMenuItem
+                                  onClick={() => handlePrintPostmortem(row.id)}
+                                  itemText={t('printPostmortem', 'Postmortem')}
+                                  disabled={!patientData}
+                                />
+                              </OverflowMenu>
+                            </div>
+                          ) : (
+                            cell.value
+                          )}
+                        </TableCell>
+                      ))}
+                    </TableRow>
+                  );
+                })}
+              </TableBody>
+            </Table>
+          </TableContainer>
+        )}
+      </DataTable>
+
+      {paginated && !isLoadingData && totalCount > 0 && (
+        <Pagination
+          page={currentPage}
+          pageSize={currPageSize}
+          pageSizes={pageSizes}
+          totalItems={totalCount}
+          size={'sm'}
+          onChange={handlePaginationChange}
+        />
+      )}
+    </div>
+  );
+};
+
+export default DischargedBedLineListView;

package/src/config-schema.ts

@@ -1,6 +1,12 @@
 import { Type } from '@openmrs/esm-framework';
+import _default from 'react-hook-form/dist/utils/createSubject';
 
 export const configSchema = {
+  mortuaryLocationTagUuid: {
+    _type: Type.String,
+    _description: 'UUID for mortuary location tag',
+    _default: '1dbbfe22-d21f-499c-bf33-cc9f75b6c7e8',
+  },
   morgueVisitTypeUuid: {
     _type: Type.String,
     _description: ' UUID for morgue visit',
@@ -16,23 +22,19 @@ export const configSchema = {
     _description: ' UUID for insurance payment mode',
     _default: 'beac329b-f1dc-4a33-9e7c-d95821a137a6',
   },
-  morgueCompartmentTagUuid: {
-    _type: Type.String,
-    _description: 'UUID for morgue compartment tag',
-    _default: 'a69f6810-fa6a-4423-a3e4-f88e8ac032dd',
-  },
+
   tagNumberUuid: {
     _type: Type.String,
     _description: 'UUID for tag number concept',
     _default: 'f2b35679-7ba9-4619-92cb-6872b0c6bf57',
   },
-  morgueAdmissionEncounterType: {
+  morgueAdmissionEncounterTypeUuid: {
     _type: Type.String,
     _description: 'Encounter type for morgue admission',
     _default: '3d2df845-6f3c-45e7-b91a-d828a1f9c2e8',
   },
   morgueDischargeEncounterTypeUuid: {
-    type: Type.String,
+    _type: Type.String,
     _description: 'Encounter type for morgue discharge',
     _default: '3d618f40b-b5a3-4f17-81c8-2f04e2aad58e',
   },
@@ -96,6 +98,31 @@ export const configSchema = {
     _description: 'UUID for admin user',
     _default: 'e02c40e5-04e7-11e5-ae3c-a0b3cc4f922f',
   },
+  autopsyFormUuid: {
+    _type: Type.String,
+    _description: 'UUID for autopsy form',
+    _default: '2b61a73-4971-4fc0-b20b-9a30176317e2',
+  },
+  autopsyEncounterFormUuid: {
+    _type: Type.String,
+    _description: 'Encounter UUID for autopsy',
+    _default: '32b61a73-4971-4fc0-b20b-9a30176317e2',
+  },
+  nextOfKinNamesUuid: {
+    _type: Type.String,
+    _description: 'UUID for next of kin names concept',
+    _default: '830bef6d-b01f-449d-9f8d-ac0fede8dbd3',
+  },
+  courtOrderCaseNumberUuid: {
+    _type: Type.String,
+    _description: 'UUID for court order case number concept',
+    _default: '26e0da6c-3e53-4f7d-9a3a-1c2f634450f7',
+  },
+  serialNumberUuid: {
+    _type: Type.String,
+    _description: 'UUID for serial number concept',
+    _default: '1646AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
 };
 
 export interface BillingConfig {
@@ -124,9 +151,9 @@ export type ConfigObject = {
   morgueVisitTypeUuid: string;
   morgueDepartmentServiceTypeUuid: string;
   insurancepaymentModeUuid: string;
-  morgueCompartmentTagUuid: string;
+  mortuaryLocationTagUuid: string;
   tagNumberUuid: string;
-  morgueAdmissionEncounterType: string;
+  morgueAdmissionEncounterTypeUuid: string;
   nextOfKinNameUuid: string;
   nextOfKinRelationshipUuid: string;
   nextOfKinAddressUuid: string;
@@ -141,4 +168,9 @@ export type ConfigObject = {
   dischargeAreaUuid: string;
   morgueDischargeEncounterTypeUuid: string;
   adminUuid: string;
+  autopsyFormUuid: string;
+  autopsyEncounterFormUuid: string;
+  nextOfKinNamesUuid: string;
+  courtOrderCaseNumberUuid: string;
+  serialNumberUuid: string;
 };

package/src/constants.ts

@@ -1 +1,58 @@
 export const PENDING_PAYMENT_STATUS = 'PENDING';
+
+export const customRepProps = [
+  ['metadataSourceName', 'ref'],
+  ['orderingProviderEncounterRole', 'ref'],
+  ['supportsTransferLocationTag', '(uuid,display,name,links)'],
+  ['unknownLocation', 'ref'],
+  ['denyAdmissionConcept', 'ref'],
+  ['admissionForm', 'ref'],
+  ['exitFromInpatientEncounterType', 'ref'],
+  ['extraPatientIdentifierTypes', 'ref'],
+  ['consultFreeTextCommentsConcept', 'ref'],
+  ['sameAsConceptMapType', 'ref'],
+  ['testPatientPersonAttributeType', 'ref'],
+  ['admissionDecisionConcept', 'ref'],
+  ['supportsAdmissionLocationTag', '(uuid,display,name,links)'],
+  ['checkInEncounterType', 'ref'],
+  ['transferWithinHospitalEncounterType', 'ref'],
+  ['suppressedDiagnosisConcepts', 'ref'],
+  ['primaryIdentifierType', 'ref'],
+  ['nonDiagnosisConceptSets', 'ref'],
+  ['fullPrivilegeLevel', 'ref'],
+  ['unknownProvider', 'ref'],
+  ['diagnosisSets', 'ref'],
+  ['personImageDirectory', 'ref'],
+  ['visitNoteEncounterType', 'ref'],
+  ['inpatientNoteEncounterType', 'ref'],
+  ['transferRequestEncounterType', 'ref'],
+  ['consultEncounterType', 'ref'],
+  ['diagnosisMetadata', 'ref'],
+  ['narrowerThanConceptMapType', 'ref'],
+  ['clinicianEncounterRole', 'ref'],
+  ['conceptSourcesForDiagnosisSearch', 'ref'],
+  ['patientDiedConcept', 'ref'],
+  ['emrApiConceptSource', 'ref'],
+  ['lastViewedPatientSizeLimit', 'ref'],
+  ['identifierTypesToSearch', 'ref'],
+  ['telephoneAttributeType', 'ref'],
+  ['checkInClerkEncounterRole', 'ref'],
+  ['dischargeForm', 'ref'],
+  ['unknownCauseOfDeathConcept', 'ref'],
+  ['visitAssignmentHandlerAdjustEncounterTimeOfDayIfNecessary', 'ref'],
+  ['atFacilityVisitType', 'ref'],
+  ['visitExpireHours', 'ref'],
+  ['admissionEncounterType', 'ref'],
+  ['motherChildRelationshipType', 'ref'],
+  ['dispositions', 'ref'],
+  ['dispositionDescriptor', 'ref'],
+  ['highPrivilegeLevel', 'ref'],
+  ['supportsLoginLocationTag', '(uuid,display,name,links)'],
+  ['unknownPatientPersonAttributeType', 'ref'],
+  ['supportsVisitsLocationTag', '(uuid,display,name,links)'],
+  ['transferForm', 'ref'],
+  ['bedAssignmentEncounterType', 'ref'],
+  ['cancelADTRequestEncounterType', 'ref'],
+  ['admissionDecisionConcept', 'ref'],
+  ['denyAdmissionConcept', 'ref'],
+];

package/src/deceased-patient-header/deceased-patient-header.component.tsx

@@ -0,0 +1,31 @@
+import { Tile } from '@carbon/react';
+import { PatientPhoto, usePatient } from '@openmrs/esm-framework';
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { formatDeceasedName } from '../utils/utils';
+import styles from './deceased-patient-header.scss';
+import { type MortuaryPatient } from '../types';
+
+interface DeceasedPatientHeaderProps {
+  patientData: MortuaryPatient;
+}
+export const DeceasedPatientHeader: React.FC<DeceasedPatientHeaderProps> = ({ patientData }) => {
+  const { t } = useTranslation();
+
+  return (
+    <Tile>
+      <div className={styles.patientHeader}>
+        <PatientPhoto patientUuid={patientData?.patient?.uuid} patientName={patientData?.person?.person?.display} />
+        <div className={styles.patientInfo}>
+          <span className={styles.patientName}>{patientData?.person?.person?.display}</span>
+          <div className={styles.patientDetails}>
+            <span className={styles.gender}>{patientData?.person?.person?.gender}</span>
+            <span className={styles.middot}>•</span>
+            <span className={styles.age}>{patientData?.person?.person?.age}</span>
+            <span className={styles.ageUnit}>{t('yearsOld', 'Yrs old')}</span>
+          </div>
+        </div>
+      </div>
+    </Tile>
+  );
+};

package/src/deceased-patient-header/deceased-patient-header.scss

@@ -0,0 +1,50 @@
+@use '@carbon/colors';
+@use '@carbon/layout';
+@use '@carbon/type';
+
+.patientHeader {
+  display: flex;
+  gap: layout.$spacing-05;
+  align-items: flex-start;
+}
+
+.patientInfo {
+  display: flex;
+  flex-direction: column;
+  gap: layout.$spacing-02;
+}
+
+.patientDetails {
+  display: flex;
+  align-items: center;
+  gap: layout.$spacing-03;
+  flex-wrap: wrap;
+}
+
+.middot {
+  color: colors.$gray-70;
+  font-weight: bold;
+}
+
+.gender {
+  @include type.type-style('body-01');
+  color: colors.$gray-70;
+  font-weight: 500;
+}
+
+.age {
+  @include type.type-style('body-01');
+  color: colors.$gray-70;
+  font-weight: 500;
+}
+
+.ageUnit {
+  @include type.type-style('body-01');
+  color: colors.$gray-70;
+  margin-left: layout.$spacing-01;
+}
+
+.patientName {
+  @include type.type-style('body-01');
+  margin-bottom: layout.$spacing-01;
+}

package/src/{component → deceased-patient-header}/deceasedInfo/deceased-info.component.tsx

@@ -4,7 +4,7 @@ import React from 'react';
 import styles from './deceased-info.scss';
 import { formatDeceasedName } from '../../utils/utils';
 import { useTranslation } from 'react-i18next';
-import { usePerson } from '../../hook/useMorgue.resource';
+import { usePerson } from './deceased-info.resource';
 
 const DeceasedInfo: React.FC<{ patientUuid: string }> = ({ patientUuid }) => {
   const { isLoading, patient, error } = usePatient(patientUuid);

package/src/deceased-patient-header/deceasedInfo/deceased-info.resource.ts

@@ -0,0 +1,11 @@
+import { FetchResponse, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { Patient } from '../../types';
+import useSWR from 'swr';
+
+export const usePerson = (uuid: string) => {
+  const customRepresentation = `custom:(uuid,display,gender,birthdate,dead,age,deathDate,causeOfDeath:(uuid,display))`;
+  const url = `${restBaseUrl}/person/${uuid}?v=${customRepresentation}`;
+  const { isLoading, error, data } = useSWR<FetchResponse<Patient['person']>>(url, openmrsFetch);
+  const person = data?.data;
+  return { isLoading, error, person };
+};

package/src/extension/actionButton.component.tsx

@@ -3,8 +3,9 @@ import { useTranslation } from 'react-i18next';
 import { launchWorkspace, navigate, UserHasAccess } from '@openmrs/esm-framework';
 import { Movement, Return, ShareKnowledge } from '@carbon/react/icons';
 import React from 'react';
-import { useAdmissionLocation } from '../hook/useMortuaryAdmissionLocation';
+
 import styles from './actionButton.scss';
+import { useParams } from 'react-router-dom';
 
 interface ActionButtonProps {
   patientUuid: string;
@@ -12,73 +13,18 @@ interface ActionButtonProps {
 
 const ActionButton: React.FC<ActionButtonProps> = ({ patientUuid }) => {
   const { t } = useTranslation();
-  const { admissionLocation, isLoading, error } = useAdmissionLocation();
-
-  const isPatientInAdmissionLocation = admissionLocation?.bedLayouts?.some((bed) =>
-    bed.patients.some((patient) => patient.uuid === patientUuid),
-  );
-
-  const bedId = admissionLocation?.bedLayouts?.find((bed) =>
-    bed.patients.some((patient) => patient.uuid === patientUuid),
-  )?.bedId;
-
-  const personUuid = admissionLocation?.bedLayouts
-    ?.find((bed) => bed.patients.some((patient) => patient.uuid === patientUuid))
-    ?.patients.find((patient) => patient.uuid === patientUuid)?.person?.uuid;
-
-  const handleNavigateToAllocationPage = () =>
+  const handleNavigateToHomePage = () =>
     navigate({
-      to: window.getOpenmrsSpaBase() + `home/morgue/allocation`,
+      to: window.getOpenmrsSpaBase() + `home/morgue`,
     });
 
-  const handleDischargeForm = (uuid: string, bedId: number) => {
-    launchWorkspace('discharge-body-form', {
-      workspaceTitle: t('dischargeForm', 'Discharge form'),
-      patientUuid: uuid,
-      bedId,
-      personUuid,
-    });
-  };
-
-  const handleSwapForm = (uuid: string, bedId: number) => {
-    launchWorkspace('swap-unit-form', {
-      workspaceTitle: t('swapCompartment', 'Swap compartment'),
-      patientUuid: uuid,
-      bedId,
-    });
-  };
-
   return (
     <div className={styles.actionButton}>
       <UserHasAccess privilege="o3 : View Mortuary Dashboard">
-        <Button kind="primary" size="sm" renderIcon={Return} onClick={handleNavigateToAllocationPage}>
+        <Button kind="primary" size="sm" renderIcon={Return} onClick={handleNavigateToHomePage}>
           {t('allocation', 'Allocation View')}
         </Button>
       </UserHasAccess>
-
-      {isPatientInAdmissionLocation && (
-        <>
-          <UserHasAccess privilege="o3: Swap Mortuary Compartments">
-            <Button
-              kind="secondary"
-              size="sm"
-              renderIcon={ShareKnowledge}
-              onClick={() => handleSwapForm(patientUuid, bedId)}>
-              {t('swapCompartment', 'Swap compartment')}
-            </Button>
-          </UserHasAccess>
-
-          <UserHasAccess privilege="o3: Discharge Body from Mortuary">
-            <Button
-              kind="danger"
-              size="sm"
-              renderIcon={Movement}
-              onClick={() => handleDischargeForm(patientUuid, bedId)}>
-              {t('discharge', 'Discharge body')}
-            </Button>
-          </UserHasAccess>
-        </>
-      )}
     </div>
   );
 };

package/src/extension/deceasedInfoBanner.component.tsx

@@ -3,28 +3,24 @@ import { useTranslation } from 'react-i18next';
 import { launchWorkspace, navigate, usePatient, useVisit } from '@openmrs/esm-framework';
 import { Movement, Return, ShareKnowledge } from '@carbon/react/icons';
 import React from 'react';
-import { useAdmissionLocation } from '../hook/useMortuaryAdmissionLocation';
 import styles from './actionButton.scss';
 import { convertDateToDays, formatDateTime } from '../utils/utils';
 import { Console } from '@carbon/pictograms-react';
+import { type Visit } from '../types';
 
 interface BannerInfoProps {
   patientUuid: string;
+  visit: Visit;
+  bedNumber?: string;
 }
 
-const BannerInfo: React.FC<BannerInfoProps> = ({ patientUuid }) => {
+const BannerInfo: React.FC<BannerInfoProps> = ({ patientUuid, visit, bedNumber }) => {
   const { t } = useTranslation();
-  const { admissionLocation, isLoading, error } = useAdmissionLocation();
   const { patient } = usePatient(patientUuid);
-  const { currentVisit } = useVisit(patientUuid);
-
-  const bedNumber =
-    admissionLocation?.bedLayouts?.find((bed) => bed.patients.some((patient) => patient.uuid === patientUuid))
-      ?.bedNumber || t('discharged', 'Discharged');
 
   const timeAndDateOfDeath = patient?.deceasedDateTime;
 
-  const startDate = currentVisit?.startDatetime;
+  const startDate = visit?.startDatetime;
 
   const lengthOfStay = `${convertDateToDays(startDate)} ${
     convertDateToDays(startDate) === 1 ? t('day', 'Day') : t('days', 'Days')