IHE MHD (Mobile Health Data) and FHIR

Just noticed John Moehrke’s post on the recent IHE MHD connectathon. I love the way that this shows how the different organizations involved in healthcare interoperability are working together rather than taking opposing views…

Clinician Connectathon

Well, we’ve just finished the second Clinician Connectathon. I wasn’t able to attend in person, but was able to dial in from home (New Zealand) to participate and it all worked out really well.

The tooling mostly behaved itself (we had a few server issues) – which was a relief!

We’ll do a more complete review later on, but for me the take away is that these events are really worth continuing (and the others seemed to agree with this), and that the tooling needs to continue to evolve – perhaps to move away from a strictly resource focussed perspective as it is now, to a more functional one. We also need to increase the range of resources, supported properties on those resources, save more stuff to FHIR servers & improve the way we support profiling. No pressure…

We’ll continue to work on this, and we’re encouraging people to try the tooling out between events so that bugs and be squashed, enhancements can be developed, deployed & tested prior to the actual event and we can maximize the value of getting clinical folk together to talk FHIR.

If you’re interested, the tool is available here, and I do encourage you to go have a look and give us feedback (you can do that in comments to this post for the moment- we’ll figure out a better way soon). We’ll also be working on the documentation…

So, on to Paris in May! (and I’m off for a sleep…)

FHIR Clinical Connectathon

I was going to write a post on the Clinical Connectathon that we held in Chicago at the Working Group Meeting the week before last (in fact, had just written the draft) but I see that Graham has just published a post covering the event, and a number of other FHIR related comments from the WGM, so I’ll just refer you there!

For myself, I think that the comment about the evolving FHIR community – moving from simply developing a standard to using that standard to solve ‘business’ problems is probably the most exciting for me – which is what the Clinical Connectathon was all about.

I also want to point out that there are (at least) 4 more FHIR related events in the next couple of months:

Plenty of opportunities to experience the hype for yourself!

SMART on FHIR – adding OAuth2

You may recall that a week back we had a look at one of the connectathon scenarios – the SMART scenario.

In this post we’re going to take the work that we had done in the last post, and make it secure using the SMART version of the OAuth2 standard. As always, a primary reason I’m writing it down is so that when I forget what I did to make it work – I’ll have this as a reference to remind me <s>. And a reminder – I’m using the Java based HAPI FHIR client, in a web based application running in a Tomcat servlet engine, with IntelliJ IDEA as my IDE.
Read more of this post

CORS in FHIR

The following is a copy of an email sent to the FHIR list by Peter Bernhardt (and copied with permission). I’ve not read through it in detail, but it’s something that I’m grappling with myself as I prepare for the SMART track in the up-coming Connectathon.

I suspect that it’s something that a lot of folk are going to have ‘fun’ with, so I suggested to Peter that we copy it here so it can be found later!

(btw – all the servers that Peter refers to are described in the spec)

  Read more of this post

SMART on FHIR: Part 1

With the 7th connectathon coming up, we’ve looked at the first scenario (Patient access) in a couple of posts and how we can use a couple of the libraries (.net and java) to make this almost trivial to achieve. (btw you don’t have to use these libraries of course – FHIR by itself uses standard technologies so there are a ton of different ways to do this if you already have the technology to do so, or use a different language).

In this post we’re going to take a look at the 3rd connectathon scenario – SMART on FHIR. There’s a lot of information about what this is trying to achieve (the connectathon site has links) so we won’t repeat that here – the ‘elevator pitch’ is that it establishes standards that enable the development of independent applications that can securely access data in any server supporting those standards – this could be an EHR, EMR, Portal or HIE.

Read more of this post

FHIR Connectathon 7 for Java Dummies

Last week we had a look at using the .net client to access a FHIR server as a lead up to the next connectathon. I thought it might be fun to do the same thing using the HAPI Java client (Now that it’s at release .5 – half way there!).

Now a disclaimer: I am not a Java developer – in fact I’m learning Java doing this work. In some ways I’d rather be in the .net world, but I’m a Mac user, and .net plays uneasily on that platform, so Java it is. (Yes, I know there’s Mono – it just doesn’t work for me for some reason).

Read more of this post

Clinical Scenarios in FHIR: Adverse reaction

The final scenario that is a candidate for the clinical connectathon is one that deals with allergies and Intolerance. Here are the details, but at a high level:

  • A patient is prescribed penicillin and 8 days into the course develops symptoms that are diagnosed as an allergy to penicillin, which is recorded in their allergy list, along with details of the nature of the allergy.
  • In addition, the patient (through a patient portal) updates their allergy list – adding an entry that is subsequently updated (or reconciled) by the clinician.

Read more of this post

Clinical Scenarios in FHIR

As you know (or should by now!), FHIR has from the outset been an implementer driven standard. The focus has always been on making healthcare interoperability as straightforward as possible, and regular connecathons have been an important part of that process (and we’re up to our 7th now).

However, it has to be admitted that thus far it has been the ‘techies’ – the ‘geeks’ – that are the main attenders at connectathon – and that’s kind of inevitable, given all the base work that’s needed to make FHIR a realistic standard for exchanging health information.

But FHIR is all about exchanging clinical information, and that means that it has to meet the needs of clinicians (which I use in the widest sense) as well as the technical folk. (And patients too – though that is another story).

At the last Working Group Meeting in Phoenix, we decided that it was time to think about a ‘Clinical Connectathon’ – where the emphasis was on meeting the needs of clinicians delivering care rather than the needs of technical people supporting them – can FHIR  do that?

So, at this WGM in September (held in Chicago) we’re going to have our first Clinical Connectathon (as well as the usual one – sigh). The focus of this event is to allow clinicians to focus on the “clinician to clinician connection” rather then the underlying technical resources that support those interactions.
Read more of this post

Connectathon 7: A Dummies Guide

As Grahame has said, the planning for the 7th FHIR connectathon to be held at the September Working Group Meeting in Chicago is well under way. This time we’ve got 4 separate tracks (you can check the link for the details), but in this post let’s have a look at track 1 – the Patient track.

This is intended to be a simple track for those new to FHIR – a way to get your feet wet (so to speak) and show just how simple basic interoperability with FHIR really is. You do need to write some code, but given the tools available these days, that’s not hard to do, so the barrier to entry is pretty low (and remember, the FHIR test servers are always available so you can do the basic learning in the privacy of your own home before you come!)

Using FHIR is actually made even easier by using one of the freely available client libraries. There are a number of them, but the 2 most well known are the .net library (from Furore – one of the earliest companies to support FHIR) and a Java one from the HAPI team – who have had a well regarded library for HL7 version 2 for many years.

In this post I’m going to use the .net libraries – but the java one will work just as well – in fact the two libraries (not co-incidentally) share a common approach.

I’d like thank my colleague Peter Jordan from HL7 New Zealand  for the code snippets in this post – I’ve adapted them a bit so I’ll take responsibility for any errors!

You’ll probably want to start with a copy of Visual Studio Express (which is free), so down load the version that suits your purpose (ie whether you’re writing a web or a desktop application).

You’ll need to download the .net FHIR libraries – they are in github, but the easiest way to get them is by using NuGet and searching for the FHIR libraries there. (The github reference has more information including links to documentation and a NuGet reference)

Now, you can create a project in Visual Studio. (btw I’m not an expert in Visual Studio – and as I use a mac it’s a bit fiddly for me to use it so this is not a step by step guide – there are a ton of tutorials on the web so it should be easy to get more detailed instructions if you need them). An alternative you can use is Xamarin which does run on the Mac.

First you need to include references to the c# FHIR libraries (and a couple of others)

using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using Hl7.Fhir.Model;
using Hl7.Fhir.Rest;

In order to use the library, you first instantiate a new FhirClient object, passing in the base URL of the FHIR Server. Then, you can call the required methods on that library which will issue the required REST calls – and throwing exceptions when errors occur.

In the example below, the FhirClient is initialized against the Orion Health ‘Blaze’ server, and the Conformance resource read and saved to a file.

var client = new FhirClient(@&quot;https:/fhir.orionhealth.com/blaze/fhir/&quot;);
var confStat = client.Read&lt;Conformance&gt;(&quot;metadata&quot;);
string TestFile = &quot;c:\temp\&quot; + Guid.NewGuid().ToString() + &quot;.html&quot;;
File.WriteAllText(TestFile, confStat.Summary);

So how do you find a patient? Well…

var client = new FhirClient(@&quot;https:/fhir.orionhealth.com/blaze/fhir/&quot;);
List&lt;string&gt; searchCriteria = new List&lt;string&gt;();
searchCriteria.Add(&quot;name='eve'&quot;);
var bundle = client.Search&lt;Patient&gt;(searchCriteria.ToArray());
foreach (ResourceEntry entry in bundle.Entries) {
   // create a Patient Object from the Entry Resource
   Patient patient = (Patient)entry.Resource;
   // ... do something with patient, it's a c# object representing the patient resource ...
}

You want to create a new patient?

var client = new FhirClient(@&quot;https:/fhir.orionhealth.com/blaze/fhir/&quot;);
// create new Patient object
Patient newPat = new Patient();

// create identifier list item and add it to the new patient
Uri uri = new Uri(&quot;http://nhi.health.nz&quot;)
Identifier id = new Identifier { System = uri, Value = &quot;PRP1660&quot;, Label = &quot;NHI&quot; };
newPat.Identifier = new List&lt;Identifier&gt;();
newPat.Identifier.Add(id);

// create a human name list item and add it to the new patient
List&lt;string&gt; famName = new List&lt;string&gt;();
famName.Add(&quot;Jones&quot;);
List&lt;string&gt; givName = new List&lt;string&gt;();
givName.Add(&quot;Indianna&quot;);
HumanName hn = new HumanName { Family = famName, Given = givName };
newPat.Name = new List&lt;HumanName&gt;();
newPat.Name.Add(hn);

// add DOB and gender
newPat.BirthDate = &quot;1955-12-16&quot;;
newPat.Gender = new CodeableConcept { Text = &quot;M&quot; };
client.Create&lt;Patient&gt;(newPat);

So there you have it – that’s half of the scenario done for you! How hard can it be?

See you in Chicago…