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> /// Obtains Weight objects from HealthVault /// </summary> /// <returns></returns> public override async Task Initialize(NavigationParams navParams) { //Save the connection so that we can reuse it for updates later _connection = navParams.Connection; HealthRecordInfo recordInfo = (await _connection.GetPersonInfoAsync()).SelectedRecord; IThingClient thingClient = _connection.CreateThingClient(); if (QueryTimeframe.SelectedIndex == (int)QueryTimeframeEnum.Default) { //Uses a simple query which specifies the Thing type as the only filter Items = await thingClient.GetThingsAsync <Weight>(recordInfo.Id); } else if (QueryTimeframe.SelectedIndex == (int)QueryTimeframeEnum.Last30d) { //In this mode, the app specifies a ThingQuery which can be used for functions like //filtering, or paging through values ThingQuery query = new ThingQuery() { EffectiveDateMin = DateTime.Now.AddDays(-30) }; Items = await thingClient.GetThingsAsync <Weight>(recordInfo.Id, query); } OnPropertyChanged("Items"); OnPropertyChanged("Latest"); return; }
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)); }
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); }
private ThingQuery GetWeightThingQuery() { var config = Substitute.For <HealthVaultConfiguration>(); var query = new ThingQuery(config); query.ItemIds.Add(Weight.TypeId); return(query); }
public async Task <ThingCollection> GetThingsAsync(Guid recordId, ThingQuery query) { Validator.ThrowIfGuidEmpty(recordId, nameof(recordId)); Validator.ThrowIfArgumentNull(query, nameof(query)); IReadOnlyCollection <ThingCollection> resultSet = await this.GetThingsAsync(recordId, new[] { query }).ConfigureAwait(false); return(resultSet.FirstOrDefault()); }
public void Should_get_all(ThingQuery.GetAll request) { // Arrange // Act var result = _mediator.SendAsync(request).Result; // Assert result.Count.ShouldEqual(4); }
public void Should_get_all(ThingQuery.GetAll request) { // Arrange // Act var response = _httpClient.GetAsync("/api/thing").Result; // Assert response.StatusCode.ShouldEqual(HttpStatusCode.OK); }
public void Should_get_one(ThingQuery.GetById request) { // Arrange request.Id = "my-first"; // Act var result = _mediator.SendAsync(request).Result; // Assert result.Id.ShouldEqual(request.Id); }
/// <summary> /// Creates a new instance of the <see cref="ThingDataTable"/> /// class with the specified table view and filter. /// </summary> /// /// <param name="view"> /// The view that the data table should take on the data. /// </param> /// /// <param name="query"> /// The filter used to gather things from the HealthVault /// service. /// </param> /// /// <exception cref="ArgumentNullException"> /// The <paramref name="query"/> parameter is <b>null</b>. /// </exception> /// /// <exception cref="ArgumentException"> /// The <paramref name="view"/> parameter is /// <see cref="ThingDataTableView.SingleTypeTable"/> and /// the <paramref name="query"/> parameter contains more than one type /// identifier. /// </exception> public ThingDataTable( ThingDataTableView view, ThingQuery query) { Validator.ThrowIfArgumentNull(query, nameof(query), Resources.DataTableFilterNull); if (view == ThingDataTableView.SingleTypeTable && query.TypeIds.Count > 1) { throw new ArgumentException(Resources.DataTableViewInvalid, nameof(view)); } this.query = query; _view = view; }
public async Task GetThings() { InitializeResponse(SampleUtils.GetSampleContent("ThingsSampleBloodPressure.xml")); ThingQuery query = this.GetBloodPressureThingQuery(); var result = await _client.GetThingsAsync(_recordId, query); // ensure that the connection was called with the proper values await _connection.Received().ExecuteAsync( HealthVaultMethods.GetThings, Arg.Any <int>(), Arg.Is <string>(x => x.Contains(BloodPressure.TypeId.ToString())), Arg.Is <Guid>(x => x == _recordId)); // Assert that all results are parsed, grouped, and returned correctly. // Note that the sample data was not from this exact call, so it includes some other types of things in the results Assert.AreEqual(33, result.Count); }
/// <summary> /// Gets the user's PersonalImage Things and then calls GetAndSavePersonalImage to extract the blob, /// save to disk, then adds that path to the ImageSource property so the UX can find it. /// </summary> /// <param name="recordInfo"></param> /// <param name="thingClient"></param> /// <returns></returns> private async Task GetPersonalImageAsync(HealthRecordInfo recordInfo, IThingClient thingClient) { //Build query var query = new ThingQuery(new Guid[] { PersonalImage.TypeId }); query.View.Sections = ThingSections.Xml | ThingSections.BlobPayload | ThingSections.Signature; var things = await thingClient.GetThingsAsync(recordInfo.Id, query); if (things.Count > 0) { Windows.Storage.StorageFile file = await GetAndSavePersonalImage(recordInfo, things); ImageSource = file.Path; OnPropertyChanged("ImageSource"); } }
public void Should_throw_ex_when_id_not_exists(ThingQuery.GetById request) { try { // Arrange // Act _mediator.SendAsync(request).Wait(); } catch (AggregateException ex) { // Assert ex.InnerException.ShouldBeType(typeof (EntityNotFound)); return; } throw new AssertException(); }
public override async Task Initialize(NavigationParams navParams) { HealthRecordInfo recordInfo = (await navParams.Connection.GetPersonInfoAsync()).SelectedRecord; IThingClient thingClient = navParams.Connection.CreateThingClient(); var query = new ThingQuery(new Guid[] { BloodGlucose.TypeId, Weight.TypeId, BloodPressure.TypeId, CholesterolProfile.TypeId, LabTestResults.TypeId, Immunization.TypeId, Procedure.TypeId, Allergy.TypeId, Condition.TypeId }); var items = await thingClient.GetThingsAsync(recordInfo.Id, query); //Create a grouped view of the Things by type Groups = from colItem in items orderby(colItem as ThingBase).TypeName, (colItem as ThingBase).EffectiveDate descending group colItem by(colItem as ThingBase).TypeName into newGroup select newGroup; OnPropertyChanged("Groups"); }
private async Task <ImageSource> GetImageAsync() { var query = new ThingQuery(PersonalImage.TypeId) { View = { Sections = ThingSections.Xml | ThingSections.BlobPayload | ThingSections.Signature } }; var things = await _thingClient.GetThingsAsync(_recordId, query); IThing firstThing = things?.FirstOrDefault(); if (firstThing == null) { return(null); } PersonalImage image = (PersonalImage)firstThing; return(ImageSource.FromStream(() => image.ReadImage())); }
public async Task <T> GetThingAsync <T>(Guid recordId, Guid thingId) where T : IThing { Validator.ThrowIfArgumentNull(recordId, nameof(recordId), Resources.NewItemsNullItem); // Create a new searcher to get the item. HealthRecordAccessor accessor = new HealthRecordAccessor(_connection, recordId); HealthRecordSearcher searcher = new HealthRecordSearcher(accessor); ThingQuery query = new ThingQuery(); query.ItemIds.Add(thingId); query.View.Sections = ThingSections.Default; query.CurrentVersionOnly = true; HealthServiceResponseData result = await GetRequestWithParameters(recordId, searcher, new[] { query }); IReadOnlyCollection <ThingCollection> resultSet = _thingDeserializer.Deserialize(result, searcher); // Check in case HealthVault returned invalid data. if (resultSet.Count == 0) { return(default(T)); } if (resultSet.Count > 1 || resultSet.ElementAt(0).Count > 1) { throw new MoreThanOneThingException(Resources.GetSingleThingTooManyResults); } if (resultSet.Count == 1) { ThingCollection resultGroup = resultSet.ElementAt(0); if (resultGroup.Count == 1) { return((T)resultGroup[0]); } } return(default(T)); }
private async void GetUserImage_OnClick(object sender, RoutedEventArgs e) { PersonInfo personInfo = await _connection.GetPersonInfoAsync(); HealthRecordInfo recordInfo = personInfo.SelectedRecord; IThingClient thingClient = _connection.CreateThingClient(); ThingQuery query = new ThingQuery(); query.View.Sections = ThingSections.Default | ThingSections.BlobPayload; var theThings = await thingClient.GetThingsAsync <PersonalImage>(recordInfo.Id, query); Stream imageStream = theThings.First().ReadImage(); using (MemoryStream memoryStream = new MemoryStream()) { await imageStream.CopyToAsync(memoryStream); OutputBlock.Text = $"Image has {memoryStream.Length} bytes"; } }
public async Task UsingDatesInThingsQueryReturnProperly() { IHealthVaultSodaConnection connection = HealthVaultConnectionFactory.Current.GetOrCreateSodaConnection(Constants.Configuration); IThingClient thingClient = connection.CreateThingClient(); PersonInfo personInfo = await connection.GetPersonInfoAsync(); HealthRecordInfo record = personInfo.SelectedRecord; ThingQuery query = new ThingQuery(BloodGlucose.TypeId); var now = DateTime.UtcNow; query.CreatedDateMin = Instant.FromDateTimeUtc(now.AddDays(-5)); query.CreatedDateMax = Instant.FromDateTimeUtc(now.AddDays(-4)); query.UpdatedDateMin = Instant.FromDateTimeUtc(now.AddDays(-3)); query.UpdatedDateMax = Instant.FromDateTimeUtc(now.AddDays(-2)); query.UpdatedEndDateMin = LocalDateTime.FromDateTime(now.AddDays(-1)); query.UpdatedEndDateMax = LocalDateTime.FromDateTime(now); var results = await thingClient.GetThingsAsync(record.Id, query); Assert.IsNotNull(results); Assert.IsNotNull(results.Query); Assert.IsNotNull(results.Query.CreatedDateMin); Assert.AreEqual(results.Query.CreatedDateMin.Value.ToDateTimeUtc(), now.AddDays(-5)); Assert.IsNotNull(results.Query.CreatedDateMax); Assert.AreEqual(results.Query.CreatedDateMax.Value.ToDateTimeUtc(), now.AddDays(-4)); Assert.IsNotNull(results.Query.UpdatedDateMin); Assert.AreEqual(results.Query.UpdatedDateMin.Value.ToDateTimeUtc(), now.AddDays(-3)); Assert.IsNotNull(results.Query.UpdatedDateMax); Assert.AreEqual(results.Query.UpdatedDateMax.Value.ToDateTimeUtc(), now.AddDays(-2)); Assert.IsNotNull(results.Query.UpdatedEndDateMin); Assert.AreEqual(results.Query.UpdatedEndDateMin.Value, LocalDateTime.FromDateTime(now.AddDays(-1))); Assert.IsNotNull(results.Query.UpdatedEndDateMax); Assert.AreEqual(results.Query.UpdatedEndDateMax.Value, LocalDateTime.FromDateTime(now)); }
public async Task GetThingsPaged() { InitializeResponse( SampleUtils.GetSampleContent("ThingsPagedResult1.xml"), SampleUtils.GetSampleContent("ThingsPagedResult2.xml"), SampleUtils.GetSampleContent("ThingsPagedResult3.xml")); ThingQuery query = this.GetBloodPressureThingQuery(); var result = await _client.GetThingsAsync <BloodPressure>(_recordId, query); List <BloodPressure> resultList = result.ToList(); // The first call should be a normal one to get blood pressures. await _connection.Received().ExecuteAsync( HealthVaultMethods.GetThings, Arg.Any <int>(), Arg.Is <string>(x => x.Contains(BloodPressure.TypeId.ToString())), Arg.Is <Guid>(x => x == _recordId)); // The first response contains some unresolved items, which need another couple of calls to fetch. // We make sure we see these calls and the thing IDs they are requesting. await _connection.Received().ExecuteAsync( HealthVaultMethods.GetThings, Arg.Any <int>(), Arg.Is <string>(x => x.Contains("c0464a97-2832-4f50-a683-6d98c396da08")), Arg.Is <Guid>(x => x == _recordId)); await _connection.Received().ExecuteAsync( HealthVaultMethods.GetThings, Arg.Any <int>(), Arg.Is <string>(x => x.Contains("f5f2c6f0-6924-4744-9338-8e3d81c31259")), Arg.Is <Guid>(x => x == _recordId)); Assert.AreEqual(503, result.Count); BloodPressure lastBloodPressure = resultList[502]; Assert.AreEqual(117, lastBloodPressure.Systolic); Assert.AreEqual(70, lastBloodPressure.Diastolic); }
public async Task <IReadOnlyCollection <T> > GetThingsAsync <T>(Guid recordId, ThingQuery query = null) where T : IThing { Validator.ThrowIfArgumentNull(recordId, nameof(recordId), Resources.NewItemsNullItem); // Ensure that we have a query that requests the correct type T thing = (T)Activator.CreateInstance(typeof(T)); query = query ?? new ThingQuery(); query.TypeIds.Clear(); query.TypeIds.Add(thing.TypeId); ThingCollection results = await GetThingsAsync(recordId, query); IList <T> things = new Collection <T>(); foreach (IThing resultThing in results) { if (resultThing is T) { things.Add((T)resultThing); } } return(new ReadOnlyCollection <T>(things)); }