/// <summary>
/// Creates a new HealthRecordSearcher for a list of specific types.
/// </summary>
///
/// <returns>
/// A <see cref="HealthRecordSearcher"/> that searches for items with specific type IDs
/// within this record.
/// </returns>
///
/// <remarks>
/// The method adds a filter to the <see cref="HealthRecordSearcher"/> that only returns
/// items of the specified type IDs. That filter may be accessed through the
/// returned searcher using searcher.Filters[0].
///
/// You can also call the <see cref="HealthRecordSearcher"/> constructor
/// directly and pass in a reference to this
/// <see cref="HealthRecordAccessor"/>.
/// </remarks>
///
/// <param name="typeIds">
/// A list of unique type ids to filter on.
/// </param>
///
public HealthRecordSearcher CreateSearcher(params Guid[] typeIds)
{
HealthRecordSearcher searcher = new HealthRecordSearcher(this);
HealthRecordFilter filter = new HealthRecordFilter(typeIds);
searcher.Filters.Add(filter);
return searcher;
}
/// <summary>
/// </summary>
///
/// <returns>
/// </returns>
///
/// <remarks>
/// This method accesses the HealthVault service across the network.
/// If the filters specified do not reduce the amount of data being retrieved from the
/// record, this method could take a significant amount of time as data gets paged into
/// memory from HealthVault.
///
/// Note: There may be data in items that HealthVault does not include when converting
/// to the CCR or CCD formats.
/// </remarks>
///
/// <exception cref="HealthServiceException">
/// The response from the server was anything but
/// <see cref="HealthServiceStatusCode.Ok"/>.
/// -or-
/// <see cref="Microsoft.Health.HealthRecordSearcher.Filters"/> is empty
/// or contains invalid filters.
/// </exception>
///
public string ExportItems()
{
HealthRecordSearcher searcher = new HealthRecordSearcher(_record);
for (int index = 0; index < Filters.Count; ++index)
{
searcher.Filters.Add(Filters[index]);
}
ReadOnlyCollection<HealthRecordItemCollection> results = searcher.GetMatchingItems();
StringBuilder resultXml = new StringBuilder(1000);
XmlWriterSettings settings = SDKHelper.XmlUnicodeWriterSettings;
settings.ConformanceLevel = ConformanceLevel.Document;
using (XmlWriter writer = XmlWriter.Create(resultXml, settings))
{
// <response>
writer.WriteStartElement("response");
// <wc:info>
writer.WriteStartElement("wc", "info", "urn:com.microsoft.wc.methods.response.GetThings3");
foreach (HealthRecordItemCollection items in results)
{
// <group>
writer.WriteStartElement("group");
// We are leveraging the HealthRecordItemCollection paging here to retrieve
// all the data from HealthVault if it doesn't come with the first request.
for (int itemIndex = 0; itemIndex < items.Count; ++itemIndex)
{
bool filterApproved = true;
foreach (HealthRecordClientFilterHandler filter in ClientFilters)
{
filterApproved = filter(items[itemIndex]);
if (!filterApproved)
{
break;
}
}
if (filterApproved)
{
items[itemIndex].WriteItemXml(writer, true, "thing");
}
}
// </group>
writer.WriteEndElement();
}
// </wc:info>
writer.WriteEndElement();
// </response>
writer.WriteEndElement();
writer.Flush();
writer.Close();
}
return TransformItemXml(resultXml.ToString());
}
/// <summary>
/// Gets the health record items that match the filters as specified by
/// the properties of this class.
/// </summary>
///
/// <param name="connection">
/// The connection to use to access the data.
/// </param>
///
/// <param name="accessor">
/// The record to use.
/// </param>
///
/// <param name="searcher">
/// The searcher that defines what items to return.
/// </param>
///
/// <returns>
/// An XPathNavigator representing the raw results of the search.
/// </returns>
///
/// <remarks>
/// This method accesses the HealthVault service across the network.
/// <br/><br/>
/// This method is typically used when the calling application wants to
/// handle the raw health record item XML directly instead of using the
/// object model.
/// </remarks>
///
public static XPathNavigator GetMatchingItemsRaw(
ApplicationConnection connection,
HealthRecordAccessor accessor,
HealthRecordSearcher searcher)
{
return HealthVaultPlatformItem.Current.GetMatchingItemsRaw(connection, accessor, searcher);
}
/// <summary>
/// Gets the health record items that match the filters as specified by
/// the properties of this class.
/// </summary>
///
/// <param name="connection">
/// The connection to use to access the data.
/// </param>
///
/// <param name="accessor">
/// The record to use.
/// </param>
///
/// <param name="searcher">
/// The searcher that defines what items to return.
/// </param>
///
/// <returns>
/// An XmlReader representing the raw results of the search.
/// </returns>
///
/// <remarks>
/// This method accesses the HealthVault service across the network.
/// <br/><br/>
/// This method is typically used when the calling application wants to
/// handle the raw health record item XML directly instead of using the
/// object model.
/// </remarks>
///
public static XmlReader GetMatchingItemsReader(
ApplicationConnection connection,
HealthRecordAccessor accessor,
HealthRecordSearcher searcher)
{
return HealthVaultPlatformItem.Current.GetMatchingItemsReader(connection, accessor, searcher);
}
/// <summary>
/// Creates a new open query using the specified
/// connection, definition, expiration time,
/// personal identification number (PIN), description, and XSL.
/// </summary>
///
/// <param name="connection">
/// An <see cref="ApplicationConnection"/> instance that creates the
/// new open query.
/// </param>
///
/// <param name="searcher">
/// A <see cref="HealthRecordSearcher"/> instance that defines the open query.
/// </param>
///
/// <param name="expires">
/// The number of minutes the query will expire from the creation time.
/// A value of Int32.MaxValue denotes that the query does not expire.
/// </param>
///
/// <param name="pinCode">
/// The PIN that protects the query.
/// </param>
///
/// <param name="note">
/// The note describing the query.
/// </param>
///
/// <param name="finalXsl">
/// The XSL that transforms the results of the query when the
/// <see cref="OpenQuery"/> is invoked.
/// </param>
///
/// <returns>
/// An <see cref="OpenQuery"/> instance that represents the newly created query.
/// </returns>
///
/// <remarks>
/// The creation of an open query makes public the data returned by that
/// query. However, the query URL must be known to retrieve the data.
/// </remarks>
///
/// <exception cref="ArgumentNullException">
/// The <paramref name="connection"/> or <paramref name="searcher"/>
/// parameter is <b>null</b>.
/// </exception>
///
///
/// <exception cref="ArgumentException">
/// The <paramref name="searcher"/> parameter contains no valid search
/// filters or the <paramref name="pinCode"/> parameter is <b>null</b>
/// or empty.
/// </exception>
///
/// <exception cref="HealthServiceException">
/// An error occurred when HealthVault processed the request.
/// </exception>
///
public static OpenQuery NewOpenQuery(
ApplicationConnection connection,
HealthRecordSearcher searcher,
int expires,
string pinCode,
string note,
string finalXsl)
{
return HealthVaultPlatformOpenQuery.Current.NewOpenQuery(
connection,
searcher,
expires,
pinCode,
note,
finalXsl);
}
/// <summary>
/// Gets the health record items that match the filters as specified by
/// the properties of this class.
/// </summary>
///
/// <param name="connection">
/// The connection to use to access the data.
/// </param>
///
/// <param name="accessor">
/// The record to use.
/// </param>
///
/// <param name="searcher">
/// The searcher that defines what items to return. .
/// </param>
///
/// <returns>
/// A collection of health record items that match the applied filters.
/// </returns>
///
/// <remarks>
/// This method accesses the HealthVault service across the network.
/// </remarks>
///
/// <exception cref="HealthServiceException">
/// The response from the server was anything but
/// <see cref="HealthServiceStatusCode.Ok"/>.
/// -or-
/// <see cref="Microsoft.Health.HealthRecordSearcher.Filters"/> is empty
/// or contains invalid filters.
/// </exception>
///
public static ReadOnlyCollection<HealthRecordItemCollection> GetMatchingItems(
ApplicationConnection connection,
HealthRecordAccessor accessor,
HealthRecordSearcher searcher)
{
return HealthVaultPlatformItem.Current.GetMatchingItems(connection, accessor, searcher);
}
/// <summary>
/// Gets the health record items specified by the
/// <see cref="HealthRecordSearcher"/> and runs them through the specified
/// transform.
/// </summary>
///
/// <param name="connection">
/// The connection to use to access the data.
/// </param>
///
/// <param name="accessor">
/// The record to use.
/// </param>
///
/// <param name="searcher">
/// The searcher that defines what items to return.
/// </param>
///
/// <param name="transform">
/// A URL to a transform to run on the resulting XML. This can be
/// a fully-qualified URL or the name of one of the standard XSLs
/// provided by the HealthVault system.
/// </param>
///
/// <returns>
/// The string resulting from performing the specified transform on
/// the XML representation of the items.
/// </returns>
///
/// <remarks>
/// This method accesses the HealthVault service across the network.
/// <br/><br/>
/// Any call to HealthVault may specify a transform to be run on the
/// response XML. The transform can be specified as a XSL fragment or
/// a well-known transform tag provided by the HealthVault service. If a
/// XSL fragment is specified, it gets compiled and cached on the server.
/// <br/>
/// <br/>
/// A final-xsl is useful when you want to convert the result from XML to
/// HTML so that you can display the result directly in a web page.
/// You may also use it to generate other data formats like CCR, CCD, CSV,
/// RSS, etc.
/// <br/>
/// <br/>
/// Transform fragments cannot contain embedded script. The following set
/// of parameters are passed to all final-xsl transforms:<br/>
/// <ul>
/// <li>currentDateTimeUtc - the date and time just before the transform
/// started executing</li>
/// <li>requestingApplicationName - the name of the application that
/// made the request to HealthVault.</li>
/// <li>countryCode - the ISO 3166 country code from the request.</li>
/// <li>languageCode - the ISO 639-1 language code from the request.</li>
/// <li>personName - the name of the person making the request.</li>
/// <li>recordName - if the request identified a HealthVault record to
/// be used, this parameter contains the name of that record.</li>
/// </ul>
/// </remarks>
///
/// <exception cref="ArgumentException">
/// The <paramref name="transform"/> parameter is <b>null</b> or empty.
/// </exception>
///
/// <exception cref="ArgumentException">
/// <see cref="Microsoft.Health.HealthRecordView.Sections"/> does not
/// contain the XML section in the view.
/// </exception>
///
/// <exception cref="HealthServiceException">
/// There is a failure retrieving the items.
/// -or-
/// No filters have been specified.
/// </exception>
///
public static string GetTransformedItems(
ApplicationConnection connection,
HealthRecordAccessor accessor,
HealthRecordSearcher searcher,
string transform)
{
return HealthVaultPlatformItem.Current.GetTransformedItems(connection, accessor, searcher, transform);
}
/// <summary>
/// Creates a new open query using the specified
/// <see cref="OfflineWebApplicationConnection"/>, definition, and personal
/// identification number (PIN).
/// </summary>
///
/// <param name="connection">
/// A connection instance that creates the new open query.
/// </param>
///
/// <param name="searcher">
/// A <see cref="HealthRecordSearcher"/> instance that defines the open query.
/// </param>
///
/// <param name="pinCode">
/// The PIN that protects the query.
/// </param>
///
/// <returns>
/// An <see cref="OpenQuery"/> instance that represents the newly created query.
/// </returns>
///
/// <remarks>
/// The creation of an open query makes public the data returned by that
/// query. However, the query URL must be known to retrieve the data.
/// </remarks>
///
/// <exception cref="ArgumentNullException">
/// The <paramref name="connection"/> or <paramref name="searcher"/>
/// parameter is <b>null</b>.
/// </exception>
///
/// <exception cref="ArgumentException">
/// The <paramref name="searcher"/> parameter contains no valid search
/// filters or the <paramref name="pinCode"/> parameter is <b>null</b>
/// or empty.
/// </exception>
///
/// <exception cref="HealthServiceException">
/// An error occurred when HealthVault processed the request.
/// </exception>
///
public static OpenQuery NewQuery(
OfflineWebApplicationConnection connection,
HealthRecordSearcher searcher,
string pinCode)
{
Validator.ThrowIfStringNullOrEmpty(pinCode, "pinCode");
return NewQuery(
connection,
searcher,
Int32.MaxValue,
pinCode,
String.Empty,
null);
}
/// <summary>
/// Creates a new open query using the specified
/// <see cref="OfflineWebApplicationConnection"/> and definition.
/// </summary>
///
/// <param name="connection">
/// An <see cref="OfflineWebApplicationConnection"/> instance that
/// creates the new open query.
/// </param>
///
/// <param name="searcher">
/// A <see cref="HealthRecordSearcher"/> instance that defines the open query.
/// </param>
///
/// <returns>
/// An <see cref="OpenQuery"/> instance that represents the newly created query.
/// </returns>
///
/// <remarks>
/// The creation of an open query makes public the data returned by that
/// query. However, the query URL must be known to retrieve the data.
/// </remarks>
///
/// <exception cref="ArgumentNullException">
/// The <paramref name="connection"/> parameter is <b>null</b>.
/// </exception>
///
/// <exception cref="ArgumentNullException">
/// The <paramref name="searcher"/> parameter is <b>null</b>.
/// </exception>
///
/// <exception cref="ArgumentException">
/// The <paramref name="searcher"/> parameter contains no valid
/// search filters.
/// </exception>
///
/// <exception cref="HealthServiceException">
/// An error occurred when HealthVault processed the request.
/// </exception>
///
public static OpenQuery NewQuery(
OfflineWebApplicationConnection connection,
HealthRecordSearcher searcher)
{
return NewQuery(
connection,
searcher,
Int32.MaxValue,
String.Empty,
String.Empty,
null);
}
/// <summary>
/// Creates a new open query using the specified
/// <see cref="AuthenticatedConnection"/> and definition.
/// </summary>
///
/// <param name="connection">
/// An <see cref="AuthenticatedConnection"/> instance that creates the new open query.
/// </param>
///
/// <param name="searcher">
/// A <see cref="HealthRecordSearcher"/> instance that defines the open query.
/// </param>
///
/// <returns>
/// An <see cref="OpenQuery"/> instance that represents the newly created query.
///
/// </returns>
///
/// <remarks>
/// The creation of an open query makes the data returned by that
/// query public. The only obscurity to the data is that the query
/// URL must be known to retrieve it.
/// </remarks>
///
/// <exception cref="ArgumentNullException">
/// The <paramref name="connection"/> parameter is <b>null</b>.
/// </exception>
///
/// <exception cref="ArgumentNullException">
/// The <paramref name="searcher"/> parameter is <b>null</b>.
/// </exception>
///
/// <exception cref="ArgumentException">
/// The <paramref name="searcher"/> parameter contains no valid
/// search filters.
/// </exception>
///
/// <exception cref="HealthServiceException">
/// An error occurred when HealthVault processed the request.
/// </exception>
///
public static OpenQuery NewQuery(
AuthenticatedConnection connection,
HealthRecordSearcher searcher)
{
return NewQuery(
connection,
searcher,
Int32.MaxValue,
String.Empty,
String.Empty,
null);
}
/// <summary>
/// Gets a single health record item from the associated record by
/// using the item identifier.
/// </summary>
///
/// <param name="itemId">
/// The unique identifier for the health record item.
/// </param>
///
/// <param name="sections">
/// The data sections of the health record item that should be retrieved.
/// </param>
///
/// <returns>
/// An instance of a <see cref="Microsoft.Health.HealthRecordItem"/>
/// representing the health record item with the specified identifier.
/// </returns>
///
/// <remarks>
/// This method accesses the HealthVault service across the network.
/// <br/><br/>
/// All filters are cleared and replaced with a single filter
/// for the specified item.
/// </remarks>
///
/// <exception cref="HealthServiceException">
/// The server returned something other than a code of
/// HealthServiceStatusCode.OK, or the result count did not equal one (1).
/// -or-
/// <see cref="Microsoft.Health.HealthRecordSearcher.Filters"/> is empty
/// or contains invalid filters.
/// </exception>
///
public HealthRecordItem GetSingleItem(
Guid itemId,
HealthRecordItemSections sections)
{
// Create a new searcher to get the item.
HealthRecordSearcher searcher = new HealthRecordSearcher(Record);
HealthRecordFilter filter = new HealthRecordFilter();
filter.ItemIds.Add(itemId);
filter.View.Sections = sections;
filter.CurrentVersionOnly = true;
searcher.Filters.Add(filter);
ReadOnlyCollection<HealthRecordItemCollection> resultSet =
HealthVaultPlatform.GetMatchingItems(Record.Connection, Record, searcher);
// Check in case HealthVault returned invalid data.
if (resultSet.Count > 1)
{
HealthServiceResponseError error = new HealthServiceResponseError();
error.Message =
ResourceRetriever.GetResourceString(
"GetSingleThingTooManyResults");
HealthServiceException e =
HealthServiceExceptionHelper.GetHealthServiceException(
HealthServiceStatusCode.MoreThanOneThingReturned,
error);
throw e;
}
HealthRecordItem result = null;
if (resultSet.Count == 1)
{
HealthRecordItemCollection resultGroup = resultSet[0];
if (resultGroup.Count > 1)
{
HealthServiceResponseError error = new HealthServiceResponseError();
error.Message =
ResourceRetriever.GetResourceString(
"GetSingleThingTooManyResults");
HealthServiceException e =
HealthServiceExceptionHelper.GetHealthServiceException(
HealthServiceStatusCode.MoreThanOneThingReturned,
error);
throw e;
}
if (resultGroup.Count == 1)
{
result = resultGroup[0];
}
}
return result;
}