/// <summary> /// Allows derived classes to construct an instance of themselves given /// an instance of the base class. /// </summary> /// /// <param name="personInfo"> /// Information about the person for constructing the instance. /// </param> /// internal PersonInfo(PersonInfo personInfo) { _connection = personInfo._connection; _personId = personInfo._personId; _name = personInfo._name; _selectedRecordId = personInfo._selectedRecordId; }
/// <summary> /// Creates a new instance of the <see cref="HealthRecordAccessor"/> /// class. /// </summary> /// /// <param name="connection"> /// An instance of a connection to which the record /// operations will be directed. /// </param> /// /// <param name="id"> /// The unique identifier for the record. /// </param> /// /// <remarks> /// This constructor creates a view of a personal health record. /// </remarks> /// <exception cref="ArgumentNullException"> /// The <paramref name="connection"/> parameter is <b>null</b>. /// </exception> /// /// <exception cref="ArgumentException"> /// The <paramref name="id"/> parameter is Guid.Empty. /// </exception> /// public HealthRecordAccessor( ApplicationConnection connection, Guid id) { Validator.ThrowIfArgumentNull(connection, "connection", "CtorServiceArgumentNull"); Validator.ThrowArgumentExceptionIf( id == Guid.Empty, "id", "CtorIDArgumentEmpty"); _connection = connection; _recordId = id; }
/// <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 static Collection<HealthRecordItem> GetValidGroupMembership( ApplicationConnection connection, HealthRecordAccessor accessor, IList<Guid> applicationIds) { return HealthVaultPlatformRecord.Current.GetValidGroupMembership(connection, accessor, applicationIds); }
/// <summary> /// Look up the record that were /// previously associated with this alternate id. /// </summary> /// /// <remarks> /// To obtain the person and record info, use <see cref="PersonInfo.GetFromAlternateId"/>. /// </remarks> /// /// <returns> /// A new instance of <see cref="HealthRecordInfo"/> that can be used to access the /// record. /// </returns> /// /// <param name="connection">The application connection to use.</param> /// <param name="alternateId">The alternateId to look up.</param> /// <returns>A HealthRecordInfo that can be used to access the record.</returns> /// /// <exception cref="ArgumentNullException"> /// The alternateId parameter is 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 static HealthRecordInfo GetFromAlternateId( ApplicationConnection connection, string alternateId) { PersonInfo personInfo = HealthVaultPlatform.GetPersonAndRecordForAlternateId(connection, alternateId); if (personInfo.AuthorizedRecords != null && personInfo.AuthorizedRecords.Count == 1) { List<HealthRecordInfo> infos = new List<HealthRecordInfo>(personInfo.AuthorizedRecords.Values); return infos[0]; } else { return null; } }
/// <summary> /// Creates a new instance of the <see cref="HealthRecordInfo"/> class /// for deserialization purposes. /// </summary> /// /// <param name="connection"> /// An instance of a <see cref="Microsoft.Health.ApplicationConnection"/> /// to which the record operations are directed. /// </param> /// /// <remarks> /// This constructor is only useful if ParseXml is called. /// </remarks> /// /// <exception cref="ArgumentNullException"> /// The <paramref name="connection"/> parameter is <b>null</b>. /// </exception> /// internal HealthRecordInfo(ApplicationConnection connection) : base(connection) { }
private void ParseXml(XPathNavigator navigator, bool includeUrl) { _personId = new Guid(navigator.SelectSingleNode("person-id").Value); _name = navigator.SelectSingleNode("name").Value; XPathNavigator navAppSettings = navigator.SelectSingleNode("app-settings"); if (navAppSettings != null) { XmlDocument doc = new XmlDocument(); doc.LoadXml(navAppSettings.OuterXml); _appSettings = doc; } XPathNavigator navSelectedRecordId = navigator.SelectSingleNode("selected-record-id"); if (navSelectedRecordId != null) { _selectedRecordId = new Guid(navSelectedRecordId.Value); } XPathNavigator navPreferredCulture = navigator.SelectSingleNode("preferred-culture[language != '']"); if (navPreferredCulture != null) { _preferredCulture = null; XPathNavigator navLanguageCode = navPreferredCulture.SelectSingleNode("language"); { _preferredCulture = navLanguageCode.Value; // Country code only matters if the language code is present. XPathNavigator navCountryCode = navPreferredCulture.SelectSingleNode("country"); if (navCountryCode != null) { _preferredCulture += "-" + navCountryCode.Value; } } } XPathNavigator navPreferredUICulture = navigator.SelectSingleNode("preferred-uiculture[language != '']"); if (navPreferredUICulture != null) { _preferredUICulture = null; XPathNavigator navLanguageCode = navPreferredUICulture.SelectSingleNode("language"); { _preferredUICulture = navLanguageCode.Value; // Country code only matters if the language code is present. XPathNavigator navCountryCode = navPreferredUICulture.SelectSingleNode("country"); if (navCountryCode != null) { _preferredUICulture += "-" + navCountryCode.Value; } } } XPathNavigator connectionNav = navigator.SelectSingleNode("connection"); if (connectionNav != null) { Guid appId = new Guid(connectionNav.SelectSingleNode("app-id").Value); Uri healthServiceUri = null; if (includeUrl) { healthServiceUri = new Uri(connectionNav.SelectSingleNode("wildcat-url").Value); } else { healthServiceUri = HealthApplicationConfiguration.Current.HealthVaultMethodUrl; } XPathNavigator credNav = connectionNav.SelectSingleNode("credential"); if (credNav != null) { Credential cred = Credential.CreateFromCookieXml(credNav); _connection = new AuthenticatedConnection(appId, healthServiceUri, cred); } XPathNavigator compressionNode = connectionNav.SelectSingleNode("request-compression-method"); if (compressionNode != null) { _connection.RequestCompressionMethod = compressionNode.Value; } } else { Validator.ThrowInvalidIfNull(_connection, "PersonInfoConnectionNull"); } XPathNodeIterator recordsNav = navigator.Select("record"); foreach (XPathNavigator recordNav in recordsNav) { // Now see if we can fill in the record information HealthRecordInfo record = HealthRecordInfo.CreateFromXml( ApplicationConnection, recordNav); if (record != null) { _authorizedRecords.Add(record.Id, record); } } XPathNavigator navMoreRecords = navigator.SelectSingleNode("more-records"); if (navMoreRecords != null) { _moreRecords = true; } XPathNavigator navMoreAppSettings = navigator.SelectSingleNode("more-app-settings"); if (navMoreAppSettings != null) { _moreAppSettings = true; } }
private HealthRecordItemDataTableView ApplyEffectiveView( ApplicationConnection connection) { HealthRecordItemDataTableView effectiveView = HealthRecordItemDataTableView.MultipleTypeTable; HealthRecordItemTypeDefinition typeDefinition = null; if (Filter.TypeIds.Count == 1 && View != HealthRecordItemDataTableView.MultipleTypeTable) { typeDefinition = ItemTypeManager.GetHealthRecordItemTypeDefinition( this.Filter.TypeIds[0], connection); if (typeDefinition != null && typeDefinition.ColumnDefinitions.Count > 0) { effectiveView = HealthRecordItemDataTableView.SingleTypeTable; _singleTypeDefinition = typeDefinition; foreach ( ItemTypeDataColumn column in typeDefinition.ColumnDefinitions) { _displayColumns.Add( column.ColumnName, column.Clone()); } this.Filter.View.TransformsToApply.Clear(); this.Filter.View.TransformsToApply.Add("stt"); } } if (_singleTypeDefinition == null) { typeDefinition = ItemTypeManager.GetBaseHealthRecordItemTypeDefinition( connection); effectiveView = HealthRecordItemDataTableView.MultipleTypeTable; foreach ( ItemTypeDataColumn column in typeDefinition.ColumnDefinitions) { _displayColumns.Add(column.ColumnName, column.Clone()); } this.Filter.View.TransformsToApply.Clear(); this.Filter.View.TransformsToApply.Add("mtt"); } return effectiveView; }
/// <summary> /// Updates the application's configuration in HealthVault. /// </summary> /// /// <param name="connection"> /// The connection to use to make the update. /// </param> /// /// <param name="applicationInfo"> /// The updated <see cref="ApplicationInfo"/> instance. /// </param> /// /// <remarks> /// This method makes a remote call to the HealthVault service. /// The calling application in the <paramref name="connection"/> must be the same as /// the application specified by this ApplicationInfo instance or its master application. /// Note, this update will replace all configuration elements for the application. It is /// advised that <see cref="ApplicationProvisioning.Provisioner.GetApplication"/> is /// called to retrieve the existing application configuration before changing values and /// calling Update. /// </remarks> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="connection"/> is <b>null</b>. /// </exception> /// /// <exception cref="HealthServiceException"> /// The HealthVault service returns an error. /// </exception> /// public static void UpdateChildApplication( ApplicationConnection connection, ApplicationInfo applicationInfo) { HealthVaultPlatformProvisioning.Current.UpdateChildApplication(connection, applicationInfo); }
/// <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 static void UpdateItems( ApplicationConnection connection, HealthRecordAccessor accessor, IList<HealthRecordItem> itemsToUpdate) { HealthVaultPlatformItem.Current.UpdateItems(connection, accessor, itemsToUpdate); }
/// <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 static void RemoveItems( ApplicationConnection connection, HealthRecordAccessor accessor, IList<HealthRecordItemKey> itemsToRemove) { HealthVaultPlatformItem.Current.RemoveItems(connection, accessor, itemsToRemove); }
/// <summary> /// Removes the saved open query from the server. /// </summary> /// /// <param name="connection"> /// The connection instance to use to remove the <see cref="OpenQuery"/>. /// </param> /// /// <param name="id"> /// The id of the open query to remove. /// </param> /// /// <remarks> /// The person authenticated with the <paramref name="connection"/> /// must have permission to remove the open query. /// </remarks> /// /// <exception cref="ArgumentNullException"> /// The <paramref name="connection"/> parameter is <b>null</b>. /// </exception> /// /// <exception cref="HealthServiceException"> /// An error occurred when HealthVault processed the request. /// </exception> /// public static void RemoveOpenQuery( ApplicationConnection connection, Guid id) { HealthVaultPlatformOpenQuery.Current.RemoveOpenQuery(connection, id); }
/// <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 static void RemoveApplicationAuthorization( ApplicationConnection connection, HealthRecordAccessor accessor) { HealthVaultPlatformRecord.Current.RemoveApplicationAuthorization(connection, accessor); }
/// <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 static IDictionary<Guid, HealthRecordItemTypePermission> QueryPermissionsByTypes( ApplicationConnection connection, HealthRecordAccessor accessor, IList<Guid> healthRecordItemTypeIds) { return HealthVaultPlatformRecord.Current.QueryPermissionsByTypes(connection, accessor, healthRecordItemTypeIds); }
/// <summary> /// Creates a new open query using the specified /// connection, definition, expiration time, /// personal identification number (PIN), description, and XSL. /// </summary> /// /// <param name="connection"> /// An <see cref="ApplicationConnection"/> instance that creates the /// new open query. /// </param> /// /// <param name="searcher"> /// A <see cref="HealthRecordSearcher"/> instance that defines the open query. /// </param> /// /// <param name="expires"> /// The number of minutes the query will expire from the creation time. /// A value of Int32.MaxValue denotes that the query does not expire. /// </param> /// /// <param name="pinCode"> /// The PIN that protects the query. /// </param> /// /// <param name="note"> /// The note describing the query. /// </param> /// /// <param name="finalXsl"> /// The XSL that transforms the results of the query when the /// <see cref="OpenQuery"/> is invoked. /// </param> /// /// <returns> /// An <see cref="OpenQuery"/> instance that represents the newly created query. /// </returns> /// /// <remarks> /// The creation of an open query makes public the data returned by that /// query. However, the query URL must be known to retrieve the data. /// </remarks> /// /// <exception cref="ArgumentNullException"> /// The <paramref name="connection"/> or <paramref name="searcher"/> /// parameter is <b>null</b>. /// </exception> /// /// /// <exception cref="ArgumentException"> /// The <paramref name="searcher"/> parameter contains no valid search /// filters or the <paramref name="pinCode"/> parameter is <b>null</b> /// or empty. /// </exception> /// /// <exception cref="HealthServiceException"> /// An error occurred when HealthVault processed the request. /// </exception> /// public static OpenQuery NewOpenQuery( ApplicationConnection connection, HealthRecordSearcher searcher, int expires, string pinCode, string note, string finalXsl) { return HealthVaultPlatformOpenQuery.Current.NewOpenQuery( connection, searcher, expires, pinCode, note, finalXsl); }
/// <summary> /// Updates the application's configuration in HealthVault. /// </summary> /// /// <param name="connection"> /// The connection to use to call HealthVault. /// </param> /// /// <remarks> /// This method makes a remote call to the HealthVault service. /// The calling application in the <paramref name="connection"/> must be the same as /// the application specified by this ApplicationInfo instance or its master application. /// Note, this update will replace all configuration elements for the application. It is /// advised that <see cref="ApplicationProvisioning.Provisioner.GetApplication"/> is /// called to retrieve the existing application configuration before changing values and /// calling Update. /// </remarks> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="connection"/> is <b>null</b>. /// </exception> /// /// <exception cref="InvalidOperationException"> /// If <see cref="Id"/> is <see cref="Guid.Empty"/>. /// </exception> /// /// <exception cref="HealthServiceException"> /// The HealthVault service returns an error. /// </exception> /// public void Update(ApplicationConnection connection) { HealthVaultPlatform.UpdateChildApplication(connection, this); }
/// <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 static void DisassociateAlternateId( ApplicationConnection connection, HealthRecordAccessor accessor, string alternateId) { HealthVaultPlatformAlternateId.Current.DisassociateAlternateId(connection, accessor, alternateId); }
/// <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 void GetData( Guid recordId, ApplicationConnection connection) { HealthRecordAccessor record = new HealthRecordAccessor(connection, recordId); GetData(record); }
/// <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 static Collection<string> GetAlternateIds( ApplicationConnection connection, HealthRecordAccessor accessor) { return HealthVaultPlatformAlternateId.Current.GetAlternateIds(connection, accessor); }
/// <summary> /// Constructs a HealthRecordAccessor for deserialization purposes. /// </summary> /// /// <param name="connection"> /// An instance of a connection to which the record /// operations will be directed. /// </param> /// /// <remarks> /// This constructor is useful only if ParseXml is called. /// </remarks> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="connection"/> is <b>null</b>. /// </exception> /// internal HealthRecordAccessor( ApplicationConnection connection) { _connection = connection; }
/// <summary> /// Gets information about people authorized for an application. /// </summary> /// /// <remarks> /// The returned IEnumerable iterator will access the HealthVault service /// across the network. See <see cref="GetAuthorizedPeopleSettings"/> for applicable /// settings. /// </remarks> /// /// <param name="connection">The connection to use to perform the operation. This connection /// must be application-level. </param> /// /// <param name="settings"> /// The <see cref="GetAuthorizedPeopleSettings" /> object used to configure the /// IEnumerable iterator returned by this method. /// </param> /// /// <returns> /// An IEnumerable iterator of <see cref="PersonInfo"/> objects representing /// people authorized for the application. /// </returns> /// /// <exception cref="HealthServiceException"> /// The HealthVault service returned an error. The retrieval can be retried from the /// current position by calling this method again and using the last successfully /// retrieved person Id for <see cref="GetAuthorizedPeopleSettings.StartingPersonId"/>. /// </exception> /// /// <exception cref="ArgumentNullException"> /// <paramref name="settings"/> is null. /// </exception> /// public static IEnumerable<PersonInfo> GetAuthorizedPeople( ApplicationConnection connection, GetAuthorizedPeopleSettings settings) { return HealthVaultPlatformApplication.Current.GetAuthorizedPeople(connection, settings); }
/// <summary> /// Look up the person and record that were /// previously associated with this alternate id. /// </summary> /// /// <remarks> /// To obtain the record info only, use <see cref="HealthRecordInfo.GetFromAlternateId"/>. /// </remarks> /// /// <returns> /// A new instance of <see cref="PersonInfo"/> containing information /// about the associated person and record. /// </returns> /// /// <param name="connection">The application connection to use.</param> /// <param name="alternateId">The alternateId to look up.</param> /// <returns>A <see cref="PersonInfo"/> with information /// about the person and record.</returns> /// /// <exception cref="ArgumentNullException"> /// The connection, 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 static PersonInfo GetFromAlternateId( ApplicationConnection connection, string alternateId) { return HealthVaultPlatform.GetPersonAndRecordForAlternateId(connection, alternateId); }
/// <summary> /// Gets the <see cref="HealthRecordInfo"/> for the records identified /// by the specified <paramref name="recordIds"/>. /// </summary> /// /// <param name="connection">The connection to use to perform the operation. This connection /// must be authenticated. </param> /// /// <param name="recordIds"> /// The unique identifiers for the records to retrieve. /// </param> /// /// <returns> /// A collection of the records matching the specified record /// identifiers and authorized for the authenticated person. /// </returns> /// /// <remarks> /// This method is useful in cases where the application is storing /// record identifiers and needs access to the functionality provided /// by the object model. /// </remarks> /// public static Collection<HealthRecordInfo> GetAuthorizedRecords( ApplicationConnection connection, IList<Guid> recordIds) { return HealthVaultPlatformPerson.Current.GetAuthorizedRecords(connection, recordIds); }
/// <summary> /// Creates a new instance of the PersonInfo class using /// the specified XML. /// </summary> /// /// <param name="connection"> /// An <see cref="ApplicationConnection"/> for the current user. The /// connection can be optionally supplied, but it is overwritten if /// the connection information is in the XML. /// </param> /// /// <param name="navigator"> /// The XML containing the person information. /// </param> /// /// <returns> /// A new instance of <see cref="PersonInfo"/> populated with the /// person information. /// </returns> /// /// <exception cref="ArgumentNullException"> /// The <paramref name="navigator"/> parameter is <b>null</b> or /// <paramref name="connection"/> is <b>null</b> and the XML does not /// contain the connection information. /// </exception> /// internal static PersonInfo CreateFromXmlExcludeUrl( ApplicationConnection connection, XPathNavigator navigator) { Validator.ThrowIfNavigatorNull(navigator); PersonInfo personInfo = new PersonInfo(connection); personInfo.ParseXmlExcludeUrl(navigator); return personInfo; }
/// <summary> /// Gets the health record items that match the filters as specified by /// the properties of this class. /// </summary> /// /// <param name="connection"> /// The connection to use to access the data. /// </param> /// /// <param name="accessor"> /// The record to use. /// </param> /// /// <param name="searcher"> /// The searcher that defines what items to return. . /// </param> /// /// <returns> /// A collection of health record items that match the applied filters. /// </returns> /// /// <remarks> /// This method accesses the HealthVault service across the network. /// </remarks> /// /// <exception cref="HealthServiceException"> /// The response from the server was anything but /// <see cref="HealthServiceStatusCode.Ok"/>. /// -or- /// <see cref="Microsoft.Health.HealthRecordSearcher.Filters"/> is empty /// or contains invalid filters. /// </exception> /// public static ReadOnlyCollection<HealthRecordItemCollection> GetMatchingItems( ApplicationConnection connection, HealthRecordAccessor accessor, HealthRecordSearcher searcher) { return HealthVaultPlatformItem.Current.GetMatchingItems(connection, accessor, searcher); }
/// <summary> /// Constructs an empty <see cref="PersonInfo"/> object which can be used to /// deserialize person info XML. /// </summary> /// /// <param name="connection"> /// The connection the <see cref="PersonInfo"/> object should use for operations /// once it has been deserialized. /// </param> /// /// <exception cref="ArgumentNullException"> /// The <paramref name="connection"/> is <b>null</b>. /// </exception> /// internal PersonInfo(ApplicationConnection connection) { _connection = connection; }
/// <summary> /// Gets the health record items that match the filters as specified by /// the properties of this class. /// </summary> /// /// <param name="connection"> /// The connection to use to access the data. /// </param> /// /// <param name="accessor"> /// The record to use. /// </param> /// /// <param name="searcher"> /// The searcher that defines what items to return. /// </param> /// /// <returns> /// An XPathNavigator representing the raw results of the search. /// </returns> /// /// <remarks> /// This method accesses the HealthVault service across the network. /// <br/><br/> /// This method is typically used when the calling application wants to /// handle the raw health record item XML directly instead of using the /// object model. /// </remarks> /// public static XPathNavigator GetMatchingItemsRaw( ApplicationConnection connection, HealthRecordAccessor accessor, HealthRecordSearcher searcher) { return HealthVaultPlatformItem.Current.GetMatchingItemsRaw(connection, accessor, searcher); }
/// <summary> /// Creates an instance of a HealthRecordInfo object using /// the specified XML. /// </summary> /// /// <param name="connection"> /// A connection for the current user. /// </param> /// /// <param name="navigator"> /// The XML containing the record information. /// </param> /// /// <returns> /// A new instance of a HealthRecordInfo object populated with the /// record information. /// </returns> /// /// <exception cref="ArgumentNullException"> /// The <paramref name="connection"/> or <paramref name="navigator"/> /// parameter is <b>null</b>. /// </exception> /// public static new HealthRecordInfo CreateFromXml( ApplicationConnection connection, XPathNavigator navigator) { Validator.ThrowIfArgumentNull(connection, "connection", "PersonInfoConnectionNull"); Validator.ThrowIfArgumentNull(navigator, "navigator", "ParseXmlNavNull"); HealthRecordInfo recordInfo = new HealthRecordInfo(connection); recordInfo.ParseXml(navigator); return recordInfo; }
/// <summary> /// Gets the health record items that match the filters as specified by /// the properties of this class. /// </summary> /// /// <param name="connection"> /// The connection to use to access the data. /// </param> /// /// <param name="accessor"> /// The record to use. /// </param> /// /// <param name="searcher"> /// The searcher that defines what items to return. /// </param> /// /// <returns> /// An XmlReader representing the raw results of the search. /// </returns> /// /// <remarks> /// This method accesses the HealthVault service across the network. /// <br/><br/> /// This method is typically used when the calling application wants to /// handle the raw health record item XML directly instead of using the /// object model. /// </remarks> /// public static XmlReader GetMatchingItemsReader( ApplicationConnection connection, HealthRecordAccessor accessor, HealthRecordSearcher searcher) { return HealthVaultPlatformItem.Current.GetMatchingItemsReader(connection, accessor, searcher); }
/// <summary> /// Creates a new instance of the <see cref="HealthRecordInfo"/> class, /// providing a new view of a personal health record. /// </summary> /// /// <param name="connection"> /// An instance of a <see cref="Microsoft.Health.ApplicationConnection"/> /// to which the record operations are directed. /// </param> /// /// <param name="id"> /// The unique identifier for the record. /// </param> /// /// <remarks> /// With this constructor, none of the data held in the properties /// is valid except the /// <see cref="Microsoft.Health.HealthRecordAccessor.Id"/> /// property. The ID is not validated with the service and the data /// is not retrieved until /// <see cref="Microsoft.Health.HealthRecordInfo.Refresh"/> /// is called. However, any of the methods can be called without /// Update being called. /// </remarks> /// /// <exception cref="ArgumentNullException"> /// The <paramref name="connection"/> parameter is <b>null</b>. /// </exception> /// /// <exception cref="ArgumentException"> /// The <paramref name="id"/> parameter is Guid.Empty. /// </exception> /// public HealthRecordInfo( ApplicationConnection connection, Guid id) : base(connection, id) { }
/// <summary> /// Gets the health record items specified by the /// <see cref="HealthRecordSearcher"/> and runs them through the specified /// transform. /// </summary> /// /// <param name="connection"> /// The connection to use to access the data. /// </param> /// /// <param name="accessor"> /// The record to use. /// </param> /// /// <param name="searcher"> /// The searcher that defines what items to return. /// </param> /// /// <param name="transform"> /// A URL to a transform to run on the resulting XML. This can be /// a fully-qualified URL or the name of one of the standard XSLs /// provided by the HealthVault system. /// </param> /// /// <returns> /// The string resulting from performing the specified transform on /// the XML representation of the items. /// </returns> /// /// <remarks> /// This method accesses the HealthVault service across the network. /// <br/><br/> /// Any call to HealthVault may specify a transform to be run on the /// response XML. The transform can be specified as a XSL fragment or /// a well-known transform tag provided by the HealthVault service. If a /// XSL fragment is specified, it gets compiled and cached on the server. /// <br/> /// <br/> /// A final-xsl is useful when you want to convert the result from XML to /// HTML so that you can display the result directly in a web page. /// You may also use it to generate other data formats like CCR, CCD, CSV, /// RSS, etc. /// <br/> /// <br/> /// Transform fragments cannot contain embedded script. The following set /// of parameters are passed to all final-xsl transforms:<br/> /// <ul> /// <li>currentDateTimeUtc - the date and time just before the transform /// started executing</li> /// <li>requestingApplicationName - the name of the application that /// made the request to HealthVault.</li> /// <li>countryCode - the ISO 3166 country code from the request.</li> /// <li>languageCode - the ISO 639-1 language code from the request.</li> /// <li>personName - the name of the person making the request.</li> /// <li>recordName - if the request identified a HealthVault record to /// be used, this parameter contains the name of that record.</li> /// </ul> /// </remarks> /// /// <exception cref="ArgumentException"> /// The <paramref name="transform"/> parameter is <b>null</b> or empty. /// </exception> /// /// <exception cref="ArgumentException"> /// <see cref="Microsoft.Health.HealthRecordView.Sections"/> does not /// contain the XML section in the view. /// </exception> /// /// <exception cref="HealthServiceException"> /// There is a failure retrieving the items. /// -or- /// No filters have been specified. /// </exception> /// public static string GetTransformedItems( ApplicationConnection connection, HealthRecordAccessor accessor, HealthRecordSearcher searcher, string transform) { return HealthVaultPlatformItem.Current.GetTransformedItems(connection, accessor, searcher, transform); }