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.

 

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 ↑