public async Task <SpecimenFindResult> FindSpecimens(SpecimenFindParams findParams)
{
var user = await _userService.GetIdentifyingUser(UserId);
var result = await _specimenService.FindSpecimens(findParams, user);
var typeIds = result.Results.Select(s => s.SpecimenId).ToList();
var photos = await _photoService.GetPhotosByTypeAsync(PhotoType.Specimen, typeIds);
foreach (var photoGroup in photos.GroupBy(p => p.TypeId))
{
var specimen = result.Results.FirstOrDefault(s => s.SpecimenId == photoGroup.Key);
if (specimen != null)
{
specimen.Photos = photoGroup.ToList();
}
}
return(result);
}
public override async Task <FindResult <Specimen> > GetListAsync(FindParams findParams)
{
var findSpecimenParams = new SpecimenFindParams
{
SearchText = findParams.SearchText,
UseNGrams = false,
Skip = findParams.Skip,
Take = findParams.Take,
SortBy = findParams.SortBy,
SortDirection = findParams.SortDirection,
Filters = SpecimenFilters,
CreatedBy = findParams.CreatedBy
};
var result = await ApiClient.FindSpecimensAsync(findSpecimenParams);
SpecimenFilters = result.Filters;
return(new SpecimenFindResult
{
Results = result.Results,
Count = result.Count
});
}
private IEnumerable <AggregationResult <Specimen> > ProcessAggregations(SearchResponse <Specimen> response, SpecimenFindParams specimenFindParams)
{
var aggregations = new List <AggregationResult <Specimen> >();
foreach (var aggregation in response.Aggregations)
{
var bucketAggregations = new List <AggregationResult <Specimen> >();
if (aggregation.Value is SingleBucketAggregate singleBucket)
{
foreach (var bucket in singleBucket)
{
if (bucket.Value is BucketAggregate bucketValues)
{
var bucketResults = new Dictionary <string, long?>();
// Process values
foreach (var bucketValue in bucketValues.Items)
{
var keyedBucket = bucketValue as KeyedBucket <object>;
bucketResults.Add(keyedBucket.Key.ToString(), keyedBucket.DocCount);
}
if (bucketResults.Any())
{
bucketAggregations.Add(new AggregationResult <Specimen>
{
Name = aggregation.Key,
Values = bucketResults
});
}
}
}
if (!bucketAggregations.Any() && singleBucket.DocCount > 0)
{
bucketAggregations.Add(new AggregationResult <Specimen>
{
Name = aggregation.Key,
Values = new Dictionary <string, long?> {
{ specimenFindParams.Filters.StageFilter.Value, singleBucket.DocCount }
}
});
}
aggregations.AddRange(bucketAggregations);
}
else if (aggregation.Value is BucketAggregate bucket)
{
var bucketResults = new Dictionary <string, long?>();
// Process values
foreach (var bucketValue in bucket.Items)
{
var keyedBucket = bucketValue as KeyedBucket <object>;
bucketResults.Add(keyedBucket.Key.ToString(), keyedBucket.DocCount);
}
bucketAggregations.Add(new AggregationResult <Specimen>
{
Name = aggregation.Key,
Values = bucketResults
});
aggregations.AddRange(bucketAggregations);
}
}
return(aggregations);
}
public async Task <SpecimenFindResult> FindSpecimens(SpecimenFindParams findParams, Data.Shared.Models.User user)
{
if (findParams.Filters == null)
{
findParams.Filters = new SpecimenFilters();
}
var specimenSearch = await _specimenIndex.SearchAsync(findParams, user);
var specimenIds = specimenSearch.Documents.Select(p => p.Id).ToArray();
var specimenQuery = _specimenRepository.WhereWithIncludes(s => specimenIds.Contains(s.Id),
false,
s => s.Include(s => s.InventoryItem)
.Include(s => s.InventoryItem.Inventory)
.Include(s => s.InventoryItem.Origin)
.Include(s => s.InventoryItem.User)
.Include(s => s.Lifeform));
specimenQuery = specimenQuery.CanViewContent(user);
var specimenResult = specimenQuery.GetSomeAsync(track: false);
var specimens = new List <Data.Shared.Models.Specimen>();
await foreach (var specimen in specimenResult)
{
specimens.Add(specimen.AsModel());
}
if (specimenSearch.Aggregations != null)
{
foreach (var aggregation in specimenSearch.AggregationResult)
{
if (aggregation.Name == "Stage")
{
var filter = findParams.Filters.StageFilter;
var values = aggregation.Values;
values = values.Prepend(new KeyValuePair <string, long?>("", null)).ToDictionary(k => k.Key, v => v.Value);
filter.FacetValues = values;
}
}
}
if (specimenSearch.Aggregations != null)
{
foreach (var aggregation in specimenSearch.AggregationResult)
{
var filter = SpecimenFindParams.GetFilter(aggregation.Name, findParams);
if (filter is SelectFilter <string> selectFilter)
{
var values = aggregation.Values;
values = values.Prepend(new KeyValuePair <string, long?>("", null)).ToDictionary(k => k.Key, v => v.Value);
selectFilter.FacetValues = values;
}
if (filter is SelectRangeFilter <double> selectRangeFilter)
{
var values = aggregation.Values.ToDictionary(k => double.Parse(k.Key), v => v.Value).OrderBy(k => k.Key).ToDictionary(k => k.Key, v => v.Value);
if (aggregation.Name.Contains("Min"))
{
selectRangeFilter.MinFacetValues = values;
}
else
{
selectRangeFilter.MaxFacetValues = values;
}
}
if (filter is RangeFilter <string> rangeFilter)
{
var values = aggregation.Values;
values = values.Prepend(new KeyValuePair <string, long?>("", null)).ToDictionary(k => k.Key, v => v.Value);
rangeFilter.FacetValues = values;
}
}
}
return(new SpecimenFindResult
{
Results = specimenIds.Join(specimens, sid => sid, s => s.SpecimenId, (id, s) => s).ToList(),
Count = specimenSearch.Count,
Filters = findParams.Filters
});
}
public async Task <SpecimenFindResult> FindSpecimensAsync(SpecimenFindParams findParams)
{
var result = await _httpClient.PostAsJsonAsync($"/api/specimen/find", findParams);
return(await ReadResult <SpecimenFindResult>(result));
}
