@olaboot/esm-patient-registration-app 9.2.0

package/src/patient-registration/patient-registration-utils.ts

@@ -0,0 +1,214 @@
+import * as Yup from 'yup';
+import camelCase from 'lodash-es/camelCase';
+import { parseDate } from '@openmrs/esm-framework';
+import {
+  type AddressValidationSchemaType,
+  type Encounter,
+  type FormValues,
+  type PatientIdentifier,
+  type PatientIdentifierValue,
+  type PatientUuidMapType,
+} from './patient-registration.types';
+
+export function parseAddressTemplateXml(addressTemplate: string) {
+  const templateXmlDoc = new DOMParser().parseFromString(addressTemplate, 'text/xml');
+  const nameMappings = templateXmlDoc.querySelector('nameMappings');
+  const properties = nameMappings.getElementsByTagName('entry');
+  const validationSchemaObjs = Array.prototype.map.call(properties, (property: Element) => {
+    const name = property.getElementsByTagName('string')[0].innerHTML;
+    const label = property.getElementsByTagName('string')[1].innerHTML;
+    const regex = findElementValueInXmlDoc(name, 'elementRegex', templateXmlDoc) || '.*';
+    const regexFormat = findElementValueInXmlDoc(name, 'elementRegexFormats', templateXmlDoc) || '';
+
+    return {
+      name,
+      label,
+      regex,
+      regexFormat,
+    };
+  });
+
+  const addressValidationSchema = Yup.object(
+    validationSchemaObjs.reduce((final, current) => {
+      final[current.name] = Yup.string().matches(current.regex, current.regexFormat);
+      return final;
+    }, {}),
+  );
+
+  const addressFieldValues = Array.prototype.map.call(properties, (property: Element) => {
+    const name = property.getElementsByTagName('string')[0].innerHTML;
+    return {
+      name,
+      defaultValue: '',
+    };
+  });
+  return {
+    addressFieldValues,
+    addressValidationSchema,
+  };
+}
+
+export function parseAddressTemplateXmlOld(addressTemplate: string) {
+  const templateXmlDoc = new DOMParser().parseFromString(addressTemplate, 'text/xml');
+  const nameMappings = templateXmlDoc.querySelector('nameMappings').querySelectorAll('property');
+  const validationSchemaObjs: AddressValidationSchemaType[] = Array.prototype.map.call(
+    nameMappings,
+    (nameMapping: Element) => {
+      const name = nameMapping.getAttribute('name');
+      const label = nameMapping.getAttribute('value');
+      const regex = findElementValueInXmlDoc(name, 'elementRegex', templateXmlDoc) || '.*';
+      const regexFormat = findElementValueInXmlDoc(name, 'elementRegexFormats', templateXmlDoc) || '';
+
+      return {
+        name,
+        label,
+        regex,
+        regexFormat,
+      };
+    },
+  );
+
+  const addressValidationSchema = Yup.object(
+    validationSchemaObjs.reduce((final, current) => {
+      final[current.name] = Yup.string().matches(current.regex, current.regexFormat);
+      return final;
+    }, {}),
+  );
+
+  const addressFieldValues: Array<{ name: string; defaultValue: string }> = Array.prototype.map.call(
+    nameMappings,
+    (nameMapping: Element) => {
+      const name = nameMapping.getAttribute('name');
+      const defaultValue = findElementValueInXmlDoc(name, 'elementDefaults', templateXmlDoc) ?? '';
+      return { name, defaultValue };
+    },
+  );
+
+  return {
+    addressFieldValues,
+    addressValidationSchema,
+  };
+}
+
+function findElementValueInXmlDoc(fieldName: string, elementSelector: string, doc: XMLDocument) {
+  return doc.querySelector(elementSelector)?.querySelector(`[name=${fieldName}]`)?.getAttribute('value') ?? null;
+}
+
+export function scrollIntoView(viewId: string) {
+  document.getElementById(viewId).scrollIntoView({
+    behavior: 'smooth',
+    block: 'center',
+    inline: 'center',
+  });
+}
+
+export function cancelRegistration() {
+  window.history.back();
+}
+
+export function getFormValuesFromFhirPatient(patient: fhir.Patient) {
+  const result = {} as FormValues;
+  const patientName = patient.name[0];
+  const additionalPatientName = patient.name[1];
+
+  result.patientUuid = patient.id;
+  result.givenName = patientName?.given[0];
+  result.middleName = patientName?.given[1];
+  result.familyName = patientName?.family;
+  result.addNameInLocalLanguage = !!additionalPatientName ? true : undefined;
+  result.additionalGivenName = additionalPatientName?.given[0];
+  result.additionalMiddleName = additionalPatientName?.given[1];
+  result.additionalFamilyName = additionalPatientName?.family;
+
+  result.gender = patient.gender;
+  result.birthdate = patient.birthDate ? parseDate(patient.birthDate) : undefined;
+  result.telephoneNumber = patient.telecom ? patient.telecom[0].value : '';
+
+  return {
+    ...result,
+    ...patient.identifier.map((identifier) => {
+      const key = camelCase(identifier.system || identifier.type.text);
+      return { [key]: identifier.value };
+    }),
+  };
+}
+
+export function getAddressFieldValuesFromFhirPatient(patient: fhir.Patient) {
+  const result = {};
+  const address = patient.address?.[0];
+
+  if (address) {
+    for (const key of Object.keys(address)) {
+      switch (key) {
+        case 'city':
+          result['cityVillage'] = address[key];
+          break;
+        case 'state':
+          result['stateProvince'] = address[key];
+          break;
+        case 'district':
+          result['countyDistrict'] = address[key];
+          break;
+        case 'extension':
+          address[key].forEach((ext) => {
+            ext.extension.forEach((extension) => {
+              result[extension.url.split('#')[1]] = extension.valueString;
+            });
+          });
+          break;
+        default:
+          if (key === 'country' || key === 'postalCode') {
+            result[key] = address[key];
+          }
+      }
+    }
+  }
+
+  return result;
+}
+
+export function getPatientUuidMapFromFhirPatient(patient: fhir.Patient): PatientUuidMapType {
+  const patientName = patient.name[0];
+  const additionalPatientName = patient.name[1];
+  const address = patient.address?.[0];
+
+  return {
+    preferredNameUuid: patientName?.id,
+    additionalNameUuid: additionalPatientName?.id,
+    preferredAddressUuid: address?.id,
+    ...patient.identifier.map((identifier) => {
+      const key = camelCase(identifier.system || identifier.type.text);
+      return { [key]: { uuid: identifier.id, value: identifier.value } };
+    }),
+  };
+}
+
+export function getPatientIdentifiersFromFhirPatient(patient: fhir.Patient): Array<PatientIdentifier> {
+  return patient.identifier.map((identifier) => {
+    return {
+      uuid: identifier.id,
+      identifier: identifier.value,
+    };
+  });
+}
+
+export function getPhonePersonAttributeValueFromFhirPatient(patient: fhir.Patient) {
+  const result = {};
+  if (patient.telecom) {
+    result['phone'] = patient.telecom[0].value;
+  }
+  return result;
+}
+
+type IdentifierMap = { [identifierFieldName: string]: PatientIdentifierValue };
+export const filterOutUndefinedPatientIdentifiers = (patientIdentifiers: IdentifierMap): IdentifierMap =>
+  Object.fromEntries(
+    Object.entries(patientIdentifiers).filter(
+      ([key, value]) =>
+        (value.autoGeneration && value.selectedSource.autoGenerationOption.manualEntryEnabled) ||
+        value.identifierValue !== undefined,
+    ),
+  );
+
+export const latestFirstEncounter = (a: Encounter, b: Encounter) =>
+  new Date(b.encounterDatetime).getTime() - new Date(a.encounterDatetime).getTime();

package/src/patient-registration/patient-registration.component.tsx

@@ -0,0 +1,266 @@
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import classNames from 'classnames';
+import { Button, InlineLoading, Link } from '@carbon/react';
+import { XAxis } from '@carbon/react/icons';
+import { useLocation, useParams } from 'react-router-dom';
+import { useTranslation } from 'react-i18next';
+import { Form, Formik, type FormikHelpers } from 'formik';
+import {
+  createErrorHandler,
+  interpolateUrl,
+  showSnackbar,
+  useConfig,
+  usePatient,
+  usePatientPhoto,
+} from '@openmrs/esm-framework';
+import { builtInSections, type RegistrationConfig, type SectionDefinition } from '../config-schema';
+import { cancelRegistration, filterOutUndefinedPatientIdentifiers, scrollIntoView } from './patient-registration-utils';
+import { getValidationSchema } from './validation/patient-registration-validation';
+import { DummyDataInput } from './input/dummy-data/dummy-data-input.component';
+import { PatientRegistrationContextProvider } from './patient-registration-context';
+import { useResourcesContext } from '../resources-context';
+import { SectionWrapper } from './section/section-wrapper.component';
+import { type CapturePhotoProps, type FormValues } from './patient-registration.types';
+import { type SavePatientForm, SavePatientTransactionManager } from './form-manager';
+import { useInitialAddressFieldValues, useInitialFormValues, usePatientUuidMap } from './patient-registration-hooks';
+import BeforeSavePrompt from './before-save-prompt.component';
+import styles from './patient-registration.scss';
+
+let exportedInitialFormValuesForTesting = {} as FormValues;
+
+export interface PatientRegistrationProps {
+  savePatientForm: SavePatientForm;
+  isOffline: boolean;
+}
+
+export const PatientRegistration: React.FC<PatientRegistrationProps> = ({ savePatientForm, isOffline }) => {
+  const { t } = useTranslation();
+  const { currentSession, identifierTypes } = useResourcesContext();
+  const { patientUuid: uuidOfPatientToEdit } = useParams();
+  const { search } = useLocation();
+  const { isLoading: isLoadingPatientToEdit, patient: patientToEdit } = usePatient(uuidOfPatientToEdit);
+  const config = useConfig<RegistrationConfig>();
+
+  const [initialFormValues, setInitialFormValues] = useInitialFormValues(
+    isLoadingPatientToEdit,
+    patientToEdit,
+    uuidOfPatientToEdit,
+  );
+  const [initialAddressFieldValues] = useInitialAddressFieldValues(
+    {},
+    isLoadingPatientToEdit,
+    patientToEdit,
+    uuidOfPatientToEdit,
+  );
+
+  const [patientUuidMap] = usePatientUuidMap({}, isLoadingPatientToEdit, patientToEdit, uuidOfPatientToEdit);
+
+  const [target, setTarget] = useState<undefined | string>();
+  const [capturePhotoProps, setCapturePhotoProps] = useState<CapturePhotoProps | null>(null);
+
+  const location = currentSession?.sessionLocation?.uuid;
+  const inEditMode = isLoadingPatientToEdit ? undefined : !!(uuidOfPatientToEdit && patientToEdit);
+  const showDummyData = useMemo(() => localStorage.getItem('openmrs:devtools') === 'true' && !inEditMode, [inEditMode]);
+  const { data: photo } = usePatientPhoto(patientToEdit?.id);
+  const savePatientTransactionManager = useRef(new SavePatientTransactionManager());
+  const validationSchema = getValidationSchema(config, t);
+
+  useEffect(() => {
+    exportedInitialFormValuesForTesting = initialFormValues;
+  }, [initialFormValues]);
+
+  const sections: Array<SectionDefinition> = useMemo(() => {
+    return config.sections
+      .map(
+        (sectionName) =>
+          config.sectionDefinitions.filter((s) => s.id == sectionName)[0] ??
+          builtInSections.filter((s) => s.id == sectionName)[0],
+      )
+      .filter((s) => s);
+  }, [config.sections, config.sectionDefinitions]);
+
+  const onFormSubmit = async (values: FormValues, helpers: FormikHelpers<FormValues>) => {
+    const abortController = new AbortController();
+    helpers.setSubmitting(true);
+
+    const updatedFormValues = { ...values, identifiers: filterOutUndefinedPatientIdentifiers(values.identifiers) };
+    try {
+      await savePatientForm(
+        !inEditMode,
+        updatedFormValues,
+        patientUuidMap,
+        initialAddressFieldValues,
+        capturePhotoProps,
+        location,
+        initialFormValues['identifiers'],
+        currentSession,
+        config,
+        savePatientTransactionManager.current,
+        abortController,
+      );
+
+      showSnackbar({
+        subtitle: inEditMode
+          ? t('updatePatientSuccessSnackbarSubtitle', "The patient's information has been successfully updated")
+          : t(
+              'registerPatientSuccessSnackbarSubtitle',
+              'The patient can now be found by searching for them using their name or ID number',
+            ),
+        title: inEditMode
+          ? t('updatePatientSuccessSnackbarTitle', 'Patient Details Updated')
+          : t('registerPatientSuccessSnackbarTitle', 'New Patient Created'),
+        kind: 'success',
+        isLowContrast: true,
+      });
+
+      const afterUrl = new URLSearchParams(search).get('afterUrl');
+      const redirectUrl = interpolateUrl(afterUrl || config.links.submitButton, { patientUuid: values.patientUuid });
+
+      setTarget(redirectUrl);
+    } catch (error) {
+      if (error.responseBody?.error?.globalErrors) {
+        error.responseBody.error.globalErrors.forEach((error) => {
+          showSnackbar({
+            title: inEditMode
+              ? t('updatePatientErrorSnackbarTitle', 'Patient Details Update Failed')
+              : t('registrationErrorSnackbarTitle', 'Patient Registration Failed'),
+            subtitle: error.message,
+            kind: 'error',
+          });
+        });
+      } else if (error.responseBody?.error?.message) {
+        showSnackbar({
+          title: inEditMode
+            ? t('updatePatientErrorSnackbarTitle', 'Patient Details Update Failed')
+            : t('registrationErrorSnackbarTitle', 'Patient Registration Failed'),
+          subtitle: error.responseBody.error.message,
+          kind: 'error',
+        });
+      } else {
+        createErrorHandler()(error);
+      }
+
+      helpers.setSubmitting(false);
+    }
+  };
+
+  const getDescription = (errors) => {
+    return (
+      <ul style={{ listStyle: 'inside' }}>
+        {Object.keys(errors).map((error, index) => {
+          return <li key={index}>{t(`${error}LabelText`, error)}</li>;
+        })}
+      </ul>
+    );
+  };
+
+  const displayErrors = (errors) => {
+    if (errors && typeof errors === 'object' && !!Object.keys(errors).length) {
+      showSnackbar({
+        isLowContrast: true,
+        kind: 'warning',
+        title: t('fieldsWithErrors', 'The following fields have errors:'),
+        subtitle: <>{getDescription(errors)}</>,
+      });
+    }
+  };
+
+  const createContextValue = useCallback(
+    (formikProps) => ({
+      identifierTypes,
+      validationSchema,
+      values: formikProps.values,
+      inEditMode,
+      setFieldValue: formikProps.setFieldValue,
+      setFieldTouched: formikProps.setFieldTouched,
+      setCapturePhotoProps,
+      currentPhoto: photo?.imageSrc,
+      isOffline,
+      initialFormValues: formikProps.initialValues,
+      setInitialFormValues,
+    }),
+    [
+      identifierTypes,
+      validationSchema,
+      inEditMode,
+      setCapturePhotoProps,
+      photo?.imageSrc,
+      isOffline,
+      setInitialFormValues,
+    ],
+  );
+
+  return (
+    <Formik
+      enableReinitialize
+      initialValues={initialFormValues}
+      onSubmit={onFormSubmit}
+      validationSchema={validationSchema}>
+      {(props) => (
+        <Form className={styles.form}>
+          <BeforeSavePrompt when={Object.keys(props.touched).length > 0} redirect={target} />
+          <div className={styles.formContainer}>
+            <div>
+              <div className={styles.stickyColumn}>
+                <h4>
+                  {inEditMode
+                    ? t('editPatientDetails', 'Edit patient details')
+                    : t('createNewPatient', 'Create new patient')}
+                </h4>
+                {showDummyData && <DummyDataInput setValues={props.setValues} />}
+                <p className={styles.label01}>{t('jumpTo', 'Jump to')}</p>
+                {sections.map((section) => (
+                  <div className={classNames(styles.space05, styles.touchTarget)} key={section.name}>
+                    <Link className={styles.linkName} onClick={() => scrollIntoView(section.id)}>
+                      <XAxis size={16} /> {t(`${section.id}Section`, section.name)}
+                    </Link>
+                  </div>
+                ))}
+                <Button
+                  className={styles.submitButton}
+                  type="submit"
+                  onClick={() => props.validateForm().then((errors) => displayErrors(errors))}
+                  // Current session and identifiers are required for patient registration.
+                  // If currentSession or identifierTypes are not available, then the
+                  // user should be blocked to register the patient.
+                  disabled={!currentSession || !identifierTypes || props.isSubmitting}>
+                  {props.isSubmitting ? (
+                    <InlineLoading
+                      className={styles.spinner}
+                      description={`${t('submitting', 'Submitting')} ...`}
+                      iconDescription="submitting"
+                    />
+                  ) : inEditMode ? (
+                    t('updatePatient', 'Update patient')
+                  ) : (
+                    t('registerPatient', 'Register patient')
+                  )}
+                </Button>
+                <Button className={styles.cancelButton} kind="secondary" onClick={cancelRegistration}>
+                  {t('cancel', 'Cancel')}
+                </Button>
+              </div>
+            </div>
+            <div className={styles.infoGrid}>
+              <PatientRegistrationContextProvider value={createContextValue(props)}>
+                {sections.map((section, index) => (
+                  <SectionWrapper
+                    key={`registration-section-${section.id}`}
+                    sectionDefinition={section}
+                    index={index}
+                  />
+                ))}
+              </PatientRegistrationContextProvider>
+            </div>
+          </div>
+        </Form>
+      )}
+    </Formik>
+  );
+};
+
+/**
+ * @internal
+ * Just exported for testing
+ */
+export { exportedInitialFormValuesForTesting as initialFormValues };

package/src/patient-registration/patient-registration.resource.test.tsx

@@ -0,0 +1,22 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { savePatient } from './patient-registration.resource';
+
+const mockOpenmrsFetch = openmrsFetch as jest.Mock;
+
+jest.mock('@openmrs/esm-framework', () => ({
+  openmrsFetch: jest.fn(),
+}));
+
+describe('savePatient', () => {
+  it('appends patient uuid in url if provided', () => {
+    mockOpenmrsFetch.mockImplementationOnce((url) => url);
+    savePatient(null, '1234');
+    expect(mockOpenmrsFetch.mock.calls[0][0]).toEqual(`${restBaseUrl}/patient/1234`);
+  });
+
+  it('does not append patient uuid in url', () => {
+    mockOpenmrsFetch.mockImplementationOnce(() => {});
+    savePatient(null);
+    expect(mockOpenmrsFetch.mock.calls[0][0]).toEqual(`${restBaseUrl}/patient/`);
+  });
+});

package/src/patient-registration/patient-registration.resource.ts

@@ -0,0 +1,198 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { type Patient, type Relationship, type PatientIdentifier, type Encounter } from './patient-registration.types';
+import dayjs from 'dayjs';
+
+export const uuidIdentifier = '05a29f94-c0ed-11e2-94be-8c13b969e334';
+export const uuidTelephoneNumber = '14d4f066-15f5-102d-96e4-000c29c2a5d7';
+
+function dataURItoFile(dataURI: string) {
+  const byteString = window.atob(dataURI.split(',')[1]);
+  const mimeString = dataURI.split(',')[0].split(':')[1].split(';')[0];
+  // write the bytes of the string to a typed array
+  const buffer = new Uint8Array(byteString.length);
+
+  for (let i = 0; i < byteString.length; i++) {
+    buffer[i] = byteString.charCodeAt(i);
+  }
+
+  const blob = new Blob([buffer], { type: mimeString });
+  return new File([blob], 'patient-photo.png');
+}
+
+export function savePatient(patient: Patient | null, updatePatientUuid?: string) {
+  const abortController = new AbortController();
+
+  return openmrsFetch(`${restBaseUrl}/patient/${updatePatientUuid || ''}`, {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    method: 'POST',
+    body: patient,
+    signal: abortController.signal,
+  });
+}
+
+export function saveEncounter(encounter: Encounter) {
+  const abortController = new AbortController();
+
+  return openmrsFetch(`${restBaseUrl}/encounter`, {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    method: 'POST',
+    body: encounter,
+    signal: abortController.signal,
+  });
+}
+
+export function generateIdentifier(source: string) {
+  const abortController = new AbortController();
+
+  return openmrsFetch(`${restBaseUrl}/idgen/identifiersource/${source}/identifier`, {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    method: 'POST',
+    body: {},
+    signal: abortController.signal,
+  });
+}
+
+export function deletePersonName(nameUuid: string, personUuid: string) {
+  const abortController = new AbortController();
+
+  return openmrsFetch(`${restBaseUrl}/person/${personUuid}/name/${nameUuid}`, {
+    method: 'DELETE',
+    signal: abortController.signal,
+  });
+}
+
+export function saveRelationship(relationship: Relationship) {
+  const abortController = new AbortController();
+
+  return openmrsFetch(`${restBaseUrl}/relationship`, {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    method: 'POST',
+    body: relationship,
+    signal: abortController.signal,
+  });
+}
+
+export function updateRelationship(relationshipUuid, relationship: { relationshipType: string }) {
+  const abortController = new AbortController();
+
+  return openmrsFetch(`${restBaseUrl}/relationship/${relationshipUuid}`, {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    method: 'POST',
+    body: { relationshipType: relationship.relationshipType },
+    signal: abortController.signal,
+  });
+}
+
+export function deleteRelationship(relationshipUuid) {
+  const abortController = new AbortController();
+
+  return openmrsFetch(`${restBaseUrl}/relationship/${relationshipUuid}`, {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    method: 'DELETE',
+    signal: abortController.signal,
+  });
+}
+
+export async function savePatientPhoto(
+  patientUuid: string,
+  content: string,
+  url: string,
+  date: string,
+  conceptUuid: string,
+) {
+  const abortController = new AbortController();
+
+  const formData = new FormData();
+  formData.append('patient', patientUuid);
+  formData.append('file', dataURItoFile(content));
+  formData.append(
+    'json',
+    JSON.stringify({
+      person: patientUuid,
+      concept: conceptUuid,
+      groupMembers: [],
+      obsDatetime: date,
+    }),
+  );
+
+  return openmrsFetch(url, {
+    method: 'POST',
+    signal: abortController.signal,
+    body: formData,
+  });
+}
+
+export async function fetchPerson(query: string, abortController: AbortController) {
+  const [patientsRes, personsRes] = await Promise.all([
+    openmrsFetch(`${restBaseUrl}/patient?q=${query}`, {
+      signal: abortController.signal,
+    }),
+    openmrsFetch(`${restBaseUrl}/person?q=${query}`, {
+      signal: abortController.signal,
+    }),
+  ]);
+
+  const results = [...patientsRes.data.results];
+
+  personsRes.data.results.forEach((person) => {
+    if (!results.some((patient) => patient.uuid === person.uuid)) {
+      results.push(person);
+    }
+  });
+
+  return results;
+}
+
+export async function addPatientIdentifier(patientUuid: string, patientIdentifier: PatientIdentifier) {
+  const abortController = new AbortController();
+  return openmrsFetch(`${restBaseUrl}/patient/${patientUuid}/identifier/`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    signal: abortController.signal,
+    body: patientIdentifier,
+  });
+}
+
+export async function updatePatientIdentifier(patientUuid: string, identifierUuid: string, identifier: string) {
+  const abortController = new AbortController();
+  return openmrsFetch(`${restBaseUrl}/patient/${patientUuid}/identifier/${identifierUuid}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    signal: abortController.signal,
+    body: { identifier },
+  });
+}
+
+export async function deletePatientIdentifier(patientUuid: string, patientIdentifierUuid: string) {
+  const abortController = new AbortController();
+  return openmrsFetch(`${restBaseUrl}/patient/${patientUuid}/identifier/${patientIdentifierUuid}?purge`, {
+    method: 'DELETE',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    signal: abortController.signal,
+  });
+}
+
+export function getDatetime(date: Date | string, time: string, timeFormat: 'AM' | 'PM') {
+  const datetime = new Date(date);
+  const [hours, minutes] = time.split(':').map(Number);
+  const fullHours = timeFormat === 'PM' ? (hours % 12) + 12 : hours % 12;
+  return dayjs(datetime).hour(fullHours).minute(minutes).second(0).millisecond(0).toDate();
+}