Programs to Upload Xml Health Record to Healthvault

Get full admission to Enabling Programmable Self with HealthVault and 60K+ other titles, with free 10-day trial of O'Reilly.

In that location's also alive online events, interactive content, certification prep materials, and more.

Affiliate iv. Using the HealthVault Data Ecosystem for Cocky-Tracking

"Information is a precious matter and volition last longer than the systems themselves."

—

The Quantified Self (http://quantifiedself.com/about/) customs enables cocky-knowledge through self-tracking. Self-tracking, when powered by appropriate data assay, has been proven to trigger behavioral change. The human activity of self-tracking creates awareness and feedback. The hunger for, and success of, cocky-knowledge is evident from the growing number of self-quantifiers (currently vi,000+ in 41 cities and fourteen countries).

Self-cognition is possible only with a substantial collection of data about oneself. HealthVault provides more 80 granular information types that enable tracking data regarding everything from daily exercise to genome sequences. In this chapter, we will build upon the understanding of the HealthVault API covered in Chapter three and extend it to develop a information-intensive self-quantifying application. Through the Quantified Cocky application, nosotros will gain an understanding of HealthVault information types and application evolution.

A Cocky-Experimentation Application

In Chapter 1 we analyzed weight data, and in Chapter 2 nosotros worked with sleep information and correlated information technology with practise. HealthVault offers a data type for tracking emotional state and daily dietary intake equally well. Allow's consider edifice a simple Quantified Self utility that helps a user go along track of his emotional state, daily dietary intake, weight, sleep, and exercise. Tracking these types of data and their relation to each other would allow our user to class and show interesting hypotheses such as: "I'g happier if I sleep well, and I sleep well if I potable less alcohol and exercise sufficiently."

Self-tracking fosters awareness and a feedback loop; numerous participants in the Quantified Self movement have attributed comeback to insights generated past the data and the act of data collection. Our Quantified Self application will aim to emulate this pattern. Figure 4-1 summarizes the data blueprint we wish to capture.

Figure four-1. Data dashboard for Quantified Cocky application

Setting Up a New HealthVault Application

Let's start by making a Quantified Self application with a unique application identifier. In this chapter we will use the HealthVault .NET SDK in order to focus on understanding the HealthVault data types. Nevertheless, every bit HealthVault SDK and Open Source Libraries outlines, you can use other languages and HealthVault libraries as well.

The first step in creating the application is to download and install the HealthVault SDK from MSDN (http://msdn.microsoft.com/en-the states/healthvault). After installing the SDK, you will observe a utility chosen Application Director. From the Windows First button, this utility can be accessed through All Programs→Microsoft HealthVault→SDK→HealthVault Application Manager.

Figure iv-ii. Using Awarding Manager to create a new HealthVault application

In one case you open the Application Manager, yous will find the Create New Application button, which you lot should utilise at present to create a new application. Every bit Effigy 4-two shows, the new application creation process asks you for an awarding name and other details, and creates a Visual Studio solution with the application starting point.

The 2nd footstep in the process is to register your awarding. Application Director automatically opens a new browser window that signs yous into the HealthVault Application Configuration utility (https://config.healthvault.com) and creates the appropriate application in the HealthVault Development environment. The development environs is frequently referred to as PPE, which stands for preproduction surround. In the next chapter we will acquire how the Awarding Configuration Center tin can exist used to create a development application without using the Application Managing director.

On the dashboard of the HealthVault Application Configuration Center, you will see the application yous just created, as depicted in Effigy 4-3.

Figure iv-3. HealthVault Application Configuration Middle showing the awarding that was created

Calculation Data Types

HealthVault offers more than 80 granular items to which a user can qualify access. They fall into categories such every bit fettle, status, medications, health history, measurements, personal contour, files, and custom information. A developer can obtain access for particular health information items by configuring an application's authorization rule set. For our awarding, we need access to weight, slumber, and exercise data, which come directly from various devices. Nosotros also want the user to exist able to track emotional state and daily dietary intake, which is information that she volition enter manually.

To starting time the necessary configuration, click on the application ID in the HealthVault Application Configuration Centre. Figure 4-four illustrates the view of our Quantified Cocky awarding after clicking on the "Online rules" tab. In this carte, select the appropriate information types for the application (weight measurement, sleep, exercise, etc.), select all permissions (read, write, update, delete), provide a reason why the awarding needs access to these types, and proper name the dominion. A dominion tin also be configured every bit optional and can have brandish settings. Why String, Is Optional, and Display Flags items are currently not active for well-nigh HealthVault applications.

Figure 4-4. Configuring online rules for an application

We are using HealthVault as the user hallmark provider for our application, and then we choose to operate in the online mode and create an authorization dominion for such admission. If we wanted our awarding to work through a backend system provided by 1 of the other types of architecture discussed in Chapter three, we would configure the offline rules for access to appropriate data types.

We are finished selecting the advisable information types for our application, and tin at present endeavor accessing them through the awarding.

Accessing the Information Types

The awarding director utility creates a template application. Figure four-5 shows the initial solution created by this utility.

Figure four-5. Solution created by the awarding managing director

The solution makes certain that your application is configured properly with an appropriate awarding ID, points it to the appropriate HealthVault platform and shell development environments, and configures the application'south redirect URL; all of these configurations live in the Web.Config file. The Default.aspx folio is derived from the HealthServicePage and handles authorisation with the HealthVault Platform, whereas the Redirect.aspx folio is derived from the HealthServiceActionPage and handles authentication and interaction with HealthVault Shell. The bin folder contains HealthVault SDK libraries: Microsoft.Health.dll , which encapsulates the cadre HealthVault functionality; Microsoft.Health.Spider web.dll , which broadly encapsulates browser interaction; and Microsoft.Health.Itemtypes , which encapsulates an object model for all HealthVault data types.

The main solution doesn't add a master page. In guild to arrive like shooting fish in a barrel to extend functionality, we create a MasterPage named QuantifiedSelf.master , create a fresh Default.aspx page subsequently deleting the old one, and ensure this page is derived from HealthServicePage .

As discussed in Chapter three, we can use the HealthVault GetThings API to admission health items in a user'south health record. The code shown in Example 4-ane accesses Emotion, DietaryDailyIntake, Weight, Sleep, and Exercise from HealthVault. As shown in the two lines at , we make sure to fetch these elements for the last vii days only.

Example 4-i. GetThings telephone call to access multiple things

                    protected void Page_Load(object sender, EventArgs e)     {         Lbl_UserName.Text = this.PersonInfo.SelectedRecord.DisplayName;          HealthRecordSearcher searcher = PersonInfo.SelectedRecord.CreateSearcher();         HealthRecordFilter filter = new HealthRecordFilter(             ApplicationSpecific.TypeId,             Emotion.TypeId,             DietaryDailyIntake.TypeId,                        Weight.TypeId,             SleepJournalAM.TypeId,             Exercise.TypeId);          filter.EffectiveDateMin = DateTime.Now.Subtract(new TimeSpan(vii, 0, 0, 0));                                        searcher.Filters.Add(filter);                  HealthRecordItemCollection items = searcher.GetMatchingItems()[0];

Before we display these types, let's dig deeper to sympathize a HealthVault data blazon.

Understanding HealthVault Data Types

A comprehensive list of all HealthVault data types is available from the HealthVault developer centre at http://developer.healthvault.com/types/types.aspx. Each type has backdrop that determine to a keen extent how items are created and used. To understand a blazon better, let'south take a deeper look at the example of the Weight Measurement type.

Type Properties

Effigy four-6 shows the properties of the Weight Measurement information blazon that are common to every data type from the HealthVault developer eye (http://developer.healthvault.com/types/type.aspx?id=3d34d87e-7fc1-4153-800f-f56592cb0d17). Each HealthVault type has a unique identifier; this id is used by the HealthVault APIs to identify the type. In the example of Weight, it is 3d34d87e-7fc1-4153-800f-f56592cb0d17. A type sets the uncreateable property to truthful if no application can create such a type in a user'south HealthVault record; a proficient example of this is the Basic type. The immutable property is true if no application tin modify or update an instance of that type in the user's HealthVault record; a skilful example of this is the CCR blazon. The belongings singleton is truthful if simply one instance of that blazon can exist in a user's HealthVault record; a good example of this is the Basic Demographic type.

Figure iv-6. Backdrop of the Weight Measurement type

Type transforms

Additionally, the listing of transforms is a property associated with the type. Transforms are built-in XSLT transformations bachelor for a detail matter type. These transforms allow y'all convert the XML associated with a particular type to various formats, such as HTML, to a representation uniform with various pop health care standards, or to an older or newer version of the same type.

Form, STT, and MTT transforms

Common among all the types are the class, stt, and mtt transforms. form provides an HTML table representation of an instance of the unabridged thing. stt, which stands for "single blazon transform," provides a row- based representation of the type then that information technology can be viewed as a list of instances of the same type. mtt, or "multiple type transform," provides a row-based representation of the type so that information technology can exist combined and viewed with multiple HealthVault types. Each row in mtt has a summary attribute representing the details of the type. The main divergence between stt and mtt is that stt has an XML attribute for each meaningful data element of the type, whereas mtt summarizes all the meaningful data elements in one cord in the summary attribute.

One can use the HealthVault PowerShell plug-in to view each source of the transforms. Example 4-2 shows how to salve the form transform for the Weight thing blazon.

Case 4-ii. Saving the class XSLT transformation for Weight thing types to a file

PS \> (Go-ThingType 3d34d87e-7fc1-4153-800f-f56592cb0d17).TransformSource["form"] | out-file Weight.xsl

The columns on the type definition page in the HealthVault Type Explorer define the column header, .NET data type, and width for each column. It'southward handy to view this data about the type in a data grid.

Instance 4-3 shows the multitype table transformation XML returned by the HealthVault platform for the Weight blazon. Nosotros tin see the columns ranging from wc-id (type identification) to summary (summary data of the type).

Case iv-3. Weight mtt XML for the Weight blazon

<data-xml transform="mtt">   <row wc-id="34655fb4-a6c8-4d47-85f1-dbc6e09b952a"     wc-version="0f57073a-0795-4867-9c9f-bcb99d2fa681" wc-annotation="" wc-tags=""     wc-appointment="2011-12-23 eleven:17:47" wc-type="Weight Measurement"     wc-typeid="3d34d87e-7fc1-4153-800f-f56592cb0d17" wc-source="" wc-brands=""    wc-issigned="imitation" wc-flags="" wc-ispersonal="imitation" wc-isdownversioned="false"     wc-isupversioned="false" wc-relatedthings="" wc-state="Active" summary="173 lbs" /> </data-xml>

In our Quantified Cocky awarding, we tin use the mtt transform to easily display multiple types in the same table for self-analysis. In Instance iv-four, Lines – construct and fetch our query from HealthVault; notation that in Line we ask the HealthVault platform to apply the mtt transform on the returned items. In Line , we select the row for each data-xml mtt transform. We and so brandish the wc-date, wc-type, and summary columns (Lines –). Dissimilar applications can choose to show different columns. Individual type columns, such as weight for Weight, are available in unmarried type transform (stt), whereas a summary column summarizes this information in mtt. The HealthDataItemGrid control is also available from the HealthVault .Net SDK to show this data automatically.

Example 4-4. Viewing multiple HealthVault types in a information grid

                        protected void Btn_ShowWeeklyReadingsTextSummary_Click         (object sender, Arrangement.EventArgs e)     {         HealthRecordSearcher searcher = PersonInfo.SelectedRecord.CreateSearcher();                                                HealthRecordFilter filter = new HealthRecordFilter(             Emotion.TypeId,             DietaryDailyIntake.TypeId,             Weight.TypeId,             SleepJournalAM.TypeId,             Practise.TypeId);          filter.EffectiveDateMin = DateTime.At present.Subtract(new TimeSpan(vii, 0, 0, 0));         searcher.Filters.Add(filter);         filter.View.TransformsToApply.Add("mtt");                                                HealthRecordItemCollection items = searcher.GetMatchingItems()[0];                                                DataTable dataTable = new DataTable();         dataTable.Columns.Add together(new DataColumn("Date", typeof(string)));         dataTable.Columns.Add(new DataColumn("Type", typeof(string)));         dataTable.Columns.Add together(new DataColumn("Summary", typeof(string)));         foreach (HealthRecordItem item in items)         {             XmlNode mttDocument = detail.TransformedXmlData["mtt"]                                                .SelectSingleNode("data-xml/row");             DataRow row = dataTable.NewRow();             row["Date"] = mttDocument.Attributes["wc-date"].Value;                                                row["Type"] = mttDocument.Attributes["wc-type"].Value;             row["Summary"] = mttDocument.Attributes["summary"].Value;             dataTable.Rows.Add(row);                                                }          Grid_ReadingsTextSummary.DataSource = dataTable;         Grid_ReadingsTextSummary.DataBind();         Grid_ReadingsTextSummary.Visible = true;     }

Once nosotros have the data grid configured, we can view the summary of all types in the aforementioned column structure. Effigy 4-seven shows how this information is displayed in our Quantified Cocky application.

Effigy 4-vii. Quantified Self application showing multiple types in a data filigree

Annotation

The CCR HealthVault type (1e1ccbfc-a55d-4d91-8940-fa2fbf73c195) has a tohv transform that converts the information in that blazon to individual HealthVault elements.

In addition to the use of transforms to convert types to dissimilar representations, the HealthVault method schema provides a <final-xsl> chemical element in each method header. final-xsl converts the data returned by the method call to congenital-in transforms, such as converting to CCR (toccr), CCD (toccd), CSV (tocsv), or RSS (torss). final-xsl also allows the caller to specify a custom-built XSLT transform that the HealthVault platform runs on the output earlier sending it to the requester.

The final-xsl chemical element is specified between the <country> and <msg-time> elements in the header of a method. In the HealthVault .NET SDK, 1 can telephone call this functionality past using the GetTransformedItems method. In the Coffee .Net Open up Source library, this functionality can exist used through a telephone call to request.setFinalXsl(" transform name or transform source ").

Versioning transforms

HealthVault information types tin can have multiple versions. As the HealthVault ecosystem matures, existing types need to be updated or modified to lucifer new use cases. Medications, Bones Demographic Information, and Family History are good examples of types that have multiple versions. You lot will notice that the older Medication datatype (which is available at http://developer.healthvault.com/pages/types/type.aspx?id=5c5f1223-f63c-4464-870c-3e36ba471def) has an up-version transform, and the newer Medication datatype (http://developer.healthvault.com/pages/types/type.aspx?id=30cafccc-047d-4288-94ef-643571f7919d) has a down-version transform. Through these transforms, HealthVault provides an easy way to move information betwixt an older and newer version of a data type.

Notation

Versioning of data types is unique to HealthVault amid personal wellness data platforms. Personal health records are meant to be over a lifetime, and this characteristic makes moves seamless from older health items to newer health items.

Other transforms

Transform names containing wpd and hvcc enable the HealthVault Connection Center to catechumen Windows Portable Device Data to and from HealthVault XML.

Type Schemas

Now that nosotros understand the high-level properties associated with a blazon and accept used the MTT brandish transform to testify the summary of all information types in our application, let's take a closer expect at what is entailed in a type's schema, with the specific goal of displaying advisable values for the Weight type.

Weight is a simple type that scales, and applications tin can write to or read from it. The XML schema and associated sample representation for this blazon are shown in Example four-v.

Instance four-5. XML and schema representation of the HealthVault Weight type

Column1: <schema xmlns:weight="urn:com.microsoft.wc.affair.weight"      xmlns:t="urn:com.microsoft.wc.thing.types" xmlns:d="urn:com.microsoft.wc.dates"     xmlns="http://www.w3.org/2001/XMLSchema"      targetNamespace="urn:com.microsoft.wc.thing.weight">   <import namespace="urn:com.microsoft.wc.thing.types" schemaLocation="base of operations.xsd" />   <import namespace="urn:com.microsoft.wc.dates" schemaLocation="dates.xsd" />   <element name="weight">     <complexType>       <sequence>         <chemical element proper name="when" minOccurs="i" maxOccurs="1" type="d:appointment-time">         </element>         <chemical element proper noun="value" minOccurs="1" maxOccurs="1" type="t:weight-value">         </chemical element>       </sequence>     </complexType>   </chemical element> </schema>  Column2: <data-xml>   <weight>     <when>       <date>         <y>1990</y>         <m>ane</m>         <d>1</d>       </date>      <time>         <h>i</h>         <m>0</m>         <south>0</south>         <f>0</f>       </time>     </when>     <value>       <kg>60</kg>       <display units="lb">132</display>     </value>   </weight>   <common/> </data-xml>

The Weight type consists of a sequence of date/time and weight values. The utilise of appointment/time in HealthVault is divers in the dates.xsd schema file (https://platform.healthvault-ppe.com/platform/XSD/dates.xsd), and the weight values are divers in the types.xsd schema file (https://platform.healthvault-ppe.com/platform/XSD/types.xsd).

The HealthVault .NET Web SDK encapsulates a squeamish object model on height of this XML and gives a user access to Value and When fields, as shown in Effigy 4-eight.

Figure 4-8. Backdrop in the HealthVault .Internet SDK for the Weight class

Units and measurements

Note that the Value field of this blazon contains display and units data. HealthVault stores the underlying measurement in kilograms, but the awarding tin show it to the user in the same grade in which information technology was entered. In our instance Quantified Self application, we ask the user to input values in pounds. Example four-half dozen shows how nosotros convert this value to kilograms for storage while displaying information technology to the user as pounds (lbs).

Example four-6. Creating a new Weight value

Dates

The When field or date is a special type chosen HealthServiceDateTime. Equally Line in Example iv-vi shows, an case of this appointment can be created by using the System DateTime. HealthVault enables a user to enter varying degrees of date precisions, hence it has a custom appointment/time.

In fact, the HealthVault guess datetime construct allows you lot to create a appointment as flexible as "when I was a child" or "Jan 2011" or "Dec". All the dissimilar kinds of HealthVault dates are defined in dates.xsd, available at https://platform.healthvault-ppe.com/platform/XSD/dates.xsd.

Note

One of the core HealthVault design tenets is to ingest all kinds of data. Flexible dates enable a user to enter unstructured data. Furthermore, constructs such as approx-appointment-fourth dimension allow HealthVault to receive data from standards such as CCR or CCD.

Common data

All types share some common data elements. In Line of Example iv-six, nosotros are writing to the common data element that shows the source of the application.

Other commonly used information elements are notes, tags, and related items.

Terminologies

HealthVault provides an extensible machinery to specify strings coded for use across various systems through codable-value. The codable-value consists of text associated with the lawmaking, which is represented in a structured format called coded-value.

Terminologies are used in a HealthVault data element called codable. This element provides a structured style to correspond semantically meaningful text.

Case 4-7 shows a codable-value schema. The family data field of coded-value specifies whether the lawmaking belongs to particular code system; for instance, wc refers to the HealthVault code arrangement, and HL7 refers to a arrangement adopted by Wellness Language vii.

Example four-7. codable-value schema

<complexType name="codable-value">   <sequence>     <element name="text" blazon="cord">     </chemical element>     <chemical element name="code" type="this:coded-value" minOccurs="0" maxOccurs="unbounded">     </element>   </sequence> </complexType><complexType name="coded-value">   <sequence>     <chemical element name="value" type="string">     </element>     <element proper noun="family unit" type="string" minOccurs="0">     </element>     <chemical element name="blazon" type="cord">     </element>     <chemical element name="version" type="string" minOccurs="0">     </chemical element>   </sequence> </complexType>

HealthVault has more than 150 terminologies. The wiki http://partners.mshealthcommunity.com/hv_eco/w/wiki/preferred-vocabularies.aspx describes how these terminologies are used by the HealthVault user interface, and the volume Meaningful Use and Beyond (Fred Trotter and David Uhlman, O'Reilly) describes how meaningful use, as proposed by federal regulations, dictates the utilise of these terminologies.

Example 4-8 shows how 1 tin can read the Exercise information type for showing calories burned. The Exercise data type stores various kinds of attributes in key value pairs. These attributes are listed in the ExerciseDetail terminology. As Example 4-viii shows, i can use the lawmaking value of CaloriesBurned from the ExerciseDetail terminology to look up the appropriate value and display it in the user interface.

Example iv-8. List calories burned in the DisplayExercise function

                      private void DisplayExercise(Listing<Exercise> exercises)     {         DataTable exercise = new DataTable("exercise");         exercise.Columns.Add together(new DataColumn("Date"));         exercise.Columns.Add(new DataColumn("ExerciseType"));         exercise.Columns.Add together(new DataColumn("CaloriesBurned"));         foreach (Exercise e in exercises)         {             DataRow row = exercise.NewRow();             row["Date"] = east.EffectiveDate.ToShortDateString().ToString();             row["ExerciseType"] = e.Activity.Text;             if (e.Details.ContainsKey(ExerciseDetail.CaloriesBurned_calories))             {                 row["CaloriesBurned"] = e.Details[ExerciseDetail.CaloriesBurned_calories];             }             exercise.Rows.Add(row);         }         ExerciseView.DataSource = practise;         ExerciseView.DataBind();     }

Extending HealthVault Information Types

Applications oftentimes have to stand for something that is non encapsulated by the data construction of the HealthVault data types. Out of the box, HealthVault provides a mechanism by which a information type can be extended.

Every application tin cull to write XML information in the extension tag within the common information department of a data type. It is recommended that applications distinguish their extension elements by using a unique source attribute on the extension element.

In our example, permit's assume we are extending the daily dietary intake blazon to add data on alcohol consumption.

Creating a Type Extension

We would similar to track the corporeality of booze consumed in a simple chemical element called "alcoholic-drinks". To simplify things farther, we presume this element represents the number of alcoholic drinks including wine, beer, cocktails etc., and is normalized to mean boilerplate alcohol per unit.

The first step is to write an alcoholic-drinks XML element inside the extension tag using a unique source (_appDailyAlcoholExtensionName) in the extension chemical element. Lines – in Instance iv-9 show how 1 can practise it in the .NET SDK.

Example 4-ix. Creating a blazon extension

Consuming a Type Extension

The second step is to read information from the extension. In our application, the user enters alcoholic beverage information through a text box associated with the Daily Dietary intake section, as shown in Figure 4-9.

Figure 4-nine. Input department for Daily Dietary Intake

Lines – in Example iv-x show how one tin can read <alcoholic-drinks> XML. To parse this information we apply XPath, and in the data type document, the element of interest resides at extension/alcoholic-drinks. Using the .NET XPathNavigator course, we select a single annotation signifying this value (Lines –). Line fetches the note associated with this case of daily dietary intake. The user can potentially input clarifying information—for example, "drank 3 tequila shots"—in this element.

Case 4-10. Consuming a type extension

Applications may choose to combine and formalize the two steps just shown and create an extension form, which then could be registered with HealthVault SDK so that every time the extend type is accessed by the awarding, the appropriate extension properties are available.

Creating Custom Types

Extending a HealthVault data blazon might non always solve your information needs. Many times there are legitimate use cases for which the application needs a unique data repository. For example, in our Quantified Self awarding, we demand a repository to store all of the user's self-experiments.

HealthVault provides a machinery chosen an awarding-specific blazon for this purpose. This type is not shareable with other applications. Once application developers find a broader use for their data, they can work with Microsoft to create a first-class data type for their needs.

Example iv-eleven shows how one tin utilize an application-specific blazon to store self-experiment hypotheses for the Quantified Self application. In our application we are asking a user to create a hypothesis using a uncomplicated text box. The value of this text box is read as the hypothesis string in Line . In Lines –, we create an XML certificate with the data for this specific type and then add together information technology to the certificate using Application Specific Xml in Line . Each application-specific type requires a SubtypeTag and Description (Lines –). We likewise specify the application creating this type in Line . Additionally, nosotros use the common note element to capture the condition of the type in Line , and the When element captures the date.

Example four-xi. Writing an application-specific custom type

On the other hand, we can show the list of self-experiments by reading the ApplicationSpecificXml using an XPath navigator. In Example 4-12, note that in Lines –, we assume that the document for this type contains only one element and that the offset node is the hypothesis.

Example 4-12. Reading an application-specific type

Trusting Data in HealthVault Data Types

Knowing the origin of data is often critical for an awarding that is using it for sensitive purposes. Some use cases warrant working with only trusted data, some warrant knowing whether the data is from a device or self-entered by the users, and in some cases the awarding might only want to work with known data providers.

HealthVault provides several ways to await at data provenance. Applications can look at the created_by and updated_by fields of a data type and come across whether they were updated by devices or known applications. Additionally, HealthVault provides digital signing of data, which tin create a very secure ecosystem of trust.

In our instance, we look at the Source attribute of Weight items to meet whether they were uploaded past a Withings scale or added manually past the user.

Relating HealthVault Data Types

HealthVault data types are intended to exist self-contained units of health information. The data types take singled-out wellness items, such as medications, immunizations, and weight readings. This approach is characteristically different from relational data modeling in which the data is normalized and stored in singled-out tables that take explicit relationships with each other. For case, in a relational model, medications may be expressed as separate medication proper name and medication dosage tables.

Often there is a need to correspond relationships between individual health items. For example, a Medication is inherently related to Medication Fill. Medications are associated with a person'southward profile as prescribed by a physician, and Medication Fill is used by a pharmacy to prescribe units of medications to a consumer every bit she consumes the prescribed medications.

The relationship betwixt Medication and Medication Fill is expressed by related items . HealthVault offers related items as an inherent mechanism to link and associate data types. A related item is a special chunk of XML that resides in the common data of a health detail. Relationships are usually described in the dependent item and link to the more independent one. For instance, to express the relationship betwixt Medication Fill up and Medication, one places related items in the Medication Make full type and points to the Medication type.

Another interesting use of related items is to link together a prepare of readings that are uploaded from a unmarried device. For example, a device computing body fat per centum and cholesterol can associate them through related items while uploading them. Because this association is washed earlier uploading to HealthVault, a special unique identifier chosen a customer ID can be used. Client IDs are usually unique identifiers associated to instances of HealthVault data types and are created by the client uploading the data.

1 can have relationships even farther and associate a set of medical images, medications, and weather condition as a result of a item health incident, maybe an accident. The Mayo Dispensary Wellness Director application provides a way to create a web of related HealthVault items.

Related items lie beyond the scope of this book, but the reader is encouraged to explore them and contribute interesting uses and examples at http://enablingprogrammableself.com.

Exploring HealthVault Information Types

In our example, nosotros picked some HealthVault types to be used in the application based on our device, data availability, and purpose. Every application developer needs to go through this data exploration based on your needs and goals. This section gives an overview of all HealthVault types and then that the reader can have a skilful agreement of what is available in the system.

Categorizing HealthVault Data Types

HealthVault stores personal health information ranging from fitness data to medical images. Table four-1 shows the categorization of the data equally displayed to the end user.

Table 4-1. Terminate user categorization of HealthVault information

Category	HealthVault types
Fettle	Aerobic Exercise Session, Aerobic Profile, Aerobic Weekly Goal, Calorie Guideline, Daily Dietary Intake, Exercise, Exercise Samples, Weight Goal
Weather condition	Allergy, Concern, Condition, Contraindication, Emotional State, Pregnancy, Problem, Respiratory Profile
Medications	Asthma Inhaler, Asthma Inhaler Use, Daily Medication Usage, Insulin Injection, Insulin Injection Utilize, Medication, Medication Make full
Health History	Allergic Episode, Note, Cardiac Profile, Diabetic Contour, Belch Summary, Encounter, Caption of Benefits, Family unit History, Family unit History Condition, Family History Person, Health Assessment, Immunization, Process, Question Reply
Measurements	Blood Glucose, Claret Oxygen Saturation, Blood Pressure level, Torso Composition, Trunk Dimension, Cholesterol Profile, Device, Genetic SNP Results, HbA1C, Centre Rate, Height, Lab Test Results, Microbiology Lab Results, PAP Session, Peak Flow, Radiology Lab Results, Sleep Journal AM, Sleep Journal PM, Spirometer, Vital Signs, Weight
Personal Profile	Accelerate Directive, Date, Basic, Contact, Healthcare Proxy, Life Goal, Payer, Person (emergency or provider contact), Personal Demographic Data, Personal Image
Files	Clinical Document Architecture (CDA), Continuity of Care Document (CCD), Continuity of Care Tape (CCR), File, Medical Image Study, Countersign-Protected Package
Custom Data	Application Data Reference, Application Specific, Group Membership, Grouping Membership Activity, Link, Status

Fitness

HealthVault offers a range of fitness types. The near ordinarily used fitness information type is Exercise. Exercise provides a terminology-based categorization of kinds of exercise, e.g., walking or running. Each activity can also be associated with terminology-driven units: Count, Mile, etc.

Devices such equally FitBit and Withings piece of work with this type. The exercise activities terminology lists a range of practise values, including running, walking, swimming, etc. Devices that fetch detailed information on do tin can write individual samples to the Exercise Sample type. For instance, exercise watches developed by Polar write to exercise samples in addition to summarizing the workout in the Exercise blazon.

This category of types is implemented in a fairly generic mode so that various industry formats, such every bit the ane used by Garmin's Connect website (http://connect.garmin.com/), can interpret easily to these types. ISO units can too be translated easily to HealthVault units.

Conditions

Health problems, allergies, contra-indications, and mental health (emotional state) are categorized in the Condition set of types. Conditions are sensitive health problems that usually have an onset date and a status associated with them.

The HealthVault Shell uses the Condition type to record conditions. Conditions entered through the user interface are mapped to SNOMED-CT terminology.

Medication

Medications are the center of modernistic medicine. HealthVault offers a number of granular types to capture the essence of medications.

A number of pharmacies, including CVS and Walgreens, offering applications for importing prescription data into HealthVault, but the user interface and integration for these applications is a flake challenging.

The most frequently used data types in this category are Medication and Medication Fill. Each prescription could be broken into Medication and Medication Make full. Medication Fill up is the recurring part of ane's prescription. As you may recall from Relating HealthVault Data Types, the Medication Fill type is usually related to Medication using the related-item semantics when entered through the HealthVault Shell.

Medications are mapped or coded to the RxNorm Active Medicines terminology.

Health History

Immunizations, procedures, family history, wellness events, etc. class the basis of the Health History category.

The most notable application using types in this category is the Surgeon General'southward Family History application (https://familyhistory.hhs.gov/fhh-web). This powerful application enables individuals to hands create a family health history tree.

Measurements

Measurements are the most all-encompassing category of HealthVault data types. Measurements range from the output of various fitness devices to lab results. For example, the Withings weighing scale writes to the weight measures, and FitBit writes to sleep measures. The measures are granular records of daily activity and consequently are traceable.

On the other hand, the Lab Test Results type, one of the most complicated HealthVault types, represents results from labs. It can be used in conjunction with manufacture-standard terminologies.

Personal Contour

The Personal Profile category of HealthVault types contains data pertaining to health care proxies, personal images, and demographics. Near every HealthVault awarding that shows a user'southward picture or looks at ages or other demographic information uses types in this category.

Files

HealthVault, different well-nigh personal health records, allows you to upload a number of types of files, and therefore supports data types for these files. Example 4-14 shows the file extensions supported, displayed through a GetServiceDefinition call in PowerShell. This information can too exist viewed online in the HealthVault Programmer Center's service definition section (http://developer.healthvault.com/pages/methods/methods.aspx).

Case 4-xiv. List of file extensions supported by HealthVault

PS C:\Windows\system32> $a = Get-ServiceDefinition PS C:\Windows\system32> $a.ConfigurationValues  Central                                   Value ---                                   ----- allowedDocumentExtensions             .avi,.bluebutton,.bmp,.ccd,.ccr,.cda,.doc,.docm,... autoReconcilableTypes                 1e1ccbfc-a55d-4d91-8940-fa2fbf73c195,9c48a2b8-... blobHashBlockSizeBytes                2097152 blobHashDefaultAlgorithm              SHA256Block blobStreamWriteTokenTtlMs             172800000 defaultCulture                        en defaultPersonInfosPerRetrieval        200 emailValidationExp                    ^([\w-+\.]+)@((\[[0-9]{i,3}\.[0-9]{1,iii}\.[0-9]... liveIdAuthPolicy                      HBI liveIdEnvironment                     PROD <... clipped for brevity..>

The Medical Image study blazon used by the HealthVault Connexion Center uploads DICOM medical images in this type. The CCD/CCR types are industry-standard ways by which various hospital data systems send care records to HealthVault. Google Health users, for instance, migrated to HealthVault using the CCR type. The Bulletin file blazon is the courage of HealthVault's Direct integration. Whatever electronic mail bulletin received by the user is stored in the Message type.

Custom Data

The Application Specific type, already covered in the section Creating Custom Types with regard to adding a repository in which to store self-experiments, is the almost important custom data type. This type is used by various applications to store information in HealthVault for which no other blazon or extension to a type is appropriate. For instance, the Vivacity'south Spending Sentinel application (http://www.spendingscout.com/) stored explanation of do good information in this type until the HealthVault team created an Caption of Benefits (EOB) type to support it more directly.

Contributing to the Cocky-Experimentation Application

In adjacent chapter we will see how we can broaden the self-experimentation web awarding by creating mobile applications. The source for the awarding is available at http://enablingprogrammableself.com, and we are inviting y'all, honey reader, to extend this application and make it your own. Maybe fork the Git repository and contribute your code dorsum, or create Java, Scarlet, or Python versions of information technology!

Go Enabling Programmable Self with HealthVault now with O'Reilly online learning.

O'Reilly members feel alive online grooming, plus books, videos, and digital content from 200+ publishers.

parrinces1973.blogspot.com

Source: https://www.oreilly.com/library/view/enabling-programmable-self/9781449334574/ch04.html

Share this post