IHE Profile – ITI 18 (Registry Stored Query)

ITI – 18 is used by Document Registry and Document Consumer actors. Both of these actors may use Synchronous or Asynchronous web service exchange.

Definition : IHE_ITI_TF_Rev14.0_Vol2a_FT_2017-07-21 (Pg: 91)

When two actors referred as Requester and Provider want to exchange information in a request-response pattern, then this communication can happen in two ways as Synchronous and Asynchronous web service exchange pattern.

Synchronous web service exchange:

In Synchronous web service exchange the requester (system which send the request) will send a request and wait for the provider (system which will respond for the request) to respond in the same connection (socket connection) which the requester initially established.

In Synchronous web service exchange a provider will always be available to respond whenever the requester send their message. Here response sender is a HIE (i.e) provider is a HIE and Requester is a EHR Middleware

Asynchronous web service exchange:

In Asynchronous web service exchange the requester will send a request knowing that provider will eventually send the response. The provider may not be available by the time the request is sent.

When the provider receives the message it will send the acknowledgement back to the requester In simple words, Asynchronous is only concerned about sending a request. EMR  will send only the request and whenever the HIE is available, it will receive it.

syn-async

Definition : IHE_ITI_TF_Vol2x (Pg : 135) 

The Document Consumer will send a request query by passing parameters to it. The Document Registry services the query based on the defined definition it has. In this scenario the Document consumer will be a EHR and the Document Registry is a HIE.

iti18

Registry Stored Query is the request query from the EHR to the HIE. It contains two elements:

  1. A reference to a predefined query
  2. parameters to a query

Message Breakdown:

The ITI 18 message follows ebXML Registry Information Mode Version (RIM) 3.0 . This ITI 18 ebXML stored query takes three forms of parameters

a) returnType
b) QueryID (an UUID) and
c)Query Parameters

Find the sample HL7v3 request from Document Consumer to Document Registry.

sample_iti_18_XML

  1. The message that starts with <query:AdhocQueryRequest> is a root element or the header tag, this provides all the necessary namespaces for the document standards, this is a static data.
  2. <query:ResponseOption> contains two attributes returnComposedObjects and returnType. the default value of returnComposedObjects will be set to “true”, which literally means the request is expecting a response back

returnType: The returnType can have two values 1. LeafClass 2. ObjectRef,
The LeafClass returns a list of XML elements of fully specified ebXML objects. This type of query result is self-contained, everything known about the object(s) is returned.
The ObjectRef returns a list of UUID which references to the registry object that matches the query. This type query is recommended when the returned object list could be large.
In real time an information has to be provided from the EHR to determine what kind of returnType is expected either LeafClass or ObjectRef
3.  <rim:AdhocQuery> contains only one attribute called id this is referred as QueryID. This is most important and required field. These are IDs (a list predefined) that are used in the AdhocQueryRequest to reference certain actions to be performed. For Example: EHR will request the HIE to Find Documents or Get Related Documents. Based on this request ID, the corresponding query parameters will change.

Query IDs are in UUID format (RFC4122). An error will be returned to the requester whenever unsupported query id is provided. The below provided are the list of actions and their corresponding Query ID

iti_18-query_id_list

Definition: IHE_ITI_TF_Rev14.0_Vol2a_FT_2017-07-21 (Pg: 113)

You can notice that in the XML provided as sample the Query ID specified is <rim:AdhocQuery id=”urn:uuid:14d4debf-8f97-4251-9a74-a90016b0af0d”> which refers to the QueryName Find Documents.

4.  In the sample XML you can also see <rim:slot> beginning sections, and the number of parameters were passed. All these parameters depends on the Query ID provided, For Example if the QueryID provided is for the action of Find Documents, then the query parameters will have the following data with it.

query_parameters_find_document

Definition: IHE_ITI_TF_Rev14.0_Vol2a_FT_2017-07-21 (Pg: 99)

For the QueryID with the name of Find Document the table provides parameters that needed to be passed. The <rim:Slot name=””> must be filled with the Parameter Name column of the table <rim:Value></rim:Value> must contain the corresponding value of the parameter. Note: Not all parameters are required for this, only highlighted ones which are those mentioned as Required (R) in Opt column is needed.

Now comes another question.. in the provided XML sample you can notice that a patient ID is provided in this format  <rim:Value>’st3498702^^^&amp;1.3.6.1.4.1.21367.2005.3.7&amp;ISO’</rim:Value> How will the EHR know what elements are these?

For this refer IHE_ITI_TF_Rev14.0_Vol2a_FT_2017-07-21.pdf document (pg number 95), these are nothing but the coding standards of ebXML specification. The general Syntax of this will be <value> (‘code1^^coding-scheme1’) </value> and it can have multiple values <Value>(‘code1^^coding-scheme1′,’code2^^coding-scheme2’)</Value>

For the Query ID with the name of Find Submission Sets the below are the expected parameters:

iti_18-find_submission_set

Advertisements

Create Mirth Environment in AWS (Amazon AMI)

Setup Java:

Check if the Java JDK is installed in the system. use the below command to confirm

java -version

if it returns java: command not found then you have to install java in the machine.

yum -y install java-1.8.0-openjdk

you will need a (sudo) in front to perform that action as a root user. sudo yum -y install java-1.8.0-openjdk. This will install the complete Java 1.8.0 package for you.

perform java -version again. this will give you the below resultjdk install success

Install Mirth connect:

Download Mirth connect by using the below command, the below link is for the version 3.6.0

sudo wget http://downloads.mirthcorp.com/connect/3.6.0.b2287/mirthconnect-3.6.0.b2287-unix.tar.gz

unzip the downloaded file by using the following command

sudo tar xvfz mirthconnect-3.6.0.b2287-unix.tar.gz

once you unzip you can see a new mirth connect folder available (with a space between Mirth and Connect). you will not use the tar.gz file anymore, you can delete it by using the below command

sudo rm -r mirthconnect-3.6.0.b2287-unix.tar.gz

It’s always better to move the spaced folder to space-less folder and keep it inside the opt directory. Perform the following command for it

sudo mv Mirth\ Connect/ /opt/mirthconnect

Mirth will need two ports one is 8080 and another is 8443, you need to enable these two ports in the security group of the AWS  console.

open_ports_for_mirth

Navigate to security groups and select launch-wizard-1 group name. The click on Inbound tab and click Edit button. Add the ports as shown in the picture below

adding_ports

Now we need to start the Mirth Service to run on the remote system. Navigate to opt/mirthconnect/ and type the below command

./mcservice start

Getting AWS remote mirth in local:

Type the IP address and the webstart port of the mirth connect in your browser URL

 

 

 

Function for – Fetching Complete System Specification

This blog provides the code with javascript function that will fetch all the system specification of the system upon which mirth is installed.

This function does not require any input parameter, it will fetch all the statistics of the system in complete real time scenario.

function fetchSystemConfigurations() {

var systemConfiguration = ”;

function memoryCalc(data) {
var kb = data / 1024;
var mb = kb / 1024;
var gb = mb / 1024;

var finalGb = Math.round(gb);
var finalMb = Math.round(mb);
var finalKb = Math.round(kb);

var finalValue;

if (finalGb == 0) {
finalValue = finalMb + ‘MB’;
} else if (finalMb == 0) {
finalValue = finalKb + ‘KB’;
} else if (finalKb == 0) {
finalValue = data + ‘Bytes’;
} else {
finalValue = finalGb + ‘GB’;
}
return finalValue;
}

var availableProcessors = “Available Processors : ” + new java.lang.Runtime.getRuntime().availableProcessors();
var freeMemory = “Free Memory : ” + memoryCalc(new java.lang.Runtime.getRuntime().freeMemory());
var osName = “OS Name : ” + new java.lang.System.getProperty(‘os.name’);
var maximumMemory = “Maximum Memory : ” + memoryCalc(new java.lang.Runtime.getRuntime().maxMemory());
var totalJVMMemory = “Total JVM Memory : ” + memoryCalc(new java.lang.Runtime.getRuntime().totalMemory());
var javaVersion = “Java Version : ” + new java.lang.System.getProperty(‘java.version’);
var file = new java.io.File(‘c:’);
var diskFreeSpace = “Disck Free Space : ” + memoryCalc(file.getFreeSpace());
var diskTotalSpace = “Total Disk Space : ” + memoryCalc(file.getTotalSpace());
var hostNameAndIP = Packages.java.net.InetAddress.getLocalHost().toString();
var splitData = hostNameAndIP.split(“/”);
var hostName = “Host Name : ” + splitData[0];
var IP = “IP : ” + splitData[1];
var processorIdentifier = “Processor Identifier : ” + java.lang.System.getenv(“PROCESSOR_IDENTIFIER”);
var processorArchitecture = “Processor Architecture : ” + java.lang.System.getenv(“PROCESSOR_ARCHITECTURE”);
var javaClassPath = “Java Class Path : ” + new java.lang.System.getProperty(“java.class.path”);

systemConfiguration = availableProcessors + “\n” + freeMemory + “\n” + osName + “\n” + maximumMemory + “\n” + totalJVMMemory + “\n” + javaVersion + “\n” + diskFreeSpace + “\n” + diskTotalSpace + “\n” + IP + “\n” + hostName + “\n” + processorIdentifier + “\n” + processorArchitecture;

return systemConfiguration;
}

Put the above code in the code template library and call this function anywhere either in transformer or connector or  anywhere.

logger.debug(fetchSystemConfigurations());

The output of the code will be as follows:

Available Processors : 4
Free Memory : 116MB
OS Name : Windows 10
Maximum Memory : 228MB
Total JVM Memory : 201MB
Java Version : 1.8.0_151
Disck Free Space : 415GB
Total Disk Space : 465GB
IP : 192.168.0.18
Host Name : VIBV-BLR-02
Processor Identifier : Intel64 Family 6 Model 142 Stepping 9, GenuineIntel
Processor Architecture : AMD64

Happy Integration ………!!!!!!!!

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

 

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.

 

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 ↑