@pih/esm-audit-app 2.1.0

package/src/audit/patient-search.component.tsx

@@ -0,0 +1,120 @@
+import React, { useEffect, useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import {
+  DataTableSkeleton,
+  Pagination,
+  Search,
+  Table,
+  TableBody,
+  TableCell,
+  TableContainer,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@carbon/react';
+import { ErrorState, useConfig, useDebounce } from '@openmrs/esm-framework';
+import { type Config } from '../config-schema';
+import { formatAuditDate } from './audit-format';
+import { getPreferredIdentifier, usePatientSearch } from './audit.resource';
+import styles from './audit.scss';
+
+interface PatientSearchProps {
+  onSelectPatient(patientUuid: string): void;
+}
+
+/**
+ * Step one of the audit trail: find the patient whose records are being audited, by name or by
+ * identifier. This mirrors the legacy admin page, which searched encounters by patient name or
+ * identifier, except that the patient is chosen explicitly before their encounters are listed.
+ */
+export default function PatientSearch({ onSelectPatient }: PatientSearchProps) {
+  const { t } = useTranslation();
+  const config = useConfig<Config>();
+  const [searchTerm, setSearchTerm] = useState('');
+  const [page, setPage] = useState(1);
+  const [pageSize, setPageSize] = useState(config.patientSearchPageSize ?? 10);
+  const debouncedSearchTerm = useDebounce(searchTerm.trim(), 300);
+  const pageSizes = useMemo(() => Array.from(new Set([pageSize, 10, 20, 50])).sort((a, b) => a - b), [pageSize]);
+  const { patients, totalCount, error, isLoading } = usePatientSearch(debouncedSearchTerm, page, pageSize);
+
+  useEffect(() => {
+    setPage(1);
+  }, [debouncedSearchTerm]);
+
+  return (
+    <div className={styles.section}>
+      <Search
+        className={styles.searchInput}
+        labelText={t('searchForPatient', 'Search for a patient by name or identifier')}
+        placeholder={t('searchForPatient', 'Search for a patient by name or identifier')}
+        onChange={(event) => setSearchTerm(event.target.value)}
+        size="lg"
+        value={searchTerm}
+      />
+      {!debouncedSearchTerm ? (
+        <p className={styles.emptyState}>
+          {t('searchToBegin', 'Enter a patient name or identifier to begin auditing their records.')}
+        </p>
+      ) : error ? (
+        <ErrorState error={error} headerTitle={t('patientSearchResults', 'Patient search results')} />
+      ) : isLoading ? (
+        <DataTableSkeleton columnCount={5} compact role="progressbar" showHeader={false} showToolbar={false} />
+      ) : patients.length === 0 ? (
+        <p className={styles.emptyState}>
+          {t('noPatientsFound', 'No patients match "{{searchTerm}}".', { searchTerm: debouncedSearchTerm })}
+        </p>
+      ) : (
+        <>
+          <TableContainer className={styles.tableContainer}>
+            <Table size="sm" useZebraStyles>
+              <TableHead>
+                <TableRow>
+                  <TableHeader>{t('patientName', 'Patient name')}</TableHeader>
+                  <TableHeader>{t('identifier', 'Identifier')}</TableHeader>
+                  <TableHeader>{t('gender', 'Gender')}</TableHeader>
+                  <TableHeader>{t('age', 'Age')}</TableHeader>
+                  <TableHeader>{t('birthdate', 'Date of birth')}</TableHeader>
+                </TableRow>
+              </TableHead>
+              <TableBody>
+                {patients.map((patient) => (
+                  <TableRow
+                    className={styles.clickableRow}
+                    key={patient.uuid}
+                    onClick={() => onSelectPatient(patient.uuid)}>
+                    <TableCell>
+                      <button
+                        className={styles.linkButton}
+                        onClick={(event) => {
+                          event.stopPropagation();
+                          onSelectPatient(patient.uuid);
+                        }}
+                        type="button">
+                        {patient.person?.display ?? patient.display}
+                      </button>
+                    </TableCell>
+                    <TableCell>{getPreferredIdentifier(patient)}</TableCell>
+                    <TableCell>{patient.person?.gender}</TableCell>
+                    <TableCell>{patient.person?.age}</TableCell>
+                    <TableCell>{formatAuditDate(patient.person?.birthdate)}</TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          </TableContainer>
+          <Pagination
+            onChange={({ page: nextPage, pageSize: nextPageSize }) => {
+              setPage(nextPage);
+              setPageSize(nextPageSize);
+            }}
+            page={page}
+            pageSize={pageSize}
+            pageSizes={pageSizes}
+            size="sm"
+            totalItems={totalCount}
+          />
+        </>
+      )}
+    </div>
+  );
+}

package/src/config-schema.ts

@@ -0,0 +1,36 @@
+/**
+ * This is the config schema. In OpenMRS Microfrontends, all config parameters
+ * are optional, so every element must have a reasonable default. See the
+ * configuration system documentation:
+ *   https://openmrs.github.io/openmrs-esm-core/#/main/config
+ */
+import { Type, validators } from '@openmrs/esm-framework';
+
+export const configSchema = {
+  patientSearchPageSize: {
+    _type: Type.Number,
+    _description: 'How many patients to show per page of patient search results.',
+    _default: 10,
+    _validators: [validators.inRange(1, 100)],
+  },
+  encountersPageSize: {
+    _type: Type.Number,
+    _description: "How many encounters to show per page of a patient's encounter list.",
+    _default: 10,
+    _validators: [validators.inRange(1, 100)],
+  },
+  patientChartUrl: {
+    _type: Type.String,
+    _description:
+      'The URL of the patient chart to link to from the audit trail. May contain the ' +
+      'template variables ${openmrsSpaBase}, ${openmrsBase} and ${patientUuid}.',
+    _default: '${openmrsSpaBase}/patient/${patientUuid}/chart',
+    _validators: [validators.isUrlWithTemplateParameters(['patientUuid'])],
+  },
+};
+
+export interface Config {
+  patientSearchPageSize: number;
+  encountersPageSize: number;
+  patientChartUrl: string;
+}

package/src/dashboard-link.component.tsx

@@ -0,0 +1,38 @@
+import React, { useMemo } from 'react';
+import { BrowserRouter, useLocation } from 'react-router-dom';
+import { useTranslation } from 'react-i18next';
+import { ConfigurableLink } from '@openmrs/esm-framework';
+import { dashboardMeta } from './dashboard.meta';
+
+function AuditLink() {
+  const { t } = useTranslation();
+  const { pathname } = useLocation();
+  const isActive = useMemo(
+    () =>
+      pathname
+        .split('/')
+        .map((segment) => decodeURIComponent(segment))
+        .includes(dashboardMeta.name),
+    [pathname],
+  );
+
+  return (
+    <ConfigurableLink
+      to={`${window.spaBase}/home/${dashboardMeta.name}`}
+      className={`cds--side-nav__link ${isActive ? 'active-left-nav-link' : ''}`}>
+      {t('audit', dashboardMeta.title)}
+    </ConfigurableLink>
+  );
+}
+
+/**
+ * Extensions are mounted as their own React root, so they do not inherit the
+ * home app's router context and need their own to read the current location.
+ */
+export default function DashboardLink() {
+  return (
+    <BrowserRouter>
+      <AuditLink />
+    </BrowserRouter>
+  );
+}

package/src/dashboard.meta.ts

@@ -0,0 +1,11 @@
+/**
+ * The home app renders one dashboard per extension assigned to the
+ * `homepage-dashboard-slot`, keyed off the `name` in the extension's meta.
+ * That name is also the last segment of the dashboard's URL, so this dashboard
+ * lives at `/openmrs/spa/home/audit`.
+ */
+export const dashboardMeta = {
+  name: 'audit',
+  slot: 'audit-dashboard-slot',
+  title: 'Audit',
+};

package/src/declarations.d.tsx

@@ -0,0 +1,3 @@
+declare module '@carbon/react';
+declare module '*.css';
+declare module '*.scss';

package/src/index.ts

@@ -0,0 +1,33 @@
+/**
+ * This is the entrypoint file of the application. It communicates the
+ * important features of this microfrontend to the app shell. It
+ * connects the app shell to the React application(s) that make up this
+ * microfrontend.
+ */
+
+import { defineConfigSchema, getAsyncLifecycle, getSyncLifecycle, registerBreadcrumbs } from '@openmrs/esm-framework';
+import { configSchema } from './config-schema';
+import { dashboardMeta } from './dashboard.meta';
+import DashboardLink from './dashboard-link.component';
+
+const moduleName = '@pih/esm-audit-app';
+const options = {
+  featureName: 'audit',
+  moduleName,
+};
+
+export const importTranslation = require.context('../translations', false, /.json$/, 'lazy');
+
+export const root = getAsyncLifecycle(() => import('./root.component'), options);
+
+export const auditDashboardLink = getSyncLifecycle(DashboardLink, options);
+
+export function startupApp() {
+  defineConfigSchema(moduleName, configSchema);
+  registerBreadcrumbs([
+    {
+      path: `${window.spaBase}/home/${dashboardMeta.name}`,
+      title: dashboardMeta.title,
+    },
+  ]);
+}

package/src/root.component.test.tsx

@@ -0,0 +1,58 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { SWRConfig } from 'swr';
+import { openmrsFetch, useConfig } from '@openmrs/esm-framework';
+import Root from './root.component';
+
+const mockOpenmrsFetch = jest.mocked(openmrsFetch);
+const mockUseConfig = jest.mocked(useConfig);
+
+function renderRoot(url = '/') {
+  window.history.pushState({}, '', url);
+  render(
+    <SWRConfig value={{ dedupingInterval: 0, provider: () => new Map() }}>
+      <Root />
+    </SWRConfig>,
+  );
+}
+
+describe('<Root />', () => {
+  beforeEach(() => {
+    mockUseConfig.mockReturnValue({ patientChartUrl: '${openmrsSpaBase}/patient/${patientUuid}/chart' });
+    mockOpenmrsFetch.mockImplementation((url: string) => {
+      if (url.includes('/patient/patient-1')) {
+        return Promise.resolve({
+          data: { uuid: 'patient-1', display: 'Y2AHXV - Dave TestPatient', person: { display: 'Dave TestPatient' } },
+        }) as ReturnType<typeof openmrsFetch>;
+      }
+      if (url.includes('/encounter/enc-1')) {
+        return Promise.resolve({
+          data: { uuid: 'enc-1', encounterType: { uuid: 'type-1', display: 'Oncology Consultation' } },
+        }) as ReturnType<typeof openmrsFetch>;
+      }
+      return Promise.resolve({ data: { results: [] } }) as ReturnType<typeof openmrsFetch>;
+    });
+  });
+
+  it('starts at the patient search', () => {
+    renderRoot();
+
+    expect(screen.getByText('Audit trail')).toBeInTheDocument();
+    expect(screen.getByRole('searchbox')).toBeInTheDocument();
+    expect(screen.getByText(/enter a patient name or identifier/i)).toBeInTheDocument();
+  });
+
+  it("shows a patient's encounters when the url names a patient", async () => {
+    renderRoot('/?patient=patient-1');
+
+    expect(await screen.findByText('Dave TestPatient')).toBeInTheDocument();
+    expect(screen.getByRole('checkbox', { name: /include deleted encounters/i })).toBeInTheDocument();
+  });
+
+  it('shows the encounter audit trail when the url names an encounter', async () => {
+    renderRoot('/?patient=patient-1&encounter=enc-1');
+
+    expect(await screen.findByText('Encounter summary')).toBeInTheDocument();
+    expect(screen.getByText('Observations')).toBeInTheDocument();
+  });
+});

package/src/root.component.tsx

@@ -0,0 +1,16 @@
+import React from 'react';
+import { BrowserRouter } from 'react-router-dom';
+import Audit from './audit/audit.component';
+
+/**
+ * Extensions are mounted as their own React root, so this dashboard does not inherit the home
+ * app's router context and needs its own in order to keep the audit trail's position — the
+ * selected patient and encounter — in the URL's query string.
+ */
+export default function Root() {
+  return (
+    <BrowserRouter>
+      <Audit />
+    </BrowserRouter>
+  );
+}

package/src/routes.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json.openmrs.org/routes.schema.json",
+  "extensions": [
+    {
+      "name": "audit-dashboard-link",
+      "slot": "homepage-dashboard-slot",
+      "component": "auditDashboardLink",
+      "meta": {
+        "name": "audit",
+        "slot": "audit-dashboard-slot",
+        "title": "Audit"
+      }
+    },
+    {
+      "name": "audit-dashboard",
+      "slot": "audit-dashboard-slot",
+      "component": "root"
+    }
+  ]
+}

package/src/types.ts

@@ -0,0 +1,122 @@
+/**
+ * Types for the encounter audit trail. These mirror the shapes returned by the
+ * OpenMRS REST API for the custom representations requested in
+ * `audit/audit.resource.ts` — keep the two in sync.
+ */
+
+/** The `{uuid, display}` shape the REST API uses for a reference to another resource. */
+export interface OpenmrsResourceRef {
+  uuid: string;
+  display?: string;
+}
+
+/**
+ * The REST API's `auditInfo` property. `changedBy`/`dateChanged` are only set once a
+ * row has been edited in place, and the `voided*` fields are only present on voided rows.
+ */
+export interface AuditInfo {
+  creator?: OpenmrsResourceRef;
+  dateCreated?: string;
+  changedBy?: OpenmrsResourceRef;
+  dateChanged?: string;
+  voidedBy?: OpenmrsResourceRef;
+  dateVoided?: string;
+  voidReason?: string;
+}
+
+export interface PagedResponse<T> {
+  results: Array<T>;
+  links?: Array<{ rel: 'prev' | 'next'; uri: string }>;
+  totalCount?: number;
+}
+
+export interface PatientIdentifier {
+  identifier: string;
+  preferred?: boolean;
+  identifierType?: OpenmrsResourceRef;
+}
+
+export interface AuditPatient {
+  uuid: string;
+  display: string;
+  identifiers?: Array<PatientIdentifier>;
+  person?: {
+    display?: string;
+    gender?: string;
+    age?: number;
+    birthdate?: string;
+    dead?: boolean;
+  };
+}
+
+export interface EncounterProvider {
+  uuid: string;
+  voided?: boolean;
+  provider?: OpenmrsResourceRef & { identifier?: string };
+  encounterRole?: OpenmrsResourceRef;
+}
+
+export interface AuditEncounter {
+  uuid: string;
+  display?: string;
+  encounterDatetime?: string;
+  voided?: boolean;
+  patient?: AuditPatient;
+  location?: OpenmrsResourceRef;
+  form?: OpenmrsResourceRef & { version?: string };
+  encounterType?: OpenmrsResourceRef;
+  visit?: OpenmrsResourceRef & { startDatetime?: string; visitType?: OpenmrsResourceRef };
+  encounterProviders?: Array<EncounterProvider>;
+  auditInfo?: AuditInfo;
+}
+
+export interface ConceptDescription {
+  description?: string;
+  locale?: string;
+}
+
+/**
+ * An obs value is a plain string or number for free-text, numeric and datetime obs, and a
+ * reference for coded obs (and for the drug/location values OpenMRS stores as coded-ish obs).
+ */
+export type ObsValue = string | number | boolean | OpenmrsResourceRef | null;
+
+export interface AuditObs {
+  uuid: string;
+  display?: string;
+  obsDatetime?: string;
+  voided?: boolean;
+  value?: ObsValue;
+  comment?: string;
+  formFieldPath?: string;
+  concept?: OpenmrsResourceRef & { descriptions?: Array<ConceptDescription> };
+  /** Set when this obs is a member of an obs group. */
+  obsGroup?: OpenmrsResourceRef;
+  /** Set when this obs replaced an earlier one, i.e. when the value was edited. */
+  previousVersion?: OpenmrsResourceRef;
+  auditInfo?: AuditInfo;
+}
+
+/**
+ * How an obs came to look the way it does, relative to the encounter it belongs to. Derived
+ * rather than stored — see `getObsChangeStatus`.
+ */
+export type ObsChangeStatus =
+  /** Entered when the encounter was first created and never touched since. */
+  | 'unchanged'
+  /** Replaces an earlier obs: someone changed the value after the fact. */
+  | 'edited'
+  /** Added to the encounter after the encounter itself was created. */
+  | 'addedAfterEncounter'
+  /** Voided outright — the value was removed from the encounter. */
+  | 'deleted'
+  /** Voided because a newer obs replaced it, so it holds a value that used to be current. */
+  | 'supersededValue';
+
+/** An obs plus the group nesting and change status the audit table renders. */
+export interface ObsTreeNode {
+  obs: AuditObs;
+  status: ObsChangeStatus;
+  depth: number;
+  children: Array<ObsTreeNode>;
+}

package/translations/en.json

@@ -0,0 +1,89 @@
+{
+  "action": "Action",
+  "activityLog": "Activity log",
+  "addedLater": "Added later",
+  "addedLaterLegend": "recorded after the encounter itself was created",
+  "age": "Age",
+  "allEncounterTypes": "All encounter types",
+  "audit": "Audit",
+  "auditTrail": "Audit trail",
+  "auditViews": "Audit views",
+  "backToEncounters": "Back to encounters",
+  "backToPatientSearch": "Back to patient search",
+  "birthdate": "Date of birth",
+  "cannotIncludeDeletedEncounters": "Deleted encounters can only be listed for a patient who has an identifier.",
+  "change": "Change",
+  "changedBy": "Changed by",
+  "changedByUser": "Changed by {{user}}",
+  "clearFilters": "Clear filters",
+  "createdBy": "Created by",
+  "deleted": "Deleted",
+  "deletedBy": "Deleted by",
+  "deletedEncountersUnavailable": "Deleted encounters unavailable",
+  "deletedLegend": "removed from the encounter",
+  "deletionReason": "Reason for deletion",
+  "detail": "Detail",
+  "edited": "Edited",
+  "editedLegend": "the value was changed after it was first recorded",
+  "encounter": "Encounter",
+  "encounterAudit": "Encounter audit",
+  "encounterChangedAction": "Changed encounter",
+  "encounterCreatedAction": "Created encounter",
+  "encounterDate": "Encounter date",
+  "encounterDateRange": "Encounter date range",
+  "encounterDeleted": "Deleted encounter",
+  "encounterDeletedAction": "Deleted encounter",
+  "encounterDeletedSubtitle": "This encounter has been deleted. Its observations are shown as they were left.",
+  "encounterNotFound": "That encounter could not be found.",
+  "encounters": "Encounters",
+  "encountersCreated": "Encounters created",
+  "encounterSummary": "Encounter summary",
+  "encounterType": "Encounter type",
+  "firstActivity": "First activity",
+  "form": "Form",
+  "gender": "Gender",
+  "identifier": "Identifier",
+  "includeDeletedEncounters": "Include deleted encounters",
+  "lastActivity": "Last activity",
+  "location": "Location",
+  "noActivity": "There is no recorded activity to show.",
+  "noEncountersFound": "This patient has no encounters to audit.",
+  "noEncountersMatchFilters": "No encounters match these filters.",
+  "noObservations": "This encounter has no observations.",
+  "noPatientsFound": "No patients match \"{{searchTerm}}\".",
+  "noProviders": "No providers are recorded for this encounter.",
+  "obsDeletedAction": "Deleted observation",
+  "obsDeletedCount": "Observations deleted",
+  "obsEditedAction": "Edited observation",
+  "obsEditedCount": "Observations edited",
+  "observations": "Observations",
+  "obsRecordedAction": "Recorded observation",
+  "obsRecordedCount": "Observations recorded",
+  "patient": "Patient",
+  "patientName": "Patient name",
+  "patientSearchResults": "Patient search results",
+  "previousValue": "Previous value",
+  "previousValueLegend": "the value that an edit replaced",
+  "provider": "Provider",
+  "providerName": "Provider name",
+  "providers": "Providers",
+  "questionConcept": "Question concept",
+  "readingObservations": "Reading observations from {{read}} of {{total}} encounters…",
+  "recordActivity": "Patient activity",
+  "recordedBy": "Recorded by",
+  "role": "Role",
+  "searchForPatient": "Search for a patient by name or identifier",
+  "searchToBegin": "Enter a patient name or identifier to begin auditing their records.",
+  "showConceptDescriptions": "Show concept descriptions",
+  "showDeletedObs": "Show deleted observations",
+  "showEveryone": "Show everyone",
+  "showOnlyThisUser": "Show only this user's activity",
+  "status": "Status",
+  "unknownUser": "Unknown user",
+  "user": "User",
+  "value": "Value",
+  "visit": "Visit",
+  "wasPreviously": "was {{value}}",
+  "when": "When",
+  "whoTouchedThisRecord": "Who modified this patient record"
+}

package/translations/es.json

@@ -0,0 +1,89 @@
+{
+  "action": "Acción",
+  "activityLog": "Registro de actividad",
+  "addedLater": "Añadido posteriormente",
+  "addedLaterLegend": "registrado después de crearse el encuentro",
+  "age": "Edad",
+  "allEncounterTypes": "Todos los tipos de encuentro",
+  "audit": "Auditoría",
+  "auditTrail": "Pista de auditoría",
+  "auditViews": "Vistas de auditoría",
+  "backToEncounters": "Volver a los encuentros",
+  "backToPatientSearch": "Volver a la búsqueda de pacientes",
+  "birthdate": "Fecha de nacimiento",
+  "cannotIncludeDeletedEncounters": "Los encuentros eliminados solo pueden listarse para un paciente que tenga un identificador.",
+  "change": "Cambio",
+  "changedBy": "Modificado por",
+  "changedByUser": "Modificado por {{user}}",
+  "clearFilters": "Borrar los filtros",
+  "createdBy": "Creado por",
+  "deleted": "Eliminado",
+  "deletedBy": "Eliminado por",
+  "deletedEncountersUnavailable": "Encuentros eliminados no disponibles",
+  "deletedLegend": "retirado del encuentro",
+  "deletionReason": "Motivo de la eliminación",
+  "detail": "Detalle",
+  "edited": "Editado",
+  "editedLegend": "el valor se cambió después de registrarse por primera vez",
+  "encounter": "Encuentro",
+  "encounterAudit": "Auditoría del encuentro",
+  "encounterChangedAction": "Encuentro modificado",
+  "encounterCreatedAction": "Encuentro creado",
+  "encounterDate": "Fecha del encuentro",
+  "encounterDateRange": "Rango de fechas de los encuentros",
+  "encounterDeleted": "Encuentro eliminado",
+  "encounterDeletedAction": "Encuentro eliminado",
+  "encounterDeletedSubtitle": "Este encuentro ha sido eliminado. Sus observaciones se muestran tal como quedaron.",
+  "encounterNotFound": "No se ha encontrado ese encuentro.",
+  "encounters": "Encuentros",
+  "encountersCreated": "Encuentros creados",
+  "encounterSummary": "Resumen del encuentro",
+  "encounterType": "Tipo de encuentro",
+  "firstActivity": "Primera actividad",
+  "form": "Formulario",
+  "gender": "Género",
+  "identifier": "Identificador",
+  "includeDeletedEncounters": "Incluir encuentros eliminados",
+  "lastActivity": "Última actividad",
+  "location": "Localidad",
+  "noActivity": "No hay actividad registrada que mostrar.",
+  "noEncountersFound": "Este paciente no tiene encuentros que auditar.",
+  "noEncountersMatchFilters": "Ningún encuentro coincide con estos filtros.",
+  "noObservations": "Este encuentro no tiene observaciones.",
+  "noPatientsFound": "Ningún paciente coincide con «{{searchTerm}}».",
+  "noProviders": "No hay proveedores registrados para este encuentro.",
+  "obsDeletedAction": "Observación eliminada",
+  "obsDeletedCount": "Observaciones eliminadas",
+  "obsEditedAction": "Observación editada",
+  "obsEditedCount": "Observaciones editadas",
+  "observations": "Observaciones",
+  "obsRecordedAction": "Observación registrada",
+  "obsRecordedCount": "Observaciones registradas",
+  "patient": "Paciente",
+  "patientName": "Nombre del paciente",
+  "patientSearchResults": "Resultados de la búsqueda de pacientes",
+  "previousValue": "Valor anterior",
+  "previousValueLegend": "el valor sustituido por una edición",
+  "provider": "Proveedor",
+  "providerName": "Nombre del proveedor",
+  "providers": "Proveedores",
+  "questionConcept": "Concepto de la pregunta",
+  "readingObservations": "Leyendo las observaciones de {{read}} de {{total}} encuentros…",
+  "recordActivity": "Actividad del paciente",
+  "recordedBy": "Registrado por",
+  "role": "Rol",
+  "searchForPatient": "Buscar un paciente por nombre o identificador",
+  "searchToBegin": "Introduzca el nombre o el identificador de un paciente para empezar a auditar su historial.",
+  "showConceptDescriptions": "Mostrar las descripciones de los conceptos",
+  "showDeletedObs": "Mostrar las observaciones eliminadas",
+  "showEveryone": "Mostrar a todos",
+  "showOnlyThisUser": "Mostrar solo la actividad de este usuario",
+  "status": "Estado",
+  "unknownUser": "Usuario desconocido",
+  "user": "Usuario",
+  "value": "Valor",
+  "visit": "Visita",
+  "wasPreviously": "era {{value}}",
+  "when": "Cuándo",
+  "whoTouchedThisRecord": "Quién ha modificado este historial del paciente"
+}