FHIR – POST data to Remote Server

In the previous blog, we have demonstrated how to GET the FHIR data from  the remote server. This blog post will be a continuation of the previous post, so the Mirth version that I will be using for this will be 3.4.2

As I previously said, latest version of Mirth 3.5 has FHIR listening and sending capability In-built in it. If you want to have a sophisticated FHIR sending and listening capability the best way is to choose 3.5 verison of Mirth.

We have got the data from the remote FHIR server. Now how do we update the data? to the remote server?

For this we are creating a new channel FHIR – Sender :

  1. Configure a new destination in the FHIR – Fetcher channel with the same listening port number of FHIR-Sender channel’s HTTP listener
  2. the content-type will be text/plain. And in the template provide the channel map variable ${getResponse}. We have used this same variable in the
  3. The listener of new channel FHIR-Sender will be a HTTP listener with a port number same as specified in the outbound channel of FHIR – Fetcher.
  4. To test, if the new channel is receiving the same data sent by the previous channel do a quick test in source transformer of the new channel by using the below code: logger.info(“Inside 2nd Channel : “+connectorMessage.getRawData());
  5. Note: connectorMessage is an important and very useful object in Mirth Javascript. This is supposed to fetch raw data, response data, transformed data and processed data efficiently from source to destination or from one channel to another.
  6. In the outbound message template provide the following XML template <Observation xmlns=”http://hl7.org/fhir”><Observation xmlns=”http://hl7.org/fhir”>   <id value=”66b0787a-b0c6-4f58-bf6b-ff5f7129658e”/>   <meta>      <versionId value=”2″/>      <lastUpdated value=”2017-05-26T11:54:50.782-04:00″/>      <profile value=”http://standardhealthrecord.org/fhir/StructureDefinition/shr-observation-Observation”/>      <profile value=”http://standardhealthrecord.org/fhir/StructureDefinition/shr-observation-SocialHistory”/>      <tag>         <system value=”https://smarthealthit.org/tags”/>         <code value=”synthea-5-2017″/>      </tag>   </meta>   <status value=”final”/>   <category>      <coding>         <system value=”http://hl7.org/fhir/observation-category”/>         <code value=”social-history”/>      </coding>   </category>   <category>      <coding>         <system value=”http://ncimeta.nci.nih.gov”/>         <code value=”C2004062″/>      </coding>   </category>   <code>      <coding>         <system value=”http://loinc.org”/>         <code value=”76690-7″/>         <display value=”Sexual orientation”/>      </coding> <text value=”VibinChander-Test-1″/>   </code>   <subject>      <reference value=”Patient/73f8dd15-e42f-48c4-a6b2-98f2253fb8ef”/>   </subject>   <context>      <reference value=”Encounter/b74c4ab6-e9bb-4c5b-a805-8e65e1880278″/>   </context>   <effectiveDateTime value=”2008-06-05T06:59:12-04:00″/>   <issued value=”2008-06-05T06:59:12-04:00″/>   <valueQuantity>      <value value=”0″/>      <unit value=”{nominal}”/>      <system value=”http://unitsofmeasure.org/”/>      <code value=”{nominal}”/>   </valueQuantity></Observation>
  7.  The uhn FHIR server takes updating of data only in the form of XML rather than JSON. So basically we are fetching the JSON from the first channel then we have to transform the JSON to XML in another channel then send the updated XML from the new channel  to hit the remote FHIR server.
  8. Here, I’m skipping the conversion part from JSON to XML and hard-coding the XML part as it is. In the above XML I have modified only one tag <text value=”VibinChander-Test-1″/> if you modify the other tags on this you may get error in updating the status of FHIR because the API  is constructed to validate the contents of FHIR as well.
  9. After Deployment in the sender channel’s response you can find this tag “Observation/66b0787a-b0c6-4f58-bf6b-ff5f7129658e/_history/10” this URL is accessible in the publicly which will provide you the updated status.
  10. The sender type of the new channel has to be PUT not POST and the corresponding URL for that will be https://fhirtest.uhn.ca/baseDstu3/Observation/66b0787a-b0c6-4f58-bf6b-ff5f7129658e?_format=xml&_pretty=true
  11. you will find the updated data you have made in this URL https://fhirtest.uhn.ca/baseDstu3/Observation/66b0787a-b0c6-4f58-bf6b-ff5f7129658e/_history/10

 

Advertisements

FHIR – GET Data From Server

In this Post you learn how to communicate to the Remote FHIR server and get the data into Mirth Interface Engine.

Mirth version : 3.4.2. (Note: In the latest version 3.5, there is a very sufficient capability to consume FHIR resources separately. There is also FHIR reader/listener available as source connector.)

Create a channel with a name “FHIR -fetcher”:

  1. The purpose of this channel is to send the GET request to the remotely hosted FHIR server and get the information from it.
  2. Navigate to the Destination tabs of that channel and select HTTP sender as the option.
  3. In the URL tabs, insert this link https://fhirtest.uhn.ca/baseDstu3/Observation/66b0787a-b0c6-4f58-bf6b-ff5f7129658e/_history/2?_pretty=true
  4. Select No for using Proxy server
  5. Click GET method. Leave the rest to the default variable as it is.

Now navigate to the channels tab, right click on this channel and select deploy. Once the channel is deployed, right clicked on the deployed channel and send some dummy data. Now the channel will fetch the data you will have Received 1 and sent 1. This shows that your channel communicates to the remote server and gets the FHIR data successfully.

  •  Double click on the deployed channel, select the SENT message and  click Response radio button now you will find the data received from the FHIR remote server.

The response from the FHIR remote server for the request we have given will look like below.

FHIR response

Now a little bit about the server itself. What is this remote server?:

  • This remote server can be accessed through this link http://fhirtest.uhn.ca/ This is a FHIR test server sponsored and developed by United Health Network from California.
  • On the left hand side of the page you can find lot of resources been available such as Observation, Condition, Immunization, Procedure, Care Plan etc.
  • Select any one of them (I’ve used Observation in this example), you can select any them of your choice.
  • Once resource is selected, On the right hand side you can see a blue button with the “Search” on it. Click on that as shown below

FHIR test Server

In the right hand side you can see a panel showing REQUEST with a specific URL and their characteristics being listed below. This URL is not the same URL we have used above. In-fact this URL is completely different. This is called BUNDLE resource URL. If you do a GET request on this URL you will get a complete JSON bundle of all the resources we have made it up so far.

You can scroll down to see the RAW message on the same page, and that is the JSON message we will be getting, this will be rough combination of all the Observation been made.

If we want  to get a specific Observation of a resource, then we have to use any of the links provided in the Result Body panel. by default it will list only 20 URLS to be used. You can extend that content as well. The URL that I have used in the above to GET the data is one such thing. You can find my URL using the Unique ID that URL contains. In the above example my URL contains 66b0787a-b0c6-4f58-bf6b-ff5f7129658e as unique ID. Do the browser find to find this URL.

If you click on the READ blue button near to the URL that will take you to another page where you will have RAW message in the Result Body Area. That is where you can find the message that we will be getting inside the Mirth as well.

 

Data Standards – US Healthcare

Lets take three hospitals, A,B and C which uses different data standards for defining Gender in their hospitals

A uses 0,1 for male and female.
B uses 1,0 for male and female,
C uses M,F,U for male, female and unknown.

The data of A and B are different syntactically while the data standards of A and C are different semantically. To achieve uniformity in these, Data standards are proposed. The simplest data standards are as follows:

National Drug Code System:

National Drug Code System  Maintained by US Food and Drug Administration (FDA)
This is a three segment code, that says “who made it / who labelled it”, “what drug is in it”, “what is the package size of this drug”. There are many commercial databases available which provides the same information.

For Example : Please find the below image which is basically a NDC for some medication called “Prozac”. Prozac tablets are basically anti-depressant tablets that will be used for treating/helping patients with Obsessive-Compulsion-Disorder (OCD), or other depression that includes even Bi-polar disorders.

NDC example

The first 4 digits represents the makers of the product. Here Prozac tablets are made by Dista Products. The next 4 digits represents the type the medication will be used, like Prozac as a medication is consumed as Capsule based tablets, it will come in bottle and with 20 mg of each tablets. Then the last two digits represents the count of the tablets, so the Prozac in general will come with the volume of 100 tablets.

As time progress on, many commercial pharmacy databases also started to use the same kind of information or code standards.

RxNorm:

To avoid the complexity of commercial databases who produce same information again and again on the medicines.  Another Standard was initiated by National Library of Medicine (NLM). They created something called RxNorm, which gave much more standard to the medication been used by a particular patient.

These RxNorm codes use a special unique number called RxCUI. which will be unique for different drug. Not all medications will have the same RxCUI code. The RxCUI code for the same drug Prozac and its composition can be found here in this link – RxNorm  Prozac

 

MU – Meaningful Use (Why?)

Why Meaningful Use (MU)?

Meaningful Use encourages you to switch from paper charts to electronic records while giving the best care to your patients. It improves your practice’s efficiency, and will earn you incentives. Medicare penalties for lack of participation began in 2015, so be sure to get started with the

Meaningful use is using certified electronic health record (EHR) technology to:

  • Improve quality, safety, efficiency, and reduce health disparities
  • Engage patients and family
  • Improve care coordination, and population and public health
  • Maintain privacy and security of patient health information

Ultimately, it is hoped that the meaningful use compliance will result in:

  • Better clinical outcomes
  • Improved population health outcomes
  • Increased transparency and efficiency
  • Empowered individuals
  • More robust research data on health systems

About EHR Incentive Program:

The American Recovery and Reinvestment Act of 2009 (ARRA) (Pub.L. 111–5) was enacted on February 17, 2009. Title IV of Division B of ARRA amends Titles XVIII and XIX of the Social Security Act (the Act) by establishing incentive payments to eligible professionals (EPs), eligible hospitals, and critical access hospitals (CAHs), and Medicare Advantage Organizations to promote the adoption and meaningful use of interoperable health information technology (HIT) and qualified electronic health records (EHRs). These incentive payments are part of a broader effort under the HITECH Act to accelerate the adoption of HIT and utilization of qualified EHRs.

Beginning in 2011, the Medicare and Medicaid Electronic Health Record (EHR) Incentive Programs were established to encourage eligible professionals and eligible hospitals to adopt, implement, upgrade (AIU), and demonstrate meaningful use of certified EHR technology.

What is MU-1,MU-2 & MU-3 ?

  1. Stage 1 set the foundation for the EHR Incentive Programs by establishing requirements for the electronic capture of clinical data, including providing patients with electronic copies of health information.
  2. Stage 2 expanded upon the Stage 1 criteria with a focus on ensuring that the meaningful use of EHRs supported the aims and priorities of the National Quality Strategy. Stage 2 criteria encouraged the use of health IT for continuous quality improvement at the point of care and the exchange of information in the most structured format possible.
  3. Stage 3 In October 2015, CMS released a final rule that specifies criteria that eligible professionals, eligible hospitals and CAHs must meet in order to participate in the EHR Incentive Programs in 2015 through 2017 (Modified Stage 2) and in Stage 3 in 2017 and beyond.

MU Regulations with respect to years:

MU certifications

MU reporting periods:

MU Reporting Period

MU EHR Medicare Incentives:

MU Medicare Incentives

MU EHR Medicaid Incentives:

MU Medicaid Incentives

 

Connect Mirth with MongoDB

It is an essential feature to connect Mirth to any flat-file Database. The reason for the shift is because in future we are expecting data in the form of an non-aligned  structure like an API call.

Most of the business people now are using Healthcare market just to increase the care co-ordination they offer.To achieve this business need, they are targeting people with mobile applications. Looking at from this perspective, the front end of this mobile application depends on latest technologies like  ReactJS or AngularJS.  These technologies primarily focus on efficiently binding the received data. This data is usually in a JSON format.

From the interoperability perspective we can see the need for inserting incoming data to parse and provide them in the flat-file MongoDB.

I basically use Java to try out this and to implement them in Mirth.

Pre-requisite:

MongoDB – connectivity Jar : please download the jar file from here  Please  Download 2.11.1/  I was using this version as it a stable release. Download mongo-java-driver-2.11.1.jar This contains only the connectivity Jar to MongoDB

Install MongoDB : Make sure MongoDB is available in your system, if you are using Windows system then make sure you navigate to the MongoDB folder and open to run Mongod.exe this will make the mongo server to listen to the port 27017 by default. Then open run Mongo.exe this will open the MongoShell console.

——————————————————–

MongoDB :

—————– Create Database ————–

show dbs;
use FHIRtest
type : db;
you should get : FHIRtest

—————– Create Collection ————–

db.createCollection(“SampleFHIR”);
type : show collections;
you should get : SampleFHIR

—————– Insert Data ——————–

db.SampleFHIR.insertOne({“Data”:”PatientInfo- GETtest”});
type : db.SampleFHIR.find();
you should get : { “_id” : ObjectId(“57c45d8403114b848da5b516”), “Data” : “PatientInfo- GETtest”}

—————————————————

Now we have a Database ready with a collection in it, also it has one collection.

We will write a JAVA code, that will primarily read the data from the MongoDB and display it to check for the connection.

package com.fhir;

import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.Set;

import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;

public class FhirConnector {
public static void main(String[] args){
try{
//Connect to MongoDB client
MongoClient mongoClient = new MongoClient(“localhost”, 27017);
DB db = mongoClient.getDB(“FHIRtest”);
System.out.println(“- Database: ” + db);
//get collection data
DBCollection col = db.getCollection(“SampleFHIR”);
System.out.println(“- Collections: ” + col);
//Print Data in MongoDB
DBCursor cursor = col.find();
while(cursor.hasNext()) {
System.out.println(cursor.next());
}

}catch(IOException e){
throw new RuntimeException(e);
}
}
}

Output :

You should be getting an output like this:
consoleJava
Note: I have used a different collection name in my code, so the collection name is different in the console screen.

Now Let’s try to insert some data inside the same collection and then try to read the output. My making a a new code change in the above existing code.

package com.fhir;

import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.Set;

import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;

public class FhirConnector {
public static void main(String[] args){
try{
MongoClient mongoClient = new MongoClient(“localhost”, 27017);
DB db = mongoClient.getDB(“FHIRtest”);
System.out.println(“- Database: ” + db);

DBCollection col = db.getCollection(“FHIRdump”);
System.out.println(“- Collections: ” + col);

//Insert data into MongoDB
BasicDBObject document = new BasicDBObject();
document.put(“database”, “FHIRtest”);
document.put(“collection_mark”, “insertFHIR”);

BasicDBObject documentDetail = new BasicDBObject();
documentDetail.put(“records”, 99);
documentDetail.put(“index”, “vps_index1”);

document.put(“detail”, documentDetail);
col.insert(document);
System.out.println(“Inserted into DB”);

//Print Data in MongoDB
DBCursor cursor = col.find();
while(cursor.hasNext()) {
System.out.println(cursor.next());
}

}catch(IOException e){
throw new RuntimeException(e);
}
}
}

Output :

You should be getting a console output like this:
consoleJava2

In the Mongo shell you will get an output like this:

mongoshell output

Now we have written the Java code that will insert a data into MongoDB. Next step we will incorporate this into Mirth.To achieve this in Mirth, deploy the MongoDB connectivity Jar in Mirth custom-lib folder. and If you have the Mirth running, restart the service.

Channel :

Source : set the source as FHIR listener set the port of your convenience

Source Transformer : 
We will write a code here, that will fetch the incoming JSON data . We will send the data to Mirth via POSTMAN chrome application tool.

var jsonData = connectorMessage.getRawData();
var parseData = JSON.parse(jsonData)
// parsed Data contents
var status = parseData.text.status;
var resource= parseData.resourceType;
var identity = parseData.id;
var sex = parseData.gender;
var dob = parseData.birthDate;
logger.info(status+” “+resource+” “+identity+” “+sex+” “+dob);
channelMap.put(‘statusDetail’,status);
channelMap.put(‘resource’,resource);
channelMap.put(‘id’,identity);
channelMap.put(‘gender’,sex);
channelMap.put(‘DateofBirth’,dob);

Destination:
Now set the destination as Javasscript writer. and type the below code in the destination

try{
var mongoClient = new Packages.com.mongodb.MongoClient(“localhost”,27017);
var db = mongoClient.getDB(“FHIRtest”);
var col = db.getCollection(“SampleFHIR”);

// Insert data into MongoDB
var document = new Packages.com.mongodb.BasicDBObject();
document.put(“Status”,$(‘statusDetail’));
document.put(“resourceType”, $(‘resource’));

var documentDetail = new Packages.com.mongodb.BasicDBObject();
documentDetail.put(“identity”, $(‘id’));
documentDetail.put(“sex”, $(‘gender’));
documentDetail.put(“dob”, $(‘DateofBirth’));

document.put(“detail”, documentDetail);

col.insert(document);

//get Data from MongoDB
var cursor = col.find();
while(cursor.hasNext())
{
logger.info(“Inside Collection : “+cursor.next());
}

}catch(e){}

You can now deploy the channel, and pass the below JSON as the message in POSTMAN

{
“text”: {
“status”: “generated”
},
“resourceType”: “”,
“id”: “210321-120321”,
“gender”: “male”,
“birthDate”: “1994-01-04”
}

You will now get the following output in the Mongo Shell.

mongoshell output 2

You can see that data is a simple JSON. But you can see all the packages, databases  are named as FHIR, the reason behind this is, It is essential to put json to a flat-file format in a enhanced way. FHIR being transferred as both XML as well as JSON it is essential to know how well we handle this and store in a flatfile format.

In future any server side based codes can read this FHIR resources as it is from MongoDB put it as an API, from where all  the mobile technologies like AngularJS, ReactJS will parse the incoming API and publish it in a wonderful user viewing manner.

— Hope this is useful.

 

 

Blog at WordPress.com.

Up ↑