Introduction

This article is the content of the lecture introduced at the 2nd openEHR study group in 2020. EHRbase is one of the open source software implementations of the openEHR specification. This time, I will introduce the architecture of EHRbase and how to build a development environment.

The following contents are constructed with reference to the following materials and the memo of Professor Ehime Kimura of Ehime University.

EHRbase(GitHub repository)
- https://github.com/ehrbase/
EHRbase project
- https://ehrbase.org/
Christian Chevalley's presentation at EHRbase, The 3rd openEHR Asia summit
- https://www.slideshare.net/openEHR-Japan/ehrbase-open-source-openehr-cdr

EHRbase development environment

Lists the main software components used by EHRbase as a development environment. The environment is built with docker, but please install it if necessary.

docker
Java JDK / JRE 11 (OpenJDK recommended)
Maven
Springboot
PostgreSQL 10.4-
- jsquery plugin
- temporal template
Postman
Ocean archetype editor, template designer

EHRbase overview

EHRbase is one of the open source software implementations of EHR servers according to the openEHR specification.
Development will start in 2019, following the flow of MEDScape and EtherCIS.
Currently, a development team of 16 people is developing on GitHub.
We are building an EHR server with Modern platform architecture using Springboot.
- REST API, JSON/XML message
Stores and manages EHR data, but does not handle information such as personal names and addresses
- OpenEPMI
in Japan?
Clients are not included, including UI. (SDK provided)

What EHRbase is aiming for

Implementation of EHR in open source software that complies with the openEHR specification
Lower barriers for vendors, hospitals and governments to introduce published standards and platforms that establish interoperability with them.
It will be the foundation that supports data-driven healthcare and will enable interoperability in healthcare in the 21st century.
It shall also be available for electronic prescriptions and intensive care management with complicated work procedures.
Make it easy to develop next-generation medical software.

EHRbase Organizational Governance

Hanover Medical College
Vitasystems Gmbh
HiGHmed Medical Informatics, sponsored by:
- German Ministry of Education and Research
- Medical Informatics Initiative Germany
Open Source Governance
Behavior Driven Development
SCRUM approach (1 sprint for 2 weeks)

EHRbase architecture

Christian Chevaley, EHRbase, the 3rd openEHR Asia summit, online, July 24, 2020.

EHRbase and its surroundings

Christian Chevaley, EHRbase, the 3rd openEHR Asia summit, online, July 24, 2020.

EHRbase server

Secure REST API (supports various authentication procedures including OAuth2)
Perform openEHR compliant CRUD transactions and validation
Query (AQL) processing for openEHR objects
Maintain a local knwoledge model
Data-centric architecture
Supports the latest architecture of openEHR

EHRbase SDK

Can handle Template (Knowledge base)
Template can be converted to POJO class
Provide the EHRbase client endpoint as a Java method
- EHR
- Template
- Composition
- Querying(AQL)
- Directory
Supports serialization and validation of openEHR objects
Generate REST API payload

Development environment construction

Before installing EHRbase

This time we will build the environment with Docker, so we will prepare the environment so that docker can operate. docker-engine and docker-compose will work with relatively new versions, but not with older versions around ver 1.7.

Linux
Please install docker and docker-compose corresponding to each distribution.
Windows
Please Prepare WSL2 environment before preparing Docker environment.
I have tried it on Ubuntu 20.04LTS, but I think other distros are okay.
Mac
I haven't tried it, but docker seems to work.

EHRbase installation

** Important **: Please note that the official procedure may cause it to stop working.

Java is not used this time, but JDK 11 equivalent installation is required for development, so please install it according to your environment as appropriate.
The order is as follows.

Create docker-network
Setting up a container with PostgreSQL and related plugins
Create an EHRbase application container

Creating docker-network

Create a docker network for EHRbase with the following command

$ docker network create ehrbase-net

Check with docker network ls and it is OK if the following is displayed.

$ docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
2c6a5b55365a        bridge              bridge              local
4b82d2167e35        ehrbase-net         bridge              local
5ee3d71c037f        host                host                local
31ab9819a783        none                null                local

Setting up a container with PostgreSQL and related plugins

If you are already using PostgreSQL, you can use it as it is, but you need to install the plug-in.

Use docker

$ docker run --name ehrdb --network ehrbase-net -e POSTGRES_PASSWORD=postgres -d -p 5432:5432 ehrbaseorg/ehrbase-postgres:latest

If you do not use docker, install PostgreSQL (ver 10.4 or later) and then install the following plugins. For Ubuntu, install the required packages as shown below.

$ sudo apt install gcc bison flex postgresql libpq-dev postgresql-server-dev-all openjdk-11-jdk maven

Install tamporal_tables

`temporal_tables`


$ git clone https://github.com/arkhipov/temporal_tables.git
$ cd temporal_tables
$ make
$ sudo make install
$ make installcheck

If you get an error with make install check, create a ROLE with the same name as your Linux user name in PostgreSQL and give it database creation privileges.
Install jsquery

`jsquery`


$ git clone https://github.com/postgrespro/jsquery.git
$ cd jsquery
$ make USE_PGXS=1
$ sudo make USE_PGXS=1 install
$ make USE_PGXS=1 installcheck

If you get an error with make install check, create a ROLE with the same name as your Linux user name in PostgreSQL and give it database creation privileges.

Build an EHRbase server

It is convenient to use docker.

$ docker run --name ehrbase --network ehrbase-net -d -p 8080:8080 -e DB_URL=jdbc:postgresql://ehrdb:5432/ehrbase -e DB_USER=ehrbase -e DB_PASS=ehrbase -e SYSTEM_NAME=local.ehrbase.org ehrbaseorg/ehrbase:latest

Confirm the execution as follows.

$ docker exec -i -t ehrbase /bin/bash

If you want to build including the development environment without using docker, do as follows.
Initialize database table

$ git clone https://github.com/ehrbase/ehrbase.git
$ cd ehrbase
$ sudo -u postgres psql -e < ./base/db-setup/createdb.sql

Maven environment settings
Edit pom.xml if necessary.
Package build

$ mvn package

Run EHRbase.
If it is the current version, execute the following command.

$ java -jar application/target/application-0.13.0.jar

API confirmation

If it works, you will see a list of APIs built with Swagger-ui. The basic authentication user is ehrbase-user and the password is SuperSecretPassword.

http://localhost:8080/ehrbase/swagger-ui.html

EHR registration

Let's register EHR using Postman. Use the following JSON sample in the official tutorial.

{
  "_type": "EHR_STATUS",
  "subject": {
    "external_ref": {
      "id": {
        "_type": "GENERIC_ID",
        "value": "ins01",
        "scheme": "id_scheme"
      },
      "namespace": "ehr_craft",
      "type": "PERSON"
    }
  },
  "other_details": {
    "_type": "ITEM_TREE",
    "items": []
  },
  "is_modifiable": "true",
  "is_queryable": "true"
}

Template registration

Create a Template using Template editing software such as Ocean Template Designer. Once created, output in operational template format.

After checking the contents of the XML file, register it with Postman according to the API.

The registered file can also be viewed using Postman.

Next time, we will register, read, update, and delete (CRUD) data based on this template.

[JAVA] Introduction to EHRbase 1-Overview and Environmental Improvement