@bathiran212/esm-patient-chart-app 7.0.0

package/src/clinical-views/types.ts

@@ -0,0 +1,305 @@
+import { type ReactElement } from 'react';
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+
+export type TableHeaderType = {
+  key: string;
+  header: string;
+};
+
+export interface Encounter extends OpenmrsResource {
+  encounterDatetime: string;
+  encounterType: { uuid: string; name: string };
+  patient: {
+    uuid: string;
+    display: string;
+    age: number;
+    birthDate: string;
+  };
+  location: {
+    uuid: string;
+    display: string;
+    name: string;
+  };
+  encounterProviders?: Array<{ encounterRole: string; provider: { uuid: string; name: string } }>;
+  obs: Array<Observation>;
+  form?: {
+    uuid: string;
+  };
+  visit?: {
+    uuid: string;
+    startDatetime: string;
+    stopDatetime?: string;
+    visitType?: {
+      uuid: string;
+      display: string;
+    };
+  };
+}
+
+export interface Observation {
+  uuid: string;
+  concept: { uuid: string; name: string; units?: string };
+  value:
+    | {
+        uuid: string;
+        name: {
+          name: string;
+          display?: string;
+        };
+        names?: Array<{ uuid: string; name: string; conceptNameType: string }>;
+      }
+    | string;
+  groupMembers?: Array<Observation>;
+  obsDatetime: string;
+}
+
+export interface ListResponse<T> {
+  results: Array<T>;
+}
+
+export interface Privilege {
+  uuid: string;
+  name: string;
+  display?: string;
+  description?: string;
+}
+
+export interface EncounterType {
+  uuid: string;
+  name: string;
+  viewPrivilege: Privilege | null;
+  editPrivilege: Privilege | null;
+}
+
+export interface Form {
+  uuid: string;
+  encounterType?: EncounterType;
+  name: string;
+  display?: string;
+  version: string;
+  published: boolean;
+  retired: boolean;
+  resources: Array<FormEncounterResource>;
+  formCategory?: string;
+}
+
+export interface FormEncounterResource {
+  uuid: string;
+  name: string;
+  dataType: string;
+  valueReference: string;
+}
+
+export interface EncounterWithFormRef {
+  uuid: string;
+  encounterType?: EncounterType;
+  encounterDatetime: string;
+  form?: Form;
+}
+
+export interface CompletedFormInfo {
+  form: Form;
+  associatedEncounters: Array<EncounterWithFormRef>;
+  lastCompleted?: Date;
+}
+
+export interface HtmlFormEntryForm {
+  formUuid: string;
+  formName: string;
+  formUiResource: string;
+  formUiPage: 'enterHtmlFormWithSimpleUi' | 'enterHtmlFormWithStandardUi';
+  formEditUiPage: 'editHtmlFormWithSimpleUi' | 'editHtmlFormWithStandardUi';
+}
+
+export interface FormsSection {
+  name: string;
+  forms: Array<string>;
+}
+
+export interface ConfigObject {
+  htmlFormEntryForms: Array<HtmlFormEntryForm>;
+  formSections: Array<FormsSection>;
+  customFormsUrl: string;
+  orderBy: 'name' | 'most-recent';
+  showHtmlFormEntryForms: boolean;
+}
+
+// encounter list types
+
+export interface ActionProps {
+  mode: string;
+  label: string;
+  formName: string;
+  intent?: string;
+}
+
+export interface ConditionalActionProps {
+  mode: string;
+  label: string;
+  formName: string;
+  dependsOn?: string;
+  dependantConcept?: string;
+  dependantEncounter?: string;
+  intent?: string;
+}
+
+export interface ColumnDefinition {
+  id: string;
+  title: string;
+  isComplex?: boolean;
+  concept?: string;
+  secondaryConcept?: string;
+  multipleConcepts?: Array<string>;
+  fallbackConcepts?: Array<string>;
+  actionOptions?: Array<ActionProps>;
+  conditionalActionOptions?: Array<ConditionalActionProps>;
+  isDate?: boolean;
+  isTrueFalseConcept?: boolean;
+  type?: EncounterPropertyType;
+  isLink?: boolean;
+  useMultipleObs?: boolean;
+  valueMappings?: Record<string, string>;
+  conceptMappings?: Array<string>;
+  statusColorMappings?: Record<string, string>;
+  isConditionalConcept?: boolean;
+  conditionalConceptMappings?: Record<string, string>;
+  conditionalEncounterMappings?: Record<string, ConditionalEncounterMapping>;
+  encounterType: string;
+  hasSummary?: boolean;
+  summaryConcept?: SummaryConcept;
+}
+
+export interface ConditionalEncounterMapping {
+  concept: string;
+  isDate?: boolean;
+}
+
+interface LaunchOptions {
+  displayText: string;
+  hideFormLauncher?: boolean;
+}
+export interface TabSchema {
+  tabName: string;
+  hasFilter?: boolean;
+  headerTitle: string;
+  displayText: string;
+  encounterType: string;
+  columns: Array<ColumnDefinition>;
+  formList: Array<{ name: string; uuid: string; fixedIntent?: string; excludedIntents?: Array<string> }>;
+  launchOptions: LaunchOptions;
+}
+
+export type Mode = 'edit' | 'view' | 'delete';
+
+export interface Action {
+  label: string;
+  mode: Mode;
+  form?: { name: string };
+  intent?: string;
+}
+
+export interface TableRow {
+  id: string;
+  actions?: ReactElement;
+}
+
+export interface FormColumn {
+  form: { name: string };
+  encounterUuid: string;
+  intent: string;
+  label: string;
+  mode: string;
+}
+
+export type NamedColumn =
+  | string
+  | {
+      uuid: string;
+      name: { name: string };
+      names?: { uuid: string; name: string; conceptNameType: string }[];
+    };
+
+export type ColumnValue = string | number | JSX.Element | NamedColumn | Array<NamedColumn> | Array<FormColumn> | null;
+
+export interface ConfigConcepts {
+  trueConceptUuid: string;
+  falseConceptUuid: string;
+  otherConceptUuid: string;
+}
+
+export interface FormattedColumn {
+  key: string;
+  header: string;
+  getValue: (encounter: Encounter) => ColumnValue;
+  link?: { getUrl: (encounter: Encounter) => string; handleNavigate?: (encounter: Encounter) => void };
+  concept?: string;
+}
+
+export interface EncounterTileColumn {
+  key: string;
+  header: string;
+  encounterTypeUuid: string;
+  concept: string;
+  title?: string;
+  getObsValue: (encounter: Encounter) => string;
+  getSummaryObsValue?: (encounter: Encounter) => string;
+  encounter?: Encounter;
+  hasSummary?: boolean;
+  summaryConcept?: SummaryConcept;
+}
+export interface EncounterTileProps {
+  patientUuid: string;
+  columns: Array<EncounterTileColumn>;
+  headerTitle: string;
+}
+
+export interface MenuCardProps {
+  tileHeader: string;
+  columns: Array<ColumnDefinition>;
+}
+
+interface SummaryConcept {
+  primaryConcept: string;
+  secondaryConcept?: string;
+  isDate?: boolean;
+  hasCalculatedDate?: boolean;
+  type?: EncounterPropertyType;
+}
+
+export interface FormattedCardColumn {
+  key: string;
+  header: string;
+  concept: string;
+  encounterUuid: string;
+  title?: string;
+  getObsValue: (encounter: Encounter) => string;
+  getSummaryObsValue?: (encounter: Encounter) => string;
+  hasSummary: boolean;
+}
+
+export interface ConfigConcepts {
+  trueConceptUuid: string;
+  falseConceptUuid: string;
+  otherConceptUuid: string;
+}
+
+export enum EncounterPropertyType {
+  location = 'location',
+  provider = 'provider',
+  encounterType = 'encounterType',
+  visitType = 'visitType',
+  ageAtEncounter = 'ageAtEncounter',
+  visitDate = 'visitDate',
+  encounterDatetime = 'encounterDatetime',
+}
+
+export interface GetObsFromEncounterParams {
+  encounter: Encounter;
+  obsConcept: string;
+  isDate?: boolean;
+  isTrueFalseConcept?: boolean;
+  type?: EncounterPropertyType;
+  fallbackConcepts?: Array<string>;
+  secondaryConcept?: string;
+  config?: ConfigConcepts;
+}

package/src/clinical-views/utils/concept-utils.ts

@@ -0,0 +1,24 @@
+import type { Encounter } from '../types';
+
+/**
+ * Helper function to extract units from an encounter for a specific concept
+ * @param encounter The encounter containing observations
+ * @param conceptUuid The concept UUID to find
+ * @returns The units string if found
+ */
+export function getConceptUnitsFromEncounter(encounter: Encounter | null, conceptUuid: string): string {
+  if (!encounter || !encounter.obs || !conceptUuid) {
+    return '';
+  }
+
+  // Find the observation for this concept
+  const obs = encounter.obs.find((o) => o.concept?.uuid === conceptUuid);
+
+  // Return the units if found
+  return obs?.concept?.units || '';
+}
+
+export const withUnit = (value: string | number, unit: string | null | undefined) => {
+  if (!value || value === '--') return value;
+  return unit ? `${value} ${unit}` : value;
+};

package/src/clinical-views/utils/encounter-list-config-builder.ts

@@ -0,0 +1,160 @@
+import {
+  getObsFromEncounter,
+  getMultipleObsFromEncounter,
+  resolveValueUsingMappings,
+  getConceptFromMappings,
+  getConditionalConceptValue,
+} from './helpers';
+import {
+  type Encounter,
+  type ColumnDefinition,
+  type TabSchema,
+  type ActionProps,
+  type ConditionalActionProps,
+  type ColumnValue,
+  type NamedColumn,
+  type ConfigConcepts,
+} from '../types';
+import { renderTag } from '../encounter-list/tag.component';
+import type { TFunction } from 'i18next';
+
+export interface FormattedColumn {
+  key: string;
+  header: string;
+  getValue: (encounter: Encounter) => ColumnValue;
+  link?: { getUrl: (encounter: Encounter) => string; handleNavigate?: (encounter: Encounter) => void };
+  concept?: string;
+}
+
+const getColumnValue = (
+  encounter: Encounter,
+  column: ColumnDefinition,
+  config: ConfigConcepts,
+  t: TFunction,
+): ColumnValue => {
+  if (column.id === 'actions') {
+    return getActions(encounter, column, config);
+  }
+  if (column.statusColorMappings) {
+    return renderTag(encounter, column.concept, column.statusColorMappings, config);
+  }
+
+  if (column.isConditionalConcept) {
+    return getConditionalConceptValue(encounter, column.conditionalConceptMappings, column.isDate, config);
+  }
+
+  if (column.useMultipleObs) {
+    return getMultipleObsFromEncounter(encounter, column.multipleConcepts, config);
+  }
+
+  if (column.valueMappings) {
+    const resolvedValue = resolveValueUsingMappings(encounter, column.concept, column.valueMappings, t);
+    if (resolvedValue !== null && resolvedValue !== undefined) {
+      return resolvedValue;
+    }
+  }
+
+  if (column.conceptMappings) {
+    return getMappedConceptValue(encounter, column, config);
+  }
+
+  return getObsFromEncounter({
+    encounter: encounter,
+    obsConcept: column.concept,
+    isDate: column.isDate,
+    isTrueFalseConcept: column.isTrueFalseConcept,
+    type: column.type,
+    fallbackConcepts: column.fallbackConcepts,
+    secondaryConcept: column.secondaryConcept,
+    config: config,
+  });
+};
+
+const createActionObject = (encounter: Encounter, action: ActionProps | ConditionalActionProps) => ({
+  form: { name: action.formName },
+  encounterUuid: encounter.uuid,
+  intent: action.intent || '*',
+  label: action.label,
+  mode: action.mode,
+});
+
+const getActions = (encounter: Encounter, column: ColumnDefinition, config: ConfigConcepts) => {
+  const baseActions = column.actionOptions?.map((action: ActionProps) => createActionObject(encounter, action)) || [];
+
+  const conditionalActions =
+    column.conditionalActionOptions
+      ?.map((action) => createConditionalAction(encounter, action, config))
+      .filter(Boolean) || [];
+
+  return [...baseActions, ...conditionalActions];
+};
+
+const createConditionalAction = (encounter: Encounter, action: ConditionalActionProps, config: ConfigConcepts) => {
+  const dependantObsValue = getObsFromEncounter({
+    encounter: encounter,
+    obsConcept: action.dependantConcept,
+    config: config,
+  });
+  if (dependantObsValue === action.dependsOn) {
+    return createActionObject(encounter, action);
+  }
+
+  const dependantEncounterValue = encounter.encounterType?.uuid;
+  if (dependantEncounterValue === action.dependantEncounter) {
+    return createActionObject(encounter, action);
+  }
+
+  return null;
+};
+
+const getMappedConceptValue = (encounter: Encounter, column: ColumnDefinition, config: ConfigConcepts): NamedColumn => {
+  const concept = getConceptFromMappings(encounter, column.conceptMappings);
+  return getObsFromEncounter({
+    encounter: encounter,
+    obsConcept: concept,
+    isDate: column.isDate,
+    isTrueFalseConcept: column.isTrueFalseConcept,
+    type: column.type,
+    fallbackConcepts: column.fallbackConcepts,
+    secondaryConcept: column.secondaryConcept,
+    config: config,
+  });
+};
+
+export const getTabColumns = (columnsDefinition: Array<ColumnDefinition>, config: ConfigConcepts, t: TFunction) => {
+  const columns: Array<FormattedColumn> = columnsDefinition.map((column: ColumnDefinition) => ({
+    key: column.id,
+    header: column.title,
+    concept: column.concept,
+    getValue: (encounter) => getColumnValue(encounter, column, config, t),
+    link: column.isLink
+      ? {
+          getUrl: (encounter) => encounter.url,
+          handleNavigate: (encounter) => encounter.launchFormActions?.viewEncounter(),
+        }
+      : null,
+  }));
+
+  return columns;
+};
+
+export const getMenuItemTabsConfiguration = (
+  tabDefinitions: Array<TabSchema>,
+  config: ConfigConcepts,
+  t: TFunction,
+) => {
+  const tabs = tabDefinitions.map((tab) => {
+    return {
+      name: tab.tabName,
+      hasFilter: tab.hasFilter || false,
+      encounterType: tab.encounterType,
+      headerTitle: tab.headerTitle,
+      description: tab.displayText,
+      formList: tab.formList,
+      columns: getTabColumns(tab.columns, config, t),
+      launchOptions: tab.launchOptions,
+    };
+  });
+
+  return tabs;
+};

package/src/clinical-views/utils/encounter-list.resource.ts

@@ -0,0 +1,26 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+
+export function fetchOpenMRSForms(formUuid: string) {
+  return openmrsFetch(`${restBaseUrl}/form/${formUuid}`).then(({ data }) => {
+    if (data.results.length) {
+      return data.results;
+    }
+    return null;
+  });
+}
+
+export function fetchPatientRelationships(patientUuid: string) {
+  return openmrsFetch(`${restBaseUrl}relationship?person=${patientUuid}&v=full`).then(({ data }) => {
+    if (data.results.length) {
+      return data.results;
+    }
+    return null;
+  });
+}
+
+export function deleteEncounter(encounterUuid: string, abortController: AbortController) {
+  return openmrsFetch(`${restBaseUrl}/encounter/${encounterUuid}`, {
+    method: 'DELETE',
+    signal: abortController.signal,
+  });
+}