public void WhenUnProcessedKeyIsPresent()
{
string thing =
@"<thing><thing-id version-stamp=""583a502e-69a1-4546-be74-dc2ba8db7d98"">e4bfb506-e94e-4d69-ba04-0c12197c0bb8</thing-id><type-id name=""Exercise"">85a21ddb-db20-4c65-8d30-33c899ccf612</type-id><thing-state>Active</thing-state><flags>0</flags><eff-date>2017-01-31T20:00:00</eff-date><created><timestamp>2017-02-01T00:55:06.92Z</timestamp><app-id name=""HealthVault Insights"">52e62dc1-0834-4e25-9612-36f6692a9bcf</app-id><person-id name=""Test"">b54d4b92-9e05-4f60-a428-8b6262d18ec7</person-id><access-avenue>Offline</access-avenue><audit-action>Created</audit-action></created><updated><timestamp>2017-02-01T00:55:06.92Z</timestamp><app-id name=""HealthVault Insights"">52e62dc1-0834-4e25-9612-36f6692a9bcf</app-id><person-id name=""Test"">b54d4b92-9e05-4f60-a428-8b6262d18ec7</person-id><access-avenue>Offline</access-avenue><audit-action>Created</audit-action></updated><data-xml><exercise><when><structured><date><y>2017</y><m>1</m><d>31</d></date><time><h>20</h><m>0</m><s>0</s><f>0</f></time></structured></when><activity><text>Bicycling</text><code><value>Bicycling</value><family>wc</family><type>exercise-activities</type><version>1</version></code></activity><duration>120</duration><detail><name><value>CaloriesBurned_calories</value><family>wc</family><type>exercise-detail-names</type><version>1</version></name><value><value>544</value><units><text>Calories</text><code><value>Calories</value><family>wc</family><type>exercise-units</type><version>1</version></code></units></value></detail><detail><name><value>ElevationGain_meters</value><family>wc</family><type>exercise-detail-names</type><version>1</version></name><value><value>0</value><units><text>meters</text><code><value>Meters</value><family>wc</family><type>exercise-units</type><version>1</version></code></units></value></detail><detail><name><value>ElevationLoss_meters</value><family>wc</family><type>exercise-detail-names</type><version>1</version></name><value><value>0</value><units><text>meters</text><code><value>Meters</value><family>wc</family><type>exercise-units</type><version>1</version></code></units></value></detail></exercise><common><source>Microsoft HealthVault Insights</source><client-thing-id>Biking_a01442b7-213e-4ccf-b057-bf00fb809b46_636214896000000000-Duration</client-thing-id></common></data-xml><eff-permissions immutable=""false""><permission>Read</permission><permission>Update</permission><permission>Create</permission><permission>Delete</permission></eff-permissions></thing>";
string unprocessedThingKeyInfo =
@"<unprocessed-thing-key-info><thing-id version-stamp=""583a502e-69a1-4546-be74-dc2ba8db7d98"">e4bfb506-e94e-4d69-ba04-0c12197c0bb8</thing-id></unprocessed-thing-key-info>";
string xml = $"<group>{thing}{unprocessedThingKeyInfo}</group>";
HealthRecordSearcher query = new HealthRecordSearcher(_healthRecordAccessor);
HealthServiceResponseData responseData = new HealthServiceResponseData
{
InfoNavigator = new XPathDocument(new StringReader(xml)).CreateNavigator()
};
IReadOnlyCollection <ThingCollection> thingCollections = _thingDeserializer.Deserialize(responseData, query);
ThingCollection thingCollection = thingCollections.FirstOrDefault();
// validate that we have both thing and unprocessed thing is parsed
Assert.AreEqual(2, thingCollection.Count);
// validate that the max full thing is 1 and doesn't include partial item
Assert.AreEqual(1, thingCollection.MaxResultsPerRequest);
}
/// <summary>
/// Gets the instance where a HealthVault account should be created
/// for the specified account location.
/// </summary>
///
/// <param name="connection">
/// The connection to use to perform the operation.
/// </param>
///
/// <param name="preferredLocation">
/// A user's preferred geographical location, used to select the best instance
/// in which to create a new HealthVault account. If there is a location associated
/// with the credential that will be used to log into the account, that location
/// should be used.
/// </param>
///
/// <remarks>
/// If no suitable instance can be found, a null value is returned. This can happen,
/// for example, if the account location is not supported by HealthVault.
///
/// Currently the returned instance IDs all parse to integers, but that is not
/// guaranteed and should not be relied upon.
/// </remarks>
///
/// <returns>
/// A <see cref="HealthServiceInstance"/> object represents the selected instance,
/// or null if no suitable instance exists.
/// </returns>
///
/// <exception cref="HealthServiceException">
/// The HealthVault service returned an error.
/// </exception>
///
/// <exception cref="ArgumentException">
/// If <paramref name="preferredLocation"/> is <b>null</b>.
/// </exception>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="connection"/> parameter is <b>null</b>.
/// </exception>
public virtual async Task <HealthServiceInstance> SelectInstanceAsync(
IHealthVaultConnection connection,
Location preferredLocation)
{
Validator.ThrowIfArgumentNull(connection, nameof(connection), Resources.TypeManagerConnectionNull);
Validator.ThrowIfArgumentNull(preferredLocation, nameof(preferredLocation), Resources.SelectInstanceLocationRequired);
StringBuilder requestParameters = new StringBuilder();
XmlWriterSettings settings = SDKHelper.XmlUnicodeWriterSettings;
using (XmlWriter writer = XmlWriter.Create(requestParameters, settings))
{
preferredLocation.WriteXml(writer, "preferred-location");
writer.Flush();
}
HealthServiceResponseData responseData = await connection.ExecuteAsync(
HealthVaultMethods.SelectInstance,
1,
requestParameters.ToString()).ConfigureAwait(false);
XPathExpression infoPath = SDKHelper.GetInfoXPathExpressionForMethod(
responseData.InfoNavigator,
"SelectInstance");
XPathNavigator infoNav = responseData.InfoNavigator.SelectSingleNode(infoPath);
XPathNavigator instanceNav = infoNav.SelectSingleNode("selected-instance");
if (instanceNav != null)
{
return(HealthServiceInstance.CreateInstance(instanceNav));
}
return(null);
}
public virtual async Task <Collection <HealthRecordInfo> > GetAuthorizedRecordsAsync(IList <Guid> recordIds)
{
StringBuilder parameters = new StringBuilder(128);
foreach (Guid id in recordIds)
{
parameters.Append(
"<id>" + id + "</id>");
}
HealthServiceResponseData responseData = await _connection.ExecuteAsync(
HealthVaultMethods.GetAuthorizedRecords,
1,
parameters.ToString())
.ConfigureAwait(false);
Collection <HealthRecordInfo> results = new Collection <HealthRecordInfo>();
XPathNodeIterator records = responseData.InfoNavigator.Select(GetRecordXPathExpression(responseData.InfoNavigator));
foreach (XPathNavigator recordNav in records)
{
results.Add(HealthRecordInfo.CreateFromXml(_connection, recordNav));
}
return(results);
}
public IReadOnlyCollection <ThingCollection> Deserialize(
HealthServiceResponseData responseData,
HealthRecordSearcher searcher)
{
XPathNavigator navigator = responseData.InfoNavigator;
Collection <ThingCollection> result = new Collection <ThingCollection>();
if (navigator != null)
{
XPathNodeIterator groupNodeIterator = navigator.Select("//group");
foreach (XPathNavigator groupNavigator in groupNodeIterator)
{
ThingCollection resultGroup = CreateResultGroupFromResponse(
searcher.Record,
groupNavigator,
searcher.Filters);
if (resultGroup != null)
{
result.Add(resultGroup);
}
}
}
return(new ReadOnlyCollection <ThingCollection>(result));
}
public virtual async Task <PersonInfo> GetPersonInfoAsync()
{
HealthServiceResponseData responseData = await _connection.ExecuteAsync(HealthVaultMethods.GetPersonInfo, 1).ConfigureAwait(false);
XPathExpression personPath = GetPersonXPathExpression(responseData.InfoNavigator);
XPathNavigator infoNav = responseData.InfoNavigator.SelectSingleNode(personPath);
return(PersonInfo.CreateFromXml(infoNav));
}
/// <summary>
/// Gets a list of <see cref="HealthRecordUpdateInfo"/> objects for the current application,
/// that optionally have been updated since a specified date.
/// </summary>
///
/// <param name="connection">The connection to use to perform the operation. This connection
/// must be application level. </param>
///
/// <param name="updatedDate">
/// Date that is used to filter health record IDs according to whether or not they have
/// been updated since the specified date.
/// </param>
///
/// <returns>
/// List of <see cref="HealthRecordUpdateInfo"/> objects filtered by any specified input parameters.
/// </returns>
///
public virtual async Task <IList <HealthRecordUpdateInfo> > GetUpdatedRecordInfoForApplicationAsync(
IHealthVaultConnection connection,
Instant?updatedDate)
{
string parameters = GetUpdateDateParameters(updatedDate);
HealthServiceResponseData responseData = await connection.ExecuteAsync(HealthVaultMethods.GetUpdatedRecordsForApplication, 2, parameters).ConfigureAwait(false);
return(ParseGetUpdatedRecordsForApplicationResponseHealthRecordUpdateInfos(responseData));
}
/// <summary>
/// Generates a new signup code that should be passed to HealthVault Shell in order
/// to create a new user account.
/// </summary>
///
/// <param name="connection">The connection to use to perform the operation. This connection
/// must be application level. </param>
///
/// <returns>
/// A signup code that can be used to create an account.
/// </returns>
///
public virtual async Task <string> NewSignupCodeAsync(IHealthVaultConnection connection)
{
HealthServiceResponseData responseData = await connection.ExecuteAsync(HealthVaultMethods.NewSignupCode, 1).ConfigureAwait(false);
XPathExpression infoPath = SDKHelper.GetInfoXPathExpressionForMethod(responseData.InfoNavigator, "NewSignupCode");
XPathNavigator infoNav = responseData.InfoNavigator.SelectSingleNode(infoPath);
return(infoNav.SelectSingleNode("signup-code").Value);
}
public static HealthServiceResponseData GetResponseData(string fileName)
{
var response = new HealthServiceResponseData
{
InfoNavigator =
new XPathDocument(new StringReader(GetSampleContent(fileName)))
.CreateNavigator()
};
return(response);
}
/// <summary>
/// Helper method that allows the SDK to throw the appropriate
/// HealthServiceException based on the status code returned by
/// HealthVault.
/// </summary>
///
/// <param name="responseData">
/// The HealthServiceResponseData object created by parsing response returned by HealthVault.
/// </param>
///
internal static HealthServiceException GetHealthServiceException(HealthServiceResponseData responseData)
{
HealthServiceStatusCode errorCode =
HealthServiceStatusCodeManager.GetStatusCode(responseData.CodeId);
var e = errorCode != HealthServiceStatusCode.UnmappedError ? GetHealthServiceException(errorCode, responseData.Error) : new HealthServiceException(responseData.CodeId, responseData.Error);
e.Response = responseData;
return(e);
}
/// <summary>
/// Retrieves a collection of key information for identifying and
/// describing the vocabularies in the system.
/// </summary>
///
/// <param name="connection">
/// The connection to use for this operation. The connection
/// must have application capability.
/// </param>
///
/// <returns>
/// A collection of keys identifying the vocabularies in the system.
/// </returns>
///
public virtual async Task <ReadOnlyCollection <VocabularyKey> > GetVocabularyKeysAsync(IHealthVaultConnection connection)
{
var method = HealthVaultMethods.GetVocabulary;
int methodVersion = 1;
HealthServiceResponseData responseData = await connection.ExecuteAsync(method, methodVersion).ConfigureAwait(false);
ReadOnlyCollection <VocabularyKey> keys = CreateVocabularyKeysFromResponse(method.ToString(), responseData);
return(keys);
}
private async Task <HealthServiceResponseData> SendRequestAsync(string requestXml, Guid?correlationId = null)
{
try
{
Debug.WriteLine($"Sent message: {requestXml}");
byte[] requestXmlBytes = Encoding.UTF8.GetBytes(requestXml);
CancellationTokenSource cancellationTokenSource = null;
HttpResponseMessage response;
try
{
cancellationTokenSource = new CancellationTokenSource(Configuration.RequestTimeoutDuration);
response = await _webRequestClient.SendAsync(
ServiceInstance.HealthServiceUrl,
requestXmlBytes,
requestXml.Length,
new Dictionary <string, string> {
{ CorrelationIdContextKey, correlationId.GetValueOrDefault(Guid.NewGuid()).ToString() }
},
(CancellationToken)cancellationTokenSource?.Token).ConfigureAwait(false);
}
finally
{
cancellationTokenSource?.Dispose();
}
// Platform returns a platform request id with the responses. This allows
// developers to have additional information if necessary for debugging/logging purposes.
Guid responseId;
if (response.Headers != null &&
response.Headers.Contains(ResponseIdContextKey) &&
Guid.TryParse(response.Headers.GetValues(ResponseIdContextKey)?.FirstOrDefault(), out responseId))
{
// TODO: Provide a plug in for applications to plug in their telemetry
if (HealthVaultPlatformTrace.LoggingEnabled)
{
HealthVaultPlatformTrace.Log(TraceEventType.Information, "Response Id: {0}", responseId);
}
}
HealthServiceResponseData responseData = await _healthServiceResponseParser.ParseResponseAsync(response).ConfigureAwait(false);
return(responseData);
}
catch (XmlException xmlException)
{
throw new HealthServiceException(
Resources.InvalidResponseFromXMLRequest,
xmlException);
}
}
public void WhenAppSpecificTypesAreRegistered()
{
HealthServiceResponseData responseData = Samples.SampleUtils.GetResponseData("ApplicationSpecificThing.xml");
_thingTypeRegistrar.RegisterApplicationSpecificHandler(
"some-appid",
"some-tag",
typeof(CustomThingType));
ThingBase thingBase = _thingDeserializer.DeserializeItem(responseData.InfoNavigator.SelectSingleNode("thing"));
Assert.IsNotNull(thingBase as CustomThingType);
}
public void InitializeTest()
{
_connection = Substitute.For <IConnectionInternal>();
_client = new VocabularyClient(_connection);
var response = new HealthServiceResponseData
{
InfoNavigator = new XPathDocument(new StringReader(SampleUtils.GetSampleContent("VocabularySample.xml"))).CreateNavigator(),
};
_connection.ExecuteAsync(Arg.Any <HealthVaultMethods>(), Arg.Any <int>(), Arg.Any <string>())
.Returns(response);
}
public async Task <SessionCredential> GetSessionCredentialAsync(CancellationToken token)
{
if (Connection == null)
{
throw new NotSupportedException($"{nameof(Connection)} is required");
}
HealthServiceResponseData responseData = await Connection
.ExecuteAsync(HealthVaultMethods.CreateAuthenticatedSessionToken, 2, ConstructCreateTokenInfoXml())
.ConfigureAwait(false);
return(GetSessionCredential(responseData));
}
public async Task CreateNewThingsAsync <T>(Guid recordId, ICollection <T> things)
where T : IThing
{
Validator.ThrowIfArgumentNull(recordId, nameof(recordId), Resources.NewItemsNullItem);
Validator.ThrowIfArgumentNull(things, nameof(things), Resources.NewItemsNullItem);
StringBuilder infoXml = new StringBuilder();
XmlWriterSettings settings = SDKHelper.XmlUnicodeWriterSettings;
using (XmlWriter infoXmlWriter =
XmlWriter.Create(infoXml, settings))
{
foreach (IThing thing in things)
{
Validator.ThrowIfArgumentNull(thing, nameof(thing), Resources.NewItemsNullItem);
thing.WriteItemXml(infoXmlWriter);
}
infoXmlWriter.Flush();
}
HealthServiceResponseData responseData = await _connection.ExecuteAsync(
HealthVaultMethods.PutThings,
2,
infoXml.ToString(),
recordId,
CorrelationId);
// Now update the Id for the new item
XPathNodeIterator thingIds =
responseData.InfoNavigator.Select(
GetThingIdXPathExpression(responseData.InfoNavigator));
int thingIndex = 0;
foreach (XPathNavigator thingIdNav in thingIds)
{
var thing = things.ElementAt(thingIndex) as ThingBase;
if (thing != null)
{
thing.Key =
new ThingKey(
new Guid(thingIdNav.Value),
new Guid(thingIdNav.GetAttribute(
"version-stamp", string.Empty)));
}
thingIndex++;
}
}
/// <summary>
/// Gets valid group memberships for a record.
/// </summary>
///
/// <remarks>
/// Group membership thing types allow an application to signify that the
/// record belongs to an application defined group. A record in the group may be
/// eligible for special programs offered by other applications, for example.
/// Applications then need a away to query for valid group memberships.
/// <br/>
/// Valid group memberships are those memberships which are not expired, and whose
/// last updating application is authorized by the last updating person to
/// read and delete the membership.
/// </remarks>
/// <param name="connection">
/// The connection to use to access the data.
/// </param>
/// <param name="accessor">
/// The record to use.
/// </param>
/// <param name="applicationIds">
/// A collection of unique application identifiers for which to
/// search for group memberships. For a null or empty application identifier
/// list, return all valid group memberships for the record. Otherwise,
/// return only those group memberships last updated by one of the
/// supplied application identifiers.
/// </param>
/// <returns>
/// A List of things representing the valid group memberships.
/// </returns>
/// <exception cref="HealthServiceException">
/// If an error occurs while contacting the HealthVault service.
/// </exception>
public virtual async Task <Collection <ThingBase> > GetValidGroupMembershipAsync(
IHealthVaultConnection connection,
HealthRecordAccessor accessor,
IList <Guid> applicationIds)
{
StringBuilder parameters = new StringBuilder(128);
if (applicationIds != null)
{
XmlWriterSettings settings = SDKHelper.XmlUnicodeWriterSettings;
using (XmlWriter writer = XmlWriter.Create(parameters, settings))
{
foreach (Guid guid in applicationIds)
{
writer.WriteElementString(
"application-id",
guid.ToString());
}
}
}
var thingDeserializer = Ioc.Container.Locate <IThingDeserializer>(
new
{
connection = connection,
thingTypeRegistrar = Ioc.Get <IThingTypeRegistrar>()
});
HealthServiceResponseData responseData = await connection.ExecuteAsync(HealthVaultMethods.GetValidGroupMembership, 1, parameters.ToString()).ConfigureAwait(false);
XPathExpression infoPath =
SDKHelper.GetInfoXPathExpressionForMethod(
responseData.InfoNavigator,
"GetValidGroupMembership");
XPathNavigator infoNav = responseData.InfoNavigator.SelectSingleNode(infoPath);
Collection <ThingBase> memberships = new Collection <ThingBase>();
XPathNodeIterator membershipIterator = infoNav.Select("thing");
if (membershipIterator != null)
{
foreach (XPathNavigator membershipNav in membershipIterator)
{
memberships.Add(thingDeserializer.Deserialize(membershipNav.OuterXml));
}
}
return(memberships);
}
private SessionCredential GetSessionCredential(HealthServiceResponseData responseData)
{
if (responseData == null)
{
throw new ArgumentNullException($"{nameof(responseData)}");
}
SessionCredential sessionCredential = GetAuthenticationToken(responseData.InfoNavigator);
// TODO: Update with returned expiry when #55406 is completed. 4h is the default HealthVault token expiry time
sessionCredential.ExpirationUtc = DateTimeOffset.UtcNow.AddHours(4);
return(sessionCredential);
}
public async Task SearchVocabulariesTest()
{
var response = new HealthServiceResponseData
{
InfoNavigator = new XPathDocument(new StringReader(SampleUtils.GetSampleContent("VocabularySearchSample.xml"))).CreateNavigator()
};
_connection.ExecuteAsync(Arg.Any <HealthVaultMethods>(), Arg.Any <int>(), Arg.Any <string>())
.Returns(response);
var searchTerm = "hypertension";
await _client.SearchVocabularyAsync(searchTerm, VocabularySearchType.Contains, null);
await _connection.Received().ExecuteAsync(HealthVaultMethods.SearchVocabulary, Arg.Any <int>(), Arg.Is <string>(x => x.Contains(searchTerm)));
}
private static IList <HealthRecordUpdateInfo> ParseGetUpdatedRecordsForApplicationResponseHealthRecordUpdateInfos(
HealthServiceResponseData response)
{
IList <HealthRecordUpdateInfo> healthRecordPersonUpdateInfos = new List <HealthRecordUpdateInfo>();
XPathNodeIterator iterator = response.InfoNavigator.SelectSingleNode("updated-records").Select("updated-record");
foreach (XPathNavigator navigator in iterator)
{
healthRecordPersonUpdateInfos.Add(ParseHealthRecordUpdateInfo(navigator));
}
return(healthRecordPersonUpdateInfos);
}
/// <summary>
/// Retrieves lists of vocabulary items for the specified
/// vocabularies and culture.
/// </summary>
///
/// <param name="connection">
/// The connection to use for this operation. The connection
/// must have application capability.
/// </param>
///
/// <param name="vocabularyKeys">
/// A list of keys identifying the requested vocabularies.
/// </param>
///
/// <param name="cultureIsFixed">
/// HealthVault looks for the vocabulary items for the culture info
/// specified using <see cref="HealthServiceConnection.Culture"/>.
/// If <paramref name="cultureIsFixed"/> is set to <b>false</b> and if
/// items are not found for the specified culture, items for the
/// default fallback culture are returned. If
/// <paramref name="cultureIsFixed"/> is set to <b>true</b>,
/// fallback will not occur, and if items are not found for the
/// specified culture, empty strings are returned.
/// </param>
///
/// <returns>
/// The specified vocabularies and their items, or empty strings.
/// </returns>
///
/// <exception cref="ArgumentException">
/// The <paramref name="vocabularyKeys"/> list is empty.
/// </exception>
///
/// <exception cref="ArgumentNullException">
/// The <paramref name="vocabularyKeys"/> list is <b>null</b>
/// or contains a <b>null</b> entry.
/// </exception>
///
/// <exception cref="HealthServiceException">
/// There is an error in the server request.
/// <br></br>
/// -Or-
/// <br></br>
/// One of the requested vocabularies is not found on the server.
/// <br></br>
/// -Or-
/// <br></br>
/// One of the requested vocabularies does not contain representations
/// for its items for the specified culture when
/// <paramref name="cultureIsFixed"/> is <b>true</b>.
/// <br></br>
/// -Or-
/// <br></br>
/// There is an error loading the vocabulary.
/// </exception>
///
public virtual async Task <ReadOnlyCollection <Vocabulary> > GetVocabularyAsync(
IHealthVaultConnection connection,
IList <VocabularyKey> vocabularyKeys,
bool cultureIsFixed)
{
Validator.ThrowIfArgumentNull(vocabularyKeys, nameof(vocabularyKeys), Resources.VocabularyKeysNullOrEmpty);
if (vocabularyKeys.Count == 0)
{
throw new ArgumentException(Resources.VocabularyKeysNullOrEmpty, nameof(vocabularyKeys));
}
var method = HealthVaultMethods.GetVocabulary;
int methodVersion = 2;
StringBuilder requestParameters = new StringBuilder(256);
XmlWriterSettings settings = SDKHelper.XmlUnicodeWriterSettings;
settings.OmitXmlDeclaration = true;
settings.ConformanceLevel = ConformanceLevel.Fragment;
using (XmlWriter writer = XmlWriter.Create(requestParameters, settings))
{
writer.WriteStartElement("vocabulary-parameters");
for (int i = 0; i < vocabularyKeys.Count; i++)
{
Validator.ThrowIfArgumentNull(vocabularyKeys[i], "vocabularyKeys[i]", Resources.VocabularyKeysNullOrEmpty);
vocabularyKeys[i].WriteXml(writer);
}
writer.WriteElementString(
"fixed-culture",
SDKHelper.XmlFromBool(cultureIsFixed));
writer.WriteEndElement();
writer.Flush();
}
string parameters = requestParameters.ToString();
HealthServiceResponseData responseData = await connection.ExecuteAsync(method, methodVersion, parameters).ConfigureAwait(false);
ReadOnlyCollection <Vocabulary> vocabularies
= CreateVocabulariesFromResponse(method.ToString(), responseData);
return(vocabularies);
}
public async Task <HealthServiceResponseData> ExecuteAsync(
HealthVaultMethods method,
int methodVersion,
string parameters = null,
Guid?recordId = null,
Guid?correlationId = null)
{
bool isMethodAnonymous = IsMethodAnonymous(method);
// Make sure that session credential is set for method calls requiring
// authentication
if (!isMethodAnonymous && string.IsNullOrEmpty(SessionCredential?.Token))
{
await AuthenticateAsync().ConfigureAwait(false);
}
// Create the message using a Func in case we need to re-generate it for a retry later
Func <string> requestXmlCreator = () => _requestMessageCreator.Create(
method,
methodVersion,
isMethodAnonymous,
parameters,
recordId,
isMethodAnonymous && method == HealthVaultMethods.CreateAuthenticatedSessionToken
? ApplicationId
: Configuration.MasterApplicationId);
var requestXml = requestXmlCreator();
HealthServiceResponseData responseData = null;
try
{
responseData = await SendRequestAsync(requestXml, correlationId).ConfigureAwait(false);
}
catch (HealthServiceAuthenticatedSessionTokenExpiredException)
{
if (!isMethodAnonymous)
{
await RefreshSessionAsync(CancellationToken.None);
// Re-generate the message so it pulls in the new SessionCredential
requestXml = requestXmlCreator();
return(await SendRequestAsync(requestXml, correlationId).ConfigureAwait(false));
}
}
return(responseData);
}
private static VocabularyItemCollection CreateVocabularyItemCollectionFromResponse(
string methodNSSuffix,
HealthServiceResponseData response)
{
XPathNavigator infoNav =
response.InfoNavigator.SelectSingleNode(
Vocabulary.GetInfoXPathExpression(
methodNSSuffix,
response.InfoNavigator));
XPathNavigator vocabNav = infoNav.SelectSingleNode("code-set-result");
VocabularyItemCollection itemCollection = new VocabularyItemCollection();
itemCollection.PopulateFromXml(vocabNav);
return(itemCollection);
}
public async Task <IReadOnlyCollection <ThingCollection> > GetThingsAsync(Guid recordId, IEnumerable <ThingQuery> queries)
{
Validator.ThrowIfGuidEmpty(recordId, nameof(recordId));
List <ThingQuery> queriesList = queries.ToList();
Validator.ThrowIfCollectionNullOrEmpty(queriesList, nameof(queries));
HealthRecordAccessor accessor = new HealthRecordAccessor(_connection, recordId);
HealthRecordSearcher searcher = new HealthRecordSearcher(accessor);
HealthServiceResponseData response = await GetRequestWithParameters(recordId, searcher, queriesList).ConfigureAwait(false);
IReadOnlyCollection <ThingCollection> resultSet = _thingDeserializer.Deserialize(response, searcher);
return(resultSet);
}
private static async Task <ServiceInfo> GetServiceDefinitionAsync(IHealthVaultConnection connection, string parameters)
{
HealthServiceResponseData responseData = await connection.ExecuteAsync(HealthVaultMethods.GetServiceDefinition, 2, parameters).ConfigureAwait(false);
if (responseData.InfoNavigator.HasChildren)
{
XPathExpression infoPath = SDKHelper.GetInfoXPathExpressionForMethod(
responseData.InfoNavigator,
"GetServiceDefinition2");
XPathNavigator infoNav = responseData.InfoNavigator.SelectSingleNode(infoPath);
return(ServiceInfo.CreateServiceInfo(infoNav));
}
return(null);
}
/// <summary>
/// Gets the application settings for the current application and
/// person.
/// </summary>
///
/// <param name="connection">The connection to use to perform the operation. This connection
/// must be authenticated. </param>
///
/// <returns>
/// The complete set application settings including the XML settings, selected record ID, etc.
/// </returns>
///
public virtual async Task <ApplicationSettings> GetApplicationSettingsAsync(IHealthVaultConnection connection)
{
HealthServiceResponseData responseData = await connection.ExecuteAsync(HealthVaultMethods.GetApplicationSettings, 1).ConfigureAwait(false);
XPathExpression xPathExpression = GetPersonAppSettingsXPathExpression(responseData.InfoNavigator);
XPathNavigator appSettingsNav = responseData.InfoNavigator.SelectSingleNode(xPathExpression);
ApplicationSettings settings = null;
if (appSettingsNav != null)
{
settings = new ApplicationSettings();
settings.ParseXml(appSettingsNav);
}
return(settings);
}
private Dictionary <Guid, ThingTypeDefinition> CreateThingTypesFromResponse(
string cultureName,
HealthServiceResponseData response,
ThingTypeSections sections,
Dictionary <Guid, ThingTypeDefinition> cachedThingTypes)
{
Dictionary <Guid, ThingTypeDefinition> thingTypes;
if (cachedThingTypes != null && cachedThingTypes.Count > 0)
{
thingTypes = new Dictionary <Guid, ThingTypeDefinition>(cachedThingTypes);
}
else
{
thingTypes = new Dictionary <Guid, ThingTypeDefinition>();
}
XPathNodeIterator thingTypesIterator =
response.InfoNavigator.Select("thing-type");
lock (_sectionCache)
{
if (!_sectionCache.ContainsKey(cultureName))
{
_sectionCache.Add(cultureName, new Dictionary <ThingTypeSections, Dictionary <Guid, ThingTypeDefinition> >());
}
if (!_sectionCache[cultureName].ContainsKey(sections))
{
_sectionCache[cultureName].Add(sections, new Dictionary <Guid, ThingTypeDefinition>());
}
foreach (XPathNavigator navigator in thingTypesIterator)
{
ThingTypeDefinition thingType =
ThingTypeDefinition.CreateFromXml(navigator);
_sectionCache[cultureName][sections][thingType.TypeId] = thingType;
thingTypes[thingType.TypeId] = thingType;
}
}
return(thingTypes);
}
/// <summary>
/// Calls the BeginPutBlob HealthVault method.
/// </summary>
///
/// <returns>
/// The result of the BeginPutBlob method call as a BlobPutParameters instance.
/// </returns>
///
/// <exception cref="HealthServiceException">
/// If the call to HealthVault fails in some way.
/// </exception>
///
private async Task <BlobPutParameters> BeginPutBlobAsync()
{
HealthServiceResponseData responseData = await _record.Connection.ExecuteAsync(HealthVaultMethods.BeginPutBlob, 1).ConfigureAwait(false);
XPathExpression infoPath =
SDKHelper.GetInfoXPathExpressionForMethod(
responseData.InfoNavigator,
"BeginPutBlob");
XPathNavigator infoNav =
responseData.InfoNavigator.SelectSingleNode(infoPath);
Uri blobReferenceUrl = new Uri(infoNav.SelectSingleNode("blob-ref-url").Value);
int chunkSize = infoNav.SelectSingleNode("blob-chunk-size").ValueAsInt;
long maxBlobSize = infoNav.SelectSingleNode("max-blob-size").ValueAsLong;
string blobHashAlgString = infoNav.SelectSingleNode("blob-hash-algorithm").Value;
BlobHashAlgorithm blobHashAlg;
try
{
blobHashAlg =
(BlobHashAlgorithm)Enum.Parse(
typeof(BlobHashAlgorithm), blobHashAlgString);
}
catch (ArgumentException)
{
blobHashAlg = BlobHashAlgorithm.Unknown;
}
int blocksize = 0;
XPathNavigator blockNav = infoNav.SelectSingleNode("blob-hash-parameters/block-size");
if (blockNav != null)
{
blocksize = blockNav.ValueAsInt;
}
return(new BlobPutParameters(
blobReferenceUrl,
chunkSize,
maxBlobSize,
blobHashAlg,
blocksize));
}
public async Task <T> GetThingAsync <T>(Guid recordId, Guid thingId)
where T : IThing
{
Validator.ThrowIfArgumentNull(recordId, nameof(recordId), Resources.NewItemsNullItem);
// Create a new searcher to get the item.
HealthRecordAccessor accessor = new HealthRecordAccessor(_connection, recordId);
HealthRecordSearcher searcher = new HealthRecordSearcher(accessor);
ThingQuery query = new ThingQuery();
query.ItemIds.Add(thingId);
query.View.Sections = ThingSections.Default;
query.CurrentVersionOnly = true;
HealthServiceResponseData result = await GetRequestWithParameters(recordId, searcher, new[] { query });
IReadOnlyCollection <ThingCollection> resultSet = _thingDeserializer.Deserialize(result, searcher);
// Check in case HealthVault returned invalid data.
if (resultSet.Count == 0)
{
return(default(T));
}
if (resultSet.Count > 1 || resultSet.ElementAt(0).Count > 1)
{
throw new MoreThanOneThingException(Resources.GetSingleThingTooManyResults);
}
if (resultSet.Count == 1)
{
ThingCollection resultGroup = resultSet.ElementAt(0);
if (resultGroup.Count == 1)
{
return((T)resultGroup[0]);
}
}
return(default(T));
}
private void InitializeResponse(params string[] samples)
{
_client = new ThingClient(_connection, new ThingDeserializer(_connection, _itemTypeManager));
_connection.CreateThingClient().Returns(_client);
var responseData = new List <HealthServiceResponseData>();
foreach (string sample in samples)
{
var infoReader = XmlReader.Create(new StringReader(sample), SDKHelper.XmlReaderSettings);
infoReader.NameTable.Add("wc");
infoReader.ReadToFollowing("wc:info");
var response = new HealthServiceResponseData
{
InfoNavigator = new XPathDocument(new StringReader(sample)).CreateNavigator(),
};
responseData.Add(response);
}
if (responseData.Count == 1)
{
_connection.ExecuteAsync(
Arg.Any <HealthVaultMethods>(),
Arg.Any <int>(),
Arg.Any <string>(),
Arg.Any <Guid?>(),
Arg.Any <Guid?>()).Returns(responseData[0]);
}
else
{
_connection.ExecuteAsync(
Arg.Any <HealthVaultMethods>(),
Arg.Any <int>(),
Arg.Any <string>(),
Arg.Any <Guid?>(),
Arg.Any <Guid?>()).Returns(responseData[0], responseData.Skip(1).ToArray());
}
}
/// <summary>
/// Gets the permissions which the authenticated person
/// has when using the calling application for the specified item types
/// in this health record as well as the other permission settings such as MeaningfulUseOptIn.
/// </summary>
/// <param name="connection">
/// The connection to use to access the data.
/// </param>
/// <param name="accessor">
/// The record to use.
/// </param>
/// <param name="healthRecordItemTypeIds">
/// A collection of uniqueidentifiers to identify the health record
/// item types, for which the permissions are being queried.
/// </param>
/// <returns>
/// A <see cref="HealthRecordPermissions"/> object
/// which contains a collection of <see cref="ThingTypePermission"/> objects and
/// other permission settings.
/// </returns>
///
/// <remarks>
/// If the list of thing types is empty, an empty list is
/// returned for <see cref="HealthRecordPermissions"/> object's ItemTypePermissions property.
/// If for a thing type, the person has
/// neither online access nor offline access permissions,
/// ThingTypePermission object is not returned for that
/// thing type.
/// </remarks>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="healthRecordItemTypeIds"/> is <b>null</b>.
/// </exception>
///
/// <exception cref="HealthServiceException">
/// There is an error in the server request.
/// </exception>
///
public virtual async Task <HealthRecordPermissions> QueryRecordPermissionsAsync(
IHealthVaultConnection connection,
HealthRecordAccessor accessor,
IList <Guid> healthRecordItemTypeIds)
{
Validator.ThrowIfArgumentNull(healthRecordItemTypeIds, nameof(healthRecordItemTypeIds), Resources.CtorhealthRecordItemTypeIdsArgumentNull);
string parameters = GetQueryPermissionsParametersXml(healthRecordItemTypeIds);
HealthServiceResponseData responseData = await connection.ExecuteAsync(HealthVaultMethods.QueryPermissions, 1, parameters).ConfigureAwait(false);
XPathNavigator infoNav =
responseData.InfoNavigator.SelectSingleNode(
GetQueryPermissionsInfoXPathExpression(
responseData.InfoNavigator));
HealthRecordPermissions recordPermissions = new HealthRecordPermissions();
XPathNodeIterator thingTypePermissionsNodes =
infoNav.Select("thing-type-permission");
foreach (XPathNavigator nav in thingTypePermissionsNodes)
{
ThingTypePermission thingTypePermissions =
ThingTypePermission.CreateFromXml(nav);
recordPermissions.ItemTypePermissions.Add(thingTypePermissions);
}
XPathNavigator valueNav = infoNav.SelectSingleNode("other-settings/meaningfuluse-opt-in");
if (valueNav != null)
{
recordPermissions.MeaningfulUseOptIn = valueNav.ValueAsBoolean;
}
else
{
recordPermissions.MeaningfulUseOptIn = null;
}
return(recordPermissions);
}
private static ReadOnlyCollection<VocabularyKey> CreateVocabularyKeysFromResponse(
string methodNameNSSuffix,
HealthServiceResponseData response)
{
XPathNavigator infoNav =
response.InfoNavigator.SelectSingleNode(
Vocabulary.GetInfoXPathExpression(
methodNameNSSuffix,
response.InfoNavigator));
List<VocabularyKey> vocabularyKeys = new List<VocabularyKey>();
XPathNodeIterator vocabKeyIter = infoNav.Select("vocabulary-key");
foreach (XPathNavigator vocabKeyNav in vocabKeyIter)
{
VocabularyKey vocabularyKey = new VocabularyKey();
vocabularyKey.ParseXml(vocabKeyNav);
vocabularyKeys.Add(vocabularyKey);
}
return new ReadOnlyCollection<VocabularyKey>(vocabularyKeys);
}
private static VocabularyItemCollection CreateVocabularyItemCollectionFromResponse(
string methodNSSuffix,
HealthServiceResponseData response)
{
XPathNavigator infoNav =
response.InfoNavigator.SelectSingleNode(
Vocabulary.GetInfoXPathExpression(
methodNSSuffix,
response.InfoNavigator));
XPathNavigator vocabNav = infoNav.SelectSingleNode("code-set-result");
VocabularyItemCollection itemCollection = new VocabularyItemCollection();
itemCollection.PopulateFromXml(vocabNav);
return itemCollection;
}
private static void ParseGetUpdatedRecordsForApplicationResponse(
HealthServiceResponseData response,
out IList<HealthRecordUpdateInfo> healthRecordUpdateInfos)
{
healthRecordUpdateInfos = new List<HealthRecordUpdateInfo>();
XPathNodeIterator iterator = response.InfoNavigator.Select("record-id");
foreach (XPathNavigator navigator in iterator)
{
healthRecordUpdateInfos.Add(ParseHealthRecordUpdateInfo(navigator));
}
}
