This is intended to be a replacement for the current OpenMRS FHIR module, initially using FHIR R4.
The FHIR2 module is divided into a series of layers, each responsible for a single piece of functionality. Each layer and the principles behind it is described below. Note that the rules given for each layer should be read as principles rather than hard and fast rules; they can be broken if there is a good enough explanation for why.
ResourceProviders: These are straight-forward HAPI
ResourceProviders. They serve to get the necessary parameters for each operation from the HAPI framework and then pass those parameters along to a
Serviceclass that implements the actual operation. Note that
ResourceProviders support older FHIR versions are responsible for translating from newer FHIR resources to their older equivalents.
ResourceProviders should depend only on
Servicelayer interfaces to allow the implementation of a resource to be changed at runtime based on local customisations.
ResourceProviders can be found in the
org.openmrs.module.fhir2.r4package and the
Serviceclasses are designed to implement the functionality needed by
ResourceProvidersin a reusable fashion. This allows us to use a single code-base to support multiple FHIR versions and allows the OpenMRS-specific FHIR functionality to be isolated from the HAPI-specific FHIR functionality. Service classes primarily coordinate between the
Translatorlayers. Generally, service classes are implemented as both an interface and a concrete implementation class, but we really only need the interface where the service corresponds directly to a
Serviceclasses should depend only on the interfaces of
Daos, to enable the implementations of these classes to be swapped at runtime.
Serviceinterfaces can be found in the
org.openmrs.module.fhir2.apipackage and the implementations in the
Translators are the classes that are primarily responsible for mapping between FHIR's data model and the OpenMRS data model (though note that other parts of the code need to be aware of these mappings, for example, to ensure that searching and translating use the same mappings. Where possible,
Translators should try to implement the full
OpenmrsFhirUpdatableTranslatorinterface, which supports mapping from OpenMRS objects to FHIR objects with special handling for creating and updating OpenMRS objects. Where that functionality is not needed, perhaps because we only support translating something to FHIR and not back to OpenMRS, other interfaces are available to describe the functionality supported. See the actual translators for examples.
Translators can be found in the
org.openmrs.module.fhir2.api.translatorspackage and the corresponding implementations in the
Daoclasses are responsible for actually interacting with the OpenMRS database. Normally, we do this relatively directly by using Hibernate, but this is also the layer than can use default OpenMRS services if there is special business logic we need to ensure is respected. The reason for using our own data access layer rather than the standard OpenMRS data access layer is to enable us to more effectively support the FHIR Search specification. Accessing the database directly allows us to turn what might be several calls to the OpenMRS service layer and some manual in-memory filtering into generally one or two database queries following a standard format.
Daos can be found in the
org.openmrs.module.fhir2.api.daopackage and the corresponding implementations in the
There are a couple of things that are not standard practice for other OpenMRS modules that should be borne in mind while developing this module.
- The OpenMRS service layer, e.g.
EncounterServiceetc. should only be used inside DAO objects.
- Avoid using
org.openmrs.Contextexcept as a last resort. We should favour injecting the appropriate service rather than relying on
Contextto load it for us.
Breaking Development Principles
The principles laid out above are just that: principles and baseline expected patterns for this module. They are not, however, unbreakable rules, but rather guidelines. Generally, these principles are designed to ensure that the FHIR module is maximally customisable without making that customisation a core feature of the module. The idea is that all of our mapping decisions are overridable at runtime via other modules without distracting from the ability to easily determine where any given functionality can be found. By sticking to common patterns, we make both of these tasks easier as people looking to implement, override or improve functionality should be able to easily work out where they need to do so.
Exceptions to the rules above are fine as long as they are in line with enabling customisation and ease of discovery of implementations. That is to say, we should have a stronger justification for breaking these principles than just "it's easier to code this way."
Broadly speaking, we should try to use the tools and utilities common to the OpenMRS environment, such as the Spring framework, Hibernate, Liquibase, Slf4j, JUnit, and Mockito. Libraries not included in the OpenMRS platform should be included sparingly; the more libraries bundled in this module, the more likely it is to interfere with other modules.
That said, we should attempt to use up-to-date methods for using these libraries, which will sometimes differ from how these technologies are used in the OpenMRS core. For example, we should favour annotation-based configuration for Spring, Hibernate, and JUnit rather than their XML equivalents, where possible.
In addition to the default libraries, we should use Lombok where feasible to avoid having to write so much repetitive code.
We should aim to have as much of this modules' code as possible tested with automated unit tests. Unit tests are tests which cover a single functional unit of code. More specifically, unit tests should aim to cover the behaviour of any methods that are marked as public. This blog post has good pointers on writing unit tests and on how to write code that is testable. However, for the purposes of this module, ignore the sections under "Test Close To The Reality". That is, we should write tests that make judicious use of mocks and tests that require a database should use an in-memory database.
In general, to test the output of any method, we should favour using
This will tend to lead to more "readable" assertions. For example compare this:
Concept expected = getExpectedConcept(); Concept result = getConcept("expectedConcept"); assertThat(result, equalTo(expected));
Concept expected = getExpectedConcept(); Concept result = getConcept("expectedConcept"); assertEquals(result, expected);
While the latter is slightly shorter, the assertion in the former reads closer to an English sentence.
Each unit test should be thought of as having three sections:
- The preconditions (given)
- The code being tested (when)
- Checking the expected result (then)
// given // here we setup whatever needs to be setup to test our code Concept expected = getExpectedConcept(); // when // this is the code we are testing Concept result = getConcept("expectedConcept"); // then // here we verify that what we expect happens. assertThat(result, equalTo(expected));
Class Naming Conventions
- Prefer to create an interface rather than directly creating a concrete type. This allows modules and implementers to swap out these classes with minimal effort.
- All interfaces should be the name of a class without additional text. For example, favour
GreatClassas an interface name over
- All implementation classes should be the name of the class with
Implto distinguish them from the interface. For example,
- All abstract classes should start with
Baseand not end with
Impl. For example,
- These conventions can be waved for
ResourceProviders, as they all implement HAPI's
IResourceProviderinterface and are not expected to be overwritten by implementations. Instead, they should be named
The license for this project is included in the LICENSE file. However, in addition to the full license included here, each file should contain the text found in license-header.txt at the start of the file.
For Java files, we should have the following message:
/* * This Source Code Form is subject to the terms of the Mozilla Public License, * v. 2.0. If a copy of the MPL was not distributed with this file, You can * obtain one at http://mozilla.org/MPL/2.0/. OpenMRS is also distributed under * the terms of the Healthcare Disclaimer located at http://openmrs.org/license. * * Copyright (C) OpenMRS Inc. OpenMRS is a registered trademark and the OpenMRS * graphic logo is a trademark of OpenMRS Inc. */
For XML files, we should use the following:
<!-- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/. OpenMRS is also distributed under the terms of the Healthcare Disclaimer located at http://openmrs.org/license. Copyright (C) OpenMRS Inc. OpenMRS is a registered trademark and the OpenMRS graphic logo is a trademark of OpenMRS Inc. -->
For properties files, we should use the following:
# # This Source Code Form is subject to the terms of the Mozilla Public License, # v. 2.0. If a copy of the MPL was not distributed with this file, You can # obtain one at http://mozilla.org/MPL/2.0/. OpenMRS is also distributed under # the terms of the Healthcare Disclaimer located at http://openmrs.org/license. # # Copyright (C) OpenMRS Inc. OpenMRS is a registered trademark and the OpenMRS # graphic logo is a trademark of OpenMRS Inc. #
In any case, the appropriate license header can easily be added to any existing file that needs it by running: