public static JObject GetAllThings(Guid personId, Guid recordId) { Guid appId = new Guid(Connections.ApplicationId); OfflineWebApplicationConnection connection = Connections.CreateConnection(appId, personId); HealthRecordAccessor accessor = new HealthRecordAccessor(connection, recordId); HealthRecordSearcher searcher = new HealthRecordSearcher(accessor); List <Guid> queryOrder = Types.TypeDefinitions.Keys.ToList(); queryOrder.Add(CustomType.Id); foreach (Guid thingType in queryOrder) { HealthRecordFilter filter = new HealthRecordFilter(thingType); if (thingType.Equals(CustomType.Id) || (Types.TypeDefinitions.ContainsKey(thingType) && !Types.TypeDefinitions[thingType].Persistent)) { filter.EffectiveDateMin = GetMinTime(); } searcher.Filters.Add(filter); } ReadOnlyCollection <HealthRecordItemCollection> things = searcher.GetMatchingItems(); return(TransformThings(things, queryOrder)); }
public void DeProvision() { Guid tempPersonId = _personId; Guid tempRecordId = _recordId; // first reset local state so // that even if things fail after this // the next app launch will have fresh state _isProvisioned = false; _personId = Guid.Empty; _recordId = Guid.Empty; _applicationId = Guid.Empty; SaveUserSettings(); // attempt to remove authorization of application from server HealthClientAuthorizedConnection connection = HealthClientApplication.CreateAuthorizedConnection(tempPersonId); HealthRecordAccessor accessor = new HealthRecordAccessor(connection, tempRecordId); accessor.RemoveApplicationAuthorization(); // delete the local certificate _healthClientApplication.DeleteCertificate(); _healthClientApplication = null; }
public void RevokeApplicationConnection(Guid recordId) { // connection must have been created in the context of a person HealthRecordAccessor record = new HealthRecordAccessor(_connection, recordId); record.RemoveApplicationAuthorization(); }
public static void PutThings(OfflineWebApplicationConnection connection, Guid recordId, ref HealthRecordItem newItem) { HealthRecordAccessor record = new HealthRecordAccessor(connection, recordId); record.NewItem(newItem); return; }
protected override void ProcessRecord() { HealthClientApplication clientApp = HvShellUtilities.GetClient(); List <PersonInfo> authorizedPeople = new List <PersonInfo>(clientApp.ApplicationConnection.GetAuthorizedPeople()); // Create an authorized connection for each person on the // list. HealthClientAuthorizedConnection authConnection = clientApp.CreateAuthorizedConnection( authorizedPeople[0].PersonId); // Use the authorized connection to read the user's default // health record. HealthRecordAccessor access = new HealthRecordAccessor( authConnection, authConnection.GetPersonInfo().GetSelfRecord().Id); // Search the health record for basic demographic // information. // Most user records contain an item of this type. HealthRecordSearcher search = access.CreateSearcher(); HealthRecordFilter filter = new HealthRecordFilter( HvShellUtilities.NameToTypeId(Type)); search.Filters.Add(filter); foreach (Object o in search.GetMatchingItems()[0]) { WriteObject(o); } }
private async Task <XPathNavigator> GetPartialThings( HealthRecordAccessor record, IList <ThingKey> thingKeys, int currentThingKeyIndex, int numberOfFullThingsToRetrieve) { HealthRecordSearcher searcher = record.CreateSearcher(); ThingQuery query = new ThingQuery(); for (int i = currentThingKeyIndex; i < thingKeys.Count && i < currentThingKeyIndex + numberOfFullThingsToRetrieve; i++) { query.ItemKeys.Add(thingKeys[i]); } query.View = this.Query.View; query.States = this.Query.States; query.CurrentVersionOnly = this.Query.CurrentVersionOnly; if (Query.OrderByClauses.Count > 0) { foreach (var orderByClause in Query.OrderByClauses) { query.OrderByClauses.Add(orderByClause); } } searcher.Filters.Add(query); return(await searcher.GetMatchingItemsRaw().ConfigureAwait(false)); }
/// <summary> /// Gets the permissions which the authenticated person /// has when using the calling application for the specified item types /// in this record. /// </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 unique identifiers to identify the health record /// item types, for which the permissions are being queried. /// </param> /// <returns> /// Returns a dictionary of <see cref="ThingTypePermission"/> /// with thing types as the keys. /// </returns> /// /// <remarks> /// If the list of thing types is empty, an empty dictionary is /// returned. If for a thing type, the person has /// neither online access nor offline access permissions, /// <b> null </b> will be returned for that type in the dictionary. /// </remarks> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="healthRecordItemTypeIds"/> is <b>null</b>. /// </exception> /// /// <exception cref="HealthServiceException"> /// If there is an exception during executing the request to HealthVault. /// </exception> /// public virtual async Task <IDictionary <Guid, ThingTypePermission> > QueryPermissionsByTypesAsync( IHealthVaultConnection connection, HealthRecordAccessor accessor, IList <Guid> healthRecordItemTypeIds) { HealthRecordPermissions recordPermissions = await QueryRecordPermissionsAsync(connection, accessor, healthRecordItemTypeIds).ConfigureAwait(false); Collection <ThingTypePermission> typePermissions = recordPermissions.ItemTypePermissions; Dictionary <Guid, ThingTypePermission> permissions = new Dictionary <Guid, ThingTypePermission>(); foreach (Guid typeId in healthRecordItemTypeIds) { if (!permissions.ContainsKey(typeId)) { permissions.Add(typeId, null); } } foreach (ThingTypePermission typePermission in typePermissions) { permissions[typePermission.TypeId] = typePermission; } return(permissions); }
private ThingCollection CreateResultGroupFromResponse( HealthRecordAccessor accessor, XPathNavigator groupNavigator, Collection <ThingQuery> queryFilters) { Validator.ThrowIfArgumentNull(accessor, nameof(accessor), Resources.ResponseRecordNull); // Name is optional ThingQuery matchingQuery = null; string groupName = groupNavigator.GetAttribute("name", string.Empty); foreach (ThingQuery queryFilter in queryFilters) { if (string.IsNullOrEmpty(queryFilter.Name) && string.IsNullOrEmpty(groupName)) { matchingQuery = queryFilter; break; } if (string.Equals(queryFilter.Name, groupName, StringComparison.Ordinal)) { matchingQuery = queryFilter; break; } } return(GetResultGroupFromResponse(groupName, accessor, matchingQuery, groupNavigator)); }
public static List <string> GetThings(OfflineWebApplicationConnection connection, Guid recordId, Guid[] typeIds, DateTime updatedSinceUtc) { HealthRecordAccessor record = new HealthRecordAccessor(connection, recordId); HealthRecordSearcher searcher = record.CreateSearcher(); HealthRecordFilter filter = new HealthRecordFilter(); searcher.Filters.Add(filter); foreach (Guid typeId in typeIds) { filter.TypeIds.Add(typeId); } filter.UpdatedDateMin = DateTime.SpecifyKind(updatedSinceUtc, DateTimeKind.Utc); filter.View.Sections = HealthRecordItemSections.All | Microsoft.Health.HealthRecordItemSections.Xml; //HealthRecordItemSections.Core | //HealthRecordItemSections.Xml | //HealthRecordItemSections.Audits; HealthRecordItemCollection things = searcher.GetMatchingItems()[0]; List <string> items = new List <string>(); foreach (HealthRecordItem thing in things) { items.Add(thing.GetItemXml(filter.View.Sections)); } return(items); }
private ThingCollection GetResultGroupFromResponse( string groupName, HealthRecordAccessor accessor, ThingQuery matchingQuery, XPathNavigator groupNavigator) { ThingCollection result = new ThingCollection(groupName, accessor, matchingQuery, _connection); int maxResultsPerRequest = 0; XPathNodeIterator thingNodeIterator = groupNavigator.Select("thing"); XPathNodeIterator unprocessedThingKeyInfoNodeIterator = groupNavigator.Select("unprocessed-thing-key-info"); XPathNavigator filteredNodeNavigator = groupNavigator.SelectSingleNode("filtered"); XPathNavigator orderByCultureNodeNavigator = groupNavigator.SelectSingleNode("order-by-culture"); if (thingNodeIterator != null) { foreach (XPathNavigator thingNode in thingNodeIterator) { ThingBase resultThingBase = DeserializeItem(thingNode); result.AddResult(resultThingBase); maxResultsPerRequest++; } } if (unprocessedThingKeyInfoNodeIterator != null) { foreach (XPathNavigator unprocessedThingKeyInfoNode in unprocessedThingKeyInfoNodeIterator) { XPathNavigator thingIdNavigator = unprocessedThingKeyInfoNode.SelectSingleNode("thing-id"); Guid thingId = Guid.Parse(thingIdNavigator.Value); Guid versionStamp = Guid.Parse(thingIdNavigator.GetAttribute("version-stamp", string.Empty)); ThingKey key = new ThingKey(thingId, versionStamp); result.AddResult(key); } } if (filteredNodeNavigator != null) { result.WasFiltered = filteredNodeNavigator.ValueAsBoolean; } if (orderByCultureNodeNavigator != null) { result.OrderByCulture = orderByCultureNodeNavigator.Value; } if (maxResultsPerRequest > 0) { result.MaxResultsPerRequest = maxResultsPerRequest; } return(result); }
/// <summary> /// Fills in the data table with data from a list of ThingBase. /// </summary> /// <param name="record"/> /// <param name="items"/> /// <param name="startIndex"/> /// <param name="count"/> public async Task GetDataAsync(HealthRecordAccessor record, IList <ThingBase> items, int startIndex, int count) { ThingDataTableView effectiveView = await this.ApplyEffectiveViewAsync(record.Connection).ConfigureAwait(false); IDictionary <Guid, ThingTypeDefinition> typeDefDict = await ItemTypeManager.GetHealthRecordItemTypeDefinitionAsync(query.TypeIds, record.Connection).ConfigureAwait(false); ThingTypeDefinition sttTypeDef = typeDefDict.Count == 1 ? typeDefDict[query.TypeIds[0]] : null; bool firstRow = true; string transformName = (effectiveView == ThingDataTableView.SingleTypeTable) ? "stt" : "mtt"; for (int i = startIndex; i < items.Count && i < count; ++i) { ThingBase item = items[i]; XPathNavigator itemTransformNav; IDictionary <string, XDocument> transformedXmlData = item.TransformedXmlData; if (transformedXmlData.ContainsKey(transformName)) { itemTransformNav = transformedXmlData[transformName].CreateNavigator().SelectSingleNode( "//data-xml/row"); } else { string transform = (sttTypeDef == null) ? ThingTypeDefinitionHelper.Create(typeDefDict[item.TypeId]).TransformItem(transformName, item) : ThingTypeDefinitionHelper.Create(sttTypeDef).TransformItem(transformName, item); XmlReaderSettings settings = new XmlReaderSettings() { XmlResolver = null, DtdProcessing = DtdProcessing.Prohibit }; using (StringReader stringReader = new StringReader(transform)) { itemTransformNav = new XPathDocument(XmlReader.Create(stringReader, settings)).CreateNavigator(); } if (!itemTransformNav.MoveToFirstChild()) { continue; } } if (firstRow) { SetupColumns(itemTransformNav.Clone()); firstRow = false; } AddRow(itemTransformNav); } }
/// <summary> /// Gets the permissions which the authenticated person /// has when using the calling application for the specified item types /// in this health record. /// </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 list of <see cref="ThingTypePermission"/> /// objects which represent the permissions that the current /// authenticated person has for the HealthRecordItemTypes specified /// in the current health record when using the current application. /// </returns> /// /// <remarks> /// If the list of thing types is empty, an empty list is /// returned. 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"> /// If there is an exception during executing the request to HealthVault. /// </exception> /// public virtual async Task <Collection <ThingTypePermission> > QueryPermissionsAsync( IHealthVaultConnection connection, HealthRecordAccessor accessor, IList <Guid> healthRecordItemTypeIds) { HealthRecordPermissions permissions = await QueryRecordPermissionsAsync(connection, accessor, healthRecordItemTypeIds).ConfigureAwait(false); return(permissions.ItemTypePermissions); }
/// <summary> /// Fills in the data table with data from the HealthVault service. /// </summary> /// /// <param name="recordId"> /// The unique health record identifier to get the data from. /// </param> /// /// <param name="connection"> /// The connection to the HealthVault service to use. /// </param> /// /// <remarks> /// This method makes a web-method call to the HealthVault service. /// </remarks> /// /// <exception cref="HealthServiceException"> /// An error occurred while accessing the HealthVault service. /// </exception> /// public async Task GetData( Guid recordId, IConnectionInternal connection) { HealthRecordAccessor record = new HealthRecordAccessor(connection, recordId); await GetDataAsync(record).ConfigureAwait(false); }
private const int DefaultStreamBufferSize = 1 << 20; // 1MB /// <summary> /// Constructs an instance of the Blob class with the specified values. /// </summary> /// /// <param name="name"> /// The name of the BLOB. It can be <see cref="string.Empty"/> but cannot be <b>null</b>. /// </param> /// /// <param name="contentType"> /// The content type of the BLOB. /// </param> /// /// <param name="currentContentEncoding"> /// The current content encoding of the BLOB or <b>null</b> if the BLOB is not encoded. /// </param> /// /// <param name="legacyContentEncoding"> /// The previous content encoding of the BLOB (if any). /// </param> /// /// <param name="record"> /// The health record to write the BLOB data to. /// </param> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="name"/> or <paramref name="contentType"/> is <b>null</b>. /// </exception> /// internal Blob( string name, string contentType, string currentContentEncoding, string legacyContentEncoding, HealthRecordAccessor record) : this(name, contentType, currentContentEncoding, legacyContentEncoding, null, record) { }
public static void PostThing(HealthRecordItem thing, Guid personId, Guid recordId) { Guid appId = new Guid(Connections.ApplicationId); OfflineWebApplicationConnection connection = Connections.CreateConnection(appId, personId); HealthRecordAccessor accessor = new HealthRecordAccessor(connection, recordId); accessor.NewItem(thing); }
private static List <T> GetValues <T>(Guid typeId, HealthRecordAccessor access) where T : HealthRecordItem { var searcher = access.CreateSearcher(); var filter = new HealthRecordFilter(typeId); searcher.Filters.Add(filter); var items = searcher.GetMatchingItems()[0]; return(items.Cast <T>().ToList()); }
public static void PurgeCustomData(Guid personId, Guid recordId) { Guid appId = new Guid(Connections.ApplicationId); OfflineWebApplicationConnection connection = Connections.CreateConnection(appId, personId); HealthRecordAccessor accessor = new HealthRecordAccessor(connection, recordId); foreach (ApplicationSpecific item in accessor.GetItemsByType(ApplicationSpecific.TypeId)) { accessor.RemoveItem(item); } }
public void InitializeTest() { Ioc.Container = new DependencyInjectionContainer(); IConnectionInternal connection = Substitute.For <IConnectionInternal>(); _healthRecordAccessor = Substitute.For <HealthRecordAccessor>(); _thingTypeRegistrar = new ThingTypeRegistrar(); _thingDeserializer = new ThingDeserializer(connection, _thingTypeRegistrar); Ioc.Container.Configure(c => c.ExportInstance(_thingTypeRegistrar).As <IThingTypeRegistrar>()); }
public void SetTemperatureOnHealthVault(double tempValue) { try { if (!_isProvisioned) { MessageBox.Show("Please provision application first"); return; } HealthClientAuthorizedConnection connection = HealthClientApplication.CreateAuthorizedConnection(PersonId); HealthRecordAccessor accessor = new HealthRecordAccessor(connection, RecordId); TemperatureMeasurement temperature = new TemperatureMeasurement(tempValue); VitalSigns vitalSign = new VitalSigns(); //generate random date DateTime startDate = new DateTime(2018, 1, 1); DateTime endDate = new DateTime(2018, 12, 30); TimeSpan timeSpan = endDate - startDate; var randomTest = new Random(); TimeSpan newSpan = new TimeSpan(0, randomTest.Next(0, (int)timeSpan.TotalMinutes), 0); DateTime newDate = startDate + newSpan; //set time now //vitalSign.When = new HealthServiceDateTime(DateTime.UtcNow); vitalSign.When = new HealthServiceDateTime(newDate); CodableValue codableValue = new CodableValue(); codableValue.Text = "celsius"; VitalSignsResultType vitalSignsResultType = new VitalSignsResultType(); vitalSignsResultType.Unit = codableValue; vitalSignsResultType.TextValue = "Temperature"; vitalSignsResultType.Title.Text = "Temperature"; vitalSignsResultType.Value = tempValue; vitalSign.VitalSignsResults.Add(vitalSignsResultType); accessor.NewItem(vitalSign); } catch (Exception ex) { throw; } }
/// <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 static T GetSingleValue <T>(Guid typeId, HealthRecordAccessor access) where T : class { var searcher = access.CreateSearcher(); var filter = new HealthRecordFilter(typeId); searcher.Filters.Add(filter); var items = searcher.GetMatchingItems()[0]; if (items != null && items.Count > 0) { return(items[0] as T); } return(null); }
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); }
/// <summary> /// Creates a connection to HealthVault and sets weight data /// </summary> /// <param name="weightValue"></param> public void SetWeightOnHealthVault(double weightValue) { if (!_isProvisioned) { MessageBox.Show("Please provision application first"); return; } HealthClientAuthorizedConnection connection = HealthClientApplication.CreateAuthorizedConnection(PersonId); HealthRecordAccessor accessor = new HealthRecordAccessor(connection, RecordId); ItemTypes.Weight weight = new ItemTypes.Weight(); weight.Value = new WeightValue(weightValue); accessor.NewItem(weight); }
/// <summary> /// Constructs an instance of the Blob class with the specified values. /// </summary> /// /// <param name="name"> /// The name of the BLOB. It can be <see cref="string.Empty"/> but cannot be <b>null</b>. /// </param> /// /// <param name="contentType"> /// The content type of the BLOB. /// </param> /// /// <param name="currentContentEncoding"> /// The current content encoding of the BLOB or <b>null</b> if the BLOB is not encoded. /// </param> /// /// <param name="legacyContentEncoding"> /// The previous content encoding of the BLOB (if any). /// </param> /// /// <param name="hashInfo"> /// The hash information for the BLOB. /// </param> /// /// <param name="record"> /// The health record to write the BLOB data to. /// </param> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="name"/> or <paramref name="contentType"/> is <b>null</b>. /// </exception> /// internal Blob( string name, string contentType, string currentContentEncoding, string legacyContentEncoding, BlobHashInfo hashInfo, HealthRecordAccessor record) { Validator.ThrowIfArgumentNull(name, nameof(name), Resources.StringNull); Validator.ThrowIfArgumentNull(contentType, nameof(contentType), Resources.StringNull); Name = name; ContentType = contentType; ContentEncoding = currentContentEncoding; LegacyContentEncoding = legacyContentEncoding; HashInfo = hashInfo; _record = record; }
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)); }
/// <summary> /// Creates a connection to HealthVault and obtains weight data /// </summary> /// <returns></returns> public HealthRecordItemCollection GetWeightFromHealthVault() { if (!_isProvisioned) { MessageBox.Show("Please provision application first"); return(null); } HealthClientAuthorizedConnection connection = HealthClientApplication.CreateAuthorizedConnection(PersonId); HealthRecordAccessor accessor = new HealthRecordAccessor(connection, RecordId); HealthRecordSearcher searcher = accessor.CreateSearcher(); HealthRecordFilter filter = new HealthRecordFilter(ItemTypes.Weight.TypeId); searcher.Filters.Add(filter); HealthRecordItemCollection items = searcher.GetMatchingItems()[0]; return(items); }
/// <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); }
protected override void ProcessRecord() { HealthClientApplication clientApp = HvShellUtilities.GetClient(); List <PersonInfo> authorizedPeople = new List <PersonInfo> (clientApp.ApplicationConnection.GetAuthorizedPeople()); // Create an authorized connection for each person on the // list. HealthClientAuthorizedConnection authConnection = clientApp.CreateAuthorizedConnection( authorizedPeople[0].PersonId); // Use the authorized connection to read the user's default // health record. HealthRecordAccessor access = new HealthRecordAccessor( authConnection, authConnection.GetPersonInfo().GetSelfRecord().Id); Weight weight = new Weight(); weight.Value = new WeightValue(Value / 2.2, new DisplayValue(Value, "pounds")); access.NewItem(weight); }
private void ContributeCCDAViaRecordAuthorization() { // Note: Applications can store the HealthVault personID and recordID and use this to make offline requests to store new information // in the patient's record whenever new data is available. In this sample, since we don't maintain offline storage (i.e. a DB) to associate // the data source organization's patient identifier with the HealthVault person and record ID, we instead sign-in the user to determine the // person and record ID everytime a request to send a new CCDA to HealthVault happens (i.e. clicking the "Send CCDA to HealthVault" button); PersonInfo pi = WebApplicationUtilities.LoadPersonInfoFromCookie(HttpContext.Current); if (pi == null) { OutputMessage(lblErrorOutput, "Must login first"); return; } // Make the offline call to stor the CCDA in the patient's HealthVault record. OfflineWebApplicationConnection connection = new OfflineWebApplicationConnection(pi.PersonId); HealthRecordAccessor receordAccessor = new HealthRecordAccessor(connection, pi.SelectedRecord.Id); receordAccessor.NewItem(_newCcdaItem); OutputMessage(lblSuccessOutput, "Successfully sent CCDA document to HealthVault via Record Authorization."); }
protected override void ProcessRecord() { HealthClientApplication clientApp = HvShellUtilities.GetClient(); List <PersonInfo> authorizedPeople = new List <PersonInfo> (clientApp.ApplicationConnection.GetAuthorizedPeople()); // Create an authorized connection for each person on the // list. HealthClientAuthorizedConnection authConnection = clientApp.CreateAuthorizedConnection( authorizedPeople[0].PersonId); // Use the authorized connection to read the user's default // health record. HealthRecordAccessor accessor = new HealthRecordAccessor( authConnection, authConnection.GetPersonInfo().GetSelfRecord().Id); HealthServiceRequest request = new HealthServiceRequest(accessor.Connection, "PutThings", 2, accessor); // Read the input file request.Parameters = System.IO.File.ReadAllText(Path.GetFullPath(FileName)); request.Execute(); }
/// <summary> /// Creates new health record items associated with the record. /// </summary> /// /// <param name="connection"> /// The connection to use to access the data. /// </param> /// /// <param name="accessor"> /// The record to use. /// </param> /// /// <param name="items"> /// The health record items from which to create new instances. /// </param> /// /// <remarks> /// This method accesses the HealthVault service across the network. /// </remarks> /// /// <exception cref="HealthServiceException"> /// The HealthVault service returned an error. /// The exception's Error property will contain the index of the /// item on which the failure occurred in the ErrorInfo property. If any failures occur, /// no items will have been created. /// </exception> /// /// <exception cref="ArgumentNullException"> /// At least one HealthRecordItem in the supplied list was null. /// </exception> /// public virtual void NewItems( ApplicationConnection connection, HealthRecordAccessor accessor, IList<HealthRecordItem> items) { Validator.ThrowIfArgumentNull(items, "items", "NewItemsNullItem"); HealthServiceRequest request = new HealthServiceRequest(connection, "PutThings", 2, accessor); StringBuilder infoXml = new StringBuilder(); XmlWriterSettings settings = SDKHelper.XmlUnicodeWriterSettings; using (XmlWriter infoXmlWriter = XmlWriter.Create(infoXml, settings)) { foreach (HealthRecordItem item in items) { Validator.ThrowIfArgumentNull(item, "items", "NewItemsNullItem"); item.WriteItemXml(infoXmlWriter); } infoXmlWriter.Flush(); } // Add the XML to the request. request.Parameters = infoXml.ToString(); // Call the web-service request.Execute(); // Now update the Id for the new item XPathNodeIterator thingIds = request.Response.InfoNavigator.Select( GetThingIdXPathExpression(request.Response.InfoNavigator)); int thingIndex = 0; foreach (XPathNavigator thingIdNav in thingIds) { if (items[thingIndex] != null) { items[thingIndex].Key = new HealthRecordItemKey( new Guid(thingIdNav.Value), new Guid(thingIdNav.GetAttribute( "version-stamp", String.Empty))); } thingIndex++; } }
/// <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 virtual ReadOnlyCollection<HealthRecordItemCollection> GetMatchingItems( ApplicationConnection connection, HealthRecordAccessor accessor, HealthRecordSearcher searcher) { ValidateFilters(searcher); return Execute(connection, accessor, searcher); }
/// <summary> /// Gets the permissions which the authenticated person /// has when using the calling application for the specified item types /// in this record. /// </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 unique identifiers to identify the health record /// item types, for which the permissions are being queried. /// </param> /// /// <returns> /// Returns a dictionary of <see cref="HealthRecordItemTypePermission"/> /// with health record item types as the keys. /// </returns> /// /// <remarks> /// If the list of health record item types is empty, an empty dictionary is /// returned. If for a health record item type, the person has /// neither online access nor offline access permissions, /// <b> null </b> will be returned for that type in the dictionary. /// </remarks> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="healthRecordItemTypeIds"/> is <b>null</b>. /// </exception> /// /// <exception cref="HealthServiceException"> /// If there is an exception during executing the request to HealthVault. /// </exception> /// public virtual IDictionary<Guid, HealthRecordItemTypePermission> QueryPermissionsByTypes( ApplicationConnection connection, HealthRecordAccessor accessor, IList<Guid> healthRecordItemTypeIds) { Validator.ThrowIfArgumentNull(healthRecordItemTypeIds, "healthRecordItemTypeIds", "CtorhealthRecordItemTypeIdsArgumentNull"); Dictionary<Guid, HealthRecordItemTypePermission> permissions = new Dictionary<Guid, HealthRecordItemTypePermission>(); HealthServiceRequest request = new HealthServiceRequest(connection, "QueryPermissions", 1, accessor); for (int i = 0; i < healthRecordItemTypeIds.Count; ++i) { if (!permissions.ContainsKey(healthRecordItemTypeIds[i])) { permissions.Add(healthRecordItemTypeIds[i], null); } } request.Parameters = GetQueryPermissionsParametersXml(healthRecordItemTypeIds); request.Execute(); XPathNavigator infoNav = request.Response.InfoNavigator.SelectSingleNode( GetQueryPermissionsInfoXPathExpression( request.Response.InfoNavigator)); XPathNodeIterator thingTypePermissionsNodes = infoNav.Select("thing-type-permission"); foreach (XPathNavigator nav in thingTypePermissionsNodes) { HealthRecordItemTypePermission thingTypePermissions = HealthRecordItemTypePermission.CreateFromXml(nav); permissions[thingTypePermissions.TypeId] = thingTypePermissions; } return permissions; }
/// <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 virtual string GetTransformedItems( ApplicationConnection connection, HealthRecordAccessor accessor, HealthRecordSearcher searcher, string transform) { Validator.ThrowIfStringNullOrEmpty(transform, "transform"); HealthServiceRequest request = PrepareRequest(connection, accessor, searcher); return request.ExecuteForTransform(transform); }
/// <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 virtual XmlReader GetMatchingItemsReader( ApplicationConnection connection, HealthRecordAccessor accessor, HealthRecordSearcher searcher) { HealthServiceRequest request = PrepareRequest(connection, accessor, searcher); request.Execute(); return request.Response.InfoReader; }
/// <summary> /// Releases the authorization of the application on the health record. /// </summary> /// /// <param name="connection"> /// The connection to use to access the data. /// </param> /// /// <param name="accessor"> /// The record to use. /// </param> /// /// <exception cref="HealthServiceException"> /// Errors during the authorization release. /// </exception> /// /// <remarks> /// Once the application releases the authorization to the health record, /// calling any methods of this <see cref="HealthRecordAccessor"/> will result /// in a <see cref="HealthServiceAccessDeniedException"/>." /// </remarks> public virtual void RemoveApplicationAuthorization( ApplicationConnection connection, HealthRecordAccessor accessor) { HealthServiceRequest request = new HealthServiceRequest(connection, "RemoveApplicationRecordAuthorization", 1, accessor); request.Execute(); }
/// <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 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 HealthRecordItems representing the valid group memberships. /// </returns> /// <exception cref="HealthServiceException"> /// If an error occurs while contacting the HealthVault service. /// </exception> public virtual Collection<HealthRecordItem> GetValidGroupMembership( ApplicationConnection connection, HealthRecordAccessor accessor, IList<Guid> applicationIds) { StringBuilder parameters = new StringBuilder(128); if (applicationIds != null) { XmlWriterSettings settings = SDKHelper.XmlUnicodeWriterSettings; XmlWriter writer = null; try { writer = XmlWriter.Create(parameters, settings); for (int i = 0; i < applicationIds.Count; i++) { writer.WriteElementString( "application-id", applicationIds[i].ToString()); } } finally { if (writer != null) { writer.Flush(); writer.Close(); } writer = null; } } HealthServiceRequest request = new HealthServiceRequest(connection, "GetValidGroupMembership", 1, accessor); request.Parameters = parameters.ToString(); request.Execute(); XPathExpression infoPath = SDKHelper.GetInfoXPathExpressionForMethod( request.Response.InfoNavigator, "GetValidGroupMembership"); XPathNavigator infoNav = request.Response.InfoNavigator.SelectSingleNode(infoPath); Collection<HealthRecordItem> memberships = new Collection<HealthRecordItem>(); XPathNodeIterator membershipIterator = infoNav.Select("thing"); if (membershipIterator != null) { foreach (XPathNavigator membershipNav in membershipIterator) { memberships.Add(ItemTypeManager.DeserializeItem(membershipNav.OuterXml)); } } return memberships; }
/// <summary> /// Executes the search using the filters supplied. /// </summary> /// /// <exception cref="HealthServiceException"> /// The response from the server was anything but /// HealthServiceStatusCode.OK, or no filters have been specified. /// </exception> /// private static ReadOnlyCollection<HealthRecordItemCollection> Execute( ApplicationConnection connection, HealthRecordAccessor accessor, HealthRecordSearcher searcher) { HealthServiceRequest request = PrepareRequest(connection, accessor, searcher); request.Execute(); XmlReader infoReader = request.Response.InfoReader; Collection<HealthRecordItemCollection> result = new Collection<HealthRecordItemCollection>(); if ((infoReader != null) && (infoReader.ReadToDescendant("group"))) { while (infoReader.Name == "group") { XmlReader groupReader = infoReader.ReadSubtree(); groupReader.MoveToContent(); HealthRecordItemCollection resultGroup = HealthRecordItemCollection.CreateResultGroupFromResponse( accessor, groupReader, searcher.Filters); groupReader.Close(); // infoReader will normally be at the end element of // the group at this point, and needs a read to get to // the next element. If the group was empty, infoReader // will be at the beginning of the group, and a // single read will still move to the next element. infoReader.Read(); if (resultGroup != null) { result.Add(resultGroup); } } } return new ReadOnlyCollection<HealthRecordItemCollection>(result); }
/// <summary> /// Creates a <see cref="File"/> item instance using the specified stream and content /// type. /// </summary> /// /// <param name="record"> /// The record to stream the data to. /// </param> /// /// <param name="stream"> /// The stream containing the data to associate with this <see cref="File"/> instance. /// </param> /// /// <param name="name"> /// The name of the file instance. /// </param> /// /// <param name="contentType"> /// The content type of the file. This is usually something like "image/jpg", "application/csv", /// or other mime type. /// </param> /// /// <returns> /// A new instance of the <see cref="File"/> health record item with data populated from the /// specified stream. /// </returns> /// /// <exception cref="ArgumentException"> /// If <paramref name="name"/> is <b>null</b> or empty. /// </exception> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="record"/>, <paramref name="stream"/>, or /// <paramref name="contentType"/> is <b>null</b>. /// </exception> /// /// <exception cref="HealthServiceException"> /// If a failure occurs streaming the data to HealthVault. /// </exception> /// public static File CreateFromStream( HealthRecordAccessor record, Stream stream, String name, CodableValue contentType) { File file = new File(); file.SetContent(record, stream, name, contentType); return file; }
/// <summary> /// Marks the specified health record item as deleted. /// </summary> /// /// <param name="connection"> /// The connection to use to access the data. /// </param> /// /// <param name="accessor"> /// The record to use. /// </param> /// /// <param name="itemsToRemove"> /// The unique item identifiers of the items to remove. /// </param> /// /// <remarks> /// This method accesses the HealthVault service across the network. /// <br/><br/> /// Health record items are never completely deleted. They are marked /// as deleted and are ignored for most normal operations. Items can /// be undeleted by contacting customer service. /// </remarks> /// /// <exception cref="ArgumentException"> /// The <paramref name="itemsToRemove"/> parameter is empty. /// </exception> /// /// <exception cref="HealthServiceException"> /// Errors removed the health record items from the server. /// The exception's Error property will contain the index of the /// item on which the failure occurred in the ErrorInfo property. If any failures occur, /// no items will have been removed. /// </exception> /// public virtual void RemoveItems( ApplicationConnection connection, HealthRecordAccessor accessor, IList<HealthRecordItemKey> itemsToRemove) { Validator.ThrowArgumentExceptionIf( itemsToRemove == null || itemsToRemove.Count == 0, "itemsToRemove", "RemoveItemsListNullOrEmpty"); StringBuilder parameters = new StringBuilder(128 * itemsToRemove.Count); for (int i = 0; i < itemsToRemove.Count; ++i) { parameters.Append("<thing-id version-stamp=\""); parameters.Append(itemsToRemove[i].VersionStamp); parameters.Append("\">"); parameters.Append(itemsToRemove[i].Id); parameters.Append("</thing-id>"); } HealthServiceRequest request = new HealthServiceRequest(connection, "RemoveThings", 1, accessor); request.Parameters = parameters.ToString(); request.Execute(); }
/// <summary> /// Updates the specified health record items in one batch call to /// the service. /// </summary> /// /// <param name="connection"> /// The connection to use to access the data. /// </param> /// /// <param name="accessor"> /// The record to use. /// </param> /// /// <param name="itemsToUpdate"> /// The health record items to be updated. /// </param> /// /// <remarks> /// Only new items are updated with the appropriate unique identifier. /// All other sections must be updated manually. /// <br/><br/> /// This method accesses the HealthVault service across the network. /// </remarks> /// /// <exception cref="ArgumentNullException"> /// The <paramref name="itemsToUpdate"/> parameter is <b>null</b>. /// </exception> /// /// <exception cref="ArgumentException"> /// The <paramref name="itemsToUpdate"/> contains a <b>null</b> member or /// a <see cref="HealthRecordItem"/> instance that does not have an ID. /// </exception> /// /// <exception cref="HealthServiceException"> /// The HealthVault service returned an error. /// The exception's Error property will contain the index of the /// item on which the failure occurred in the ErrorInfo property. If any failures occur, /// no items will have been updated. /// </exception> /// public virtual void UpdateItems( ApplicationConnection connection, HealthRecordAccessor accessor, IList<HealthRecordItem> itemsToUpdate) { Validator.ThrowIfArgumentNull(itemsToUpdate, "itemsToUpdate", "UpdateItemsArgumentNull"); StringBuilder infoXml = new StringBuilder(128); XmlWriterSettings settings = SDKHelper.XmlUnicodeWriterSettings; bool somethingRequiresUpdate = false; using (XmlWriter infoXmlWriter = XmlWriter.Create(infoXml, settings)) { foreach (HealthRecordItem item in itemsToUpdate) { Validator.ThrowIfArgumentNull(item, "items", "UpdateItemsArgumentNull"); Validator.ThrowArgumentExceptionIf( item.Key == null, "itemsToUpdate", "UpdateItemsWithNoId"); if (item.WriteItemXml(infoXmlWriter, false)) { somethingRequiresUpdate = true; } } infoXmlWriter.Flush(); } if (somethingRequiresUpdate) { HealthServiceRequest request = new HealthServiceRequest(connection, "PutThings", 2, accessor); // Add the XML to the request. request.Parameters = infoXml.ToString(); // Call the web-service request.Execute(); XPathNodeIterator thingIds = request.Response.InfoNavigator.Select( GetThingIdXPathExpression(request.Response.InfoNavigator)); int index = 0; foreach (XPathNavigator thingIdNav in thingIds) { HealthRecordItem thing = itemsToUpdate[index]; thing.Key = new HealthRecordItemKey( new Guid(thingIdNav.Value), new Guid(thingIdNav.GetAttribute( "version-stamp", String.Empty))); thing.ClearDirtyFlags(); ++index; } } }
/// <summary> /// Gets the permissions which the authenticated person /// has when using the calling application for the specified item types /// in this health record. /// </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 list of <see cref="HealthRecordItemTypePermission"/> /// objects which represent the permissions that the current /// authenticated person has for the HealthRecordItemTypes specified /// in the current health record when using the current application. /// </returns> /// /// <remarks> /// If the list of health record item types is empty, an empty list is /// returned. If for a health record item type, the person has /// neither online access nor offline access permissions, /// HealthRecordItemTypePermission object is not returned for that /// health record item type. /// </remarks> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="healthRecordItemTypeIds"/> is <b>null</b>. /// </exception> /// /// <exception cref="HealthServiceException"> /// If there is an exception during executing the request to HealthVault. /// </exception> /// public virtual Collection<HealthRecordItemTypePermission> QueryPermissions( ApplicationConnection connection, HealthRecordAccessor accessor, IList<Guid> healthRecordItemTypeIds) { Validator.ThrowIfArgumentNull(healthRecordItemTypeIds, "healthRecordItemTypeIds", "CtorhealthRecordItemTypeIdsArgumentNull"); Collection<HealthRecordItemTypePermission> permissions = new Collection<HealthRecordItemTypePermission>(); HealthServiceRequest request = new HealthServiceRequest(connection, "QueryPermissions", 1, accessor); request.Parameters = GetQueryPermissionsParametersXml(healthRecordItemTypeIds); request.Execute(); XPathNavigator infoNav = request.Response.InfoNavigator.SelectSingleNode( GetQueryPermissionsInfoXPathExpression( request.Response.InfoNavigator)); XPathNodeIterator thingTypePermissionsNodes = infoNav.Select("thing-type-permission"); foreach (XPathNavigator nav in thingTypePermissionsNodes) { HealthRecordItemTypePermission thingTypePermissions = HealthRecordItemTypePermission.CreateFromXml(nav); permissions.Add(thingTypePermissions); } return permissions; }
/// <summary> /// Sets the content of the file instance using the specified stream. /// </summary> /// /// <param name="stream"> /// The stream containing the data to associate with this <see cref="File"/> instance. /// </param> /// /// <param name="record"> /// The record to stream the data to. /// </param> /// /// <param name="name"> /// The name of the file instance. /// </param> /// /// <param name="contentType"> /// The content type of the file. /// </param> /// /// <exception cref="ArgumentException"> /// If <paramref name="name"/> is <b>null</b> or empty. /// </exception> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="record"/>, <paramref name="stream"/> or <paramref name="contentType"/> is <b>null</b>. /// </exception> /// /// <exception cref="HealthServiceException"> /// If a failure occurs streaming the data to HealthVault. /// </exception> /// public void SetContent( HealthRecordAccessor record, Stream stream, String name, CodableValue contentType) { Validator.ThrowIfArgumentNull(record, "record", "FileRecordMustBeSpecified"); Validator.ThrowIfArgumentNull(stream, "stream", "FileStreamMustBeSpecified"); Validator.ThrowIfStringNullOrEmpty(name, "name"); Validator.ThrowIfArgumentNull(contentType, "contentType", "FileContentTypeMustBeSpecified"); if (stream.CanSeek) { Size = stream.Length; } Name = name; ContentType = contentType; BlobStore store = GetBlobStore(record); Blob blob = store.NewBlob(String.Empty, ContentType.Text); blob.Write(stream); }
/// <summary> /// Disassociates an alternate ID with a record. /// </summary> /// /// <param name="connection"> /// The connection to use to access the data. /// </param> /// /// <param name="accessor"> /// The record to use. /// </param> /// /// <param name="alternateId"> /// The alternate ID. /// </param> /// /// <remarks> /// This method accesses the HealthVault service across the network. /// </remarks> /// /// <exception cref="ArgumentNullException"> /// The connection, accessor, or alternateId parameters are null. /// </exception> /// /// <exception cref="ArgumentException"> /// The alternateId parameter is empty, all whitespace, or more than 255 characters in length. /// </exception> /// /// <exception cref="HealthServiceException"> /// The HealthVault service returned an error. /// If the alternate Id is not associated with a person and record id, the ErrorCode property /// will be set to AlternateIdNotFound. /// </exception> /// public virtual void DisassociateAlternateId( ApplicationConnection connection, HealthRecordAccessor accessor, string alternateId) { Validator.ThrowIfArgumentNull(connection, "connection", "AlternateIdConnectionNull"); Validator.ThrowIfArgumentNull(accessor, "accessor", "AccessorNull"); Validator.ThrowIfArgumentNull(alternateId, "alternateId", "AlternateIdNull"); Validator.ThrowIfStringIsEmptyOrWhitespace(alternateId, "alternateId"); Validator.ThrowArgumentExceptionIf(alternateId.Length > 255, "alternateId", "AlternateIdTooLong"); HealthServiceRequest request = new HealthServiceRequest(connection, "DisassociateAlternateId", 1, accessor); request.Parameters = "<alternate-id>" + alternateId + "</alternate-id>"; request.Execute(); }
/// <summary> /// Gets the request object including the necessary parameters for /// the "GetThings" request. /// </summary> /// /// <returns> /// The request object for the thing search with the parameters filled /// in. /// </returns> /// /// <exception cref="HealthServiceException"> /// No filters have been specified. /// </exception> /// private static HealthServiceRequest PrepareRequest( ApplicationConnection connection, HealthRecordAccessor accessor, HealthRecordSearcher searcher) { HealthServiceRequest request = new HealthServiceRequest(connection, "GetThings", 3, accessor); request.Parameters = GetParametersXml(searcher); return request; }
/// <summary> /// Gets the list of alternate IDs that are associated with a record. /// </summary> /// /// <param name="connection"> /// The connection to use to access the data. /// </param> /// /// <param name="accessor"> /// The record to use. /// </param> /// /// <remarks> /// This method accesses the HealthVault service across the network. /// </remarks> /// /// <exception cref="HealthServiceException"> /// The HealthVault service returned an error. /// If the alternate Id is not associated with a person and record id, the ErrorCode property /// will be set to AlternateIdNotFound. /// </exception> /// public virtual Collection<string> GetAlternateIds( ApplicationConnection connection, HealthRecordAccessor accessor) { HealthServiceRequest request = new HealthServiceRequest(connection, "GetAlternateIds", 1, accessor); request.Execute(); Collection<string> alternateIds = new Collection<string>(); XPathNavigator infoNav = request.Response.InfoNavigator.SelectSingleNode( SDKHelper.GetInfoXPathExpressionForMethod( request.Response.InfoNavigator, "GetAlternateIds")); // Get the alternate ids that came back XPathNodeIterator alternateIdsNav = infoNav.Select("alternate-ids/alternate-id"); foreach (XPathNavigator alternateIdNode in alternateIdsNav) { alternateIds.Add(alternateIdNode.Value); } return alternateIds; }