private IQueryable <Activity> GetActivityQuery(FindParams findParams, Data.Shared.Models.User user, int?specimenId = null)
{
var activityQuery = _activityRepository.WhereWithIncludes(a => (!specimenId.HasValue || a.SpecimenId == specimenId) &&
(!findParams.ContactsOnly || a.User.Contacts.Any(u => u.ContactUserId == user.Id)) &&
(findParams.SearchTextQuery == null ||
EF.Functions.Like(a.Name, findParams.SearchTextQuery) ||
EF.Functions.Like(a.Specimen.InventoryItem.Name, findParams.SearchTextQuery) ||
(a.Specimen.Lifeform != null && EF.Functions.Like(a.Specimen.Lifeform.CommonName, findParams.SearchTextQuery)) ||
(a.Specimen.Lifeform != null && EF.Functions.Like(a.Specimen.Lifeform.ScientificName, findParams.SearchTextQuery))),
false,
a => a.Include(a => a.Specimen)
.Include(a => a.Specimen.InventoryItem)
.Include(a => a.Specimen.Lifeform)
.Include(a => a.User));
activityQuery = activityQuery.CanViewContent(user);
if (!findParams.ContactsOnly && !string.IsNullOrEmpty(findParams.CreatedBy))
{
activityQuery = activityQuery.Where(a => a.CreatedBy == findParams.CreatedBy);
}
activityQuery = OrderBy(activityQuery, findParams.SortBy, findParams.SortDirection);
return(activityQuery);
}
private List <QueryContainer> GetFilters(FindParams <Data.Shared.Models.Specimen> findParams)
{
var musts = new List <QueryContainer>();
var query = new QueryContainerDescriptor <Specimen>();
var specimenFindParams = findParams as SpecimenFindParams;
if (findParams.CreatedBy != null)
{
musts.Add(query.Match(m => m.Field(f => f.CreatedBy).Query(findParams.CreatedBy)));
}
if (specimenFindParams.Filters != null)
{
var filters = specimenFindParams.Filters;
var stageFilter = filters.StageFilter;
if (!string.IsNullOrEmpty(stageFilter.Value))
{
musts.Add(query.Term(t => t.SpecimenStage, stageFilter.Value));
}
}
return(musts);
}
public FindInFilesDialog(Data data, FindParams findParams, Getter <string, string, bool> doFind, string name)
{
this.data = data;
this.findParams = findParams;
this.doFind = doFind;
Name = name;
}
public async Task <FindResult <Origin> > FindOrigins(FindParams findParams)
{
var user = await _userService.GetIdentifyingUser(UserId);
var result = await _originService.FindOrigins(findParams, user);
return(result);
}
private void SetValues(DatabaseObject target, FilterParams filter, FindParams findParams, bool isRelational)
{
this.schema = target.Schema.Name;
this.collection = target.Name;
this.isRelational = isRelational;
this.filter = filter;
this.findParams = findParams;
}
public async Task <FindResult <Activity> > FindActivities(FindParams findParams, int?specimenId)
{
var user = await _userService.GetIdentifyingUser(UserId);
var result = await _activityService.FindActivities(findParams, user, specimenId);
return(await FindResult(result));
}
public ViFindDialog(
FindDialog.Data data, FindParams findParams, Getter <string, Pattern, bool, bool> doFind, bool isBackward)
{
this.data = data;
this.findParams = findParams;
this.doFind = doFind;
this.isBackward = isBackward;
Name = "Find";
}
public override async Task <FindResult <Origin> > GetListAsync(FindParams findParams)
{
var result = await ApiClient.FindOriginsAsync(findParams);
return(new FindResult <Origin>
{
Results = result.Results,
Count = result.Count
});
}
public override async Task <FindResult <UserContactRequest> > GetListAsync(FindParams findParams)
{
var result = await ApiClient.FindContactRequestsAsync(findParams);
return(new FindResult <UserContactRequest>
{
Results = result.Results,
Count = result.Count
});
}
public void FindCompanyTest()
{
MainViewModel mvm = new MainViewModel(_dataService);
FindParams findParams = new FindParams()
{
CompanyId = 1, CountryCode = 100
};
mvm.FindCompanyCommand.Execute(findParams);
}
public async Task <FindResult <Data.Shared.Models.Taxon> > FindTaxons(FindParams <Data.Shared.Models.Taxon> findParams, TaxonRank rank)
{
var taxonShape = findParams.Shape;
var taxonQuery = _taxonRepository.WhereWithIncludes(t => t.Kingdom != null && (taxonShape == null ||
((taxonShape.Kingdom == null || t.Kingdom == taxonShape.Kingdom) &&
(taxonShape.Subkingdom == null || t.Subkingdom == taxonShape.Subkingdom) &&
(taxonShape.Infrakingdom == null || t.Infrakingdom == taxonShape.Infrakingdom) &&
(taxonShape.Phylum == null || t.Phylum == taxonShape.Phylum) &&
(taxonShape.Subphylum == null || t.Subphylum == taxonShape.Subphylum) &&
(taxonShape.Class == null || t.Class == taxonShape.Class) &&
(taxonShape.Superorder == null || t.Superorder == taxonShape.Superorder) &&
(taxonShape.Order == null || t.Order == taxonShape.Order) &&
(taxonShape.Suborder == null || t.Suborder == taxonShape.Suborder) &&
(taxonShape.Family == null || t.Family == taxonShape.Family) &&
(taxonShape.Genus == null || t.Genus == taxonShape.Genus) &&
(taxonShape.Species == null || t.Species == taxonShape.Species))));
if (taxonShape == null || rank == TaxonRank.Kingdom)
{
taxonQuery = taxonQuery.Where(t => taxonShape == null || taxonShape.Kingdom == null || t.Kingdom == taxonShape.Kingdom)
.Select(t => new Taxon {
Kingdom = t.Kingdom
}).Distinct();
}
else
{
taxonQuery = OrderByDistinct(rank, taxonQuery);
}
var result = taxonQuery.GetSome().ToList();
var count = result.Count;
var taxonsResult = result.Skip(findParams.Skip).Take(findParams.Take);
var parentRank = rank.GetParentRank();
var parentName = taxonShape.GetTaxonName(parentRank);
var synonyms = await _synonymService.GetSynonymsByParentAsync(parentRank, parentName);
var taxons = new List <Data.Shared.Models.Taxon>();
foreach (var taxon in taxonsResult)
{
var taxonResult = taxon.AsModel();
taxonResult.Synonyms = synonyms.Where(s => s.Taxon.GetTaxonName(rank) == taxonResult.GetTaxonName(rank));
taxons.Add(taxonResult);
}
return(await Task.FromResult(new FindResult <Data.Shared.Models.Taxon>
{
Count = count,
Results = taxons
}));
}
public async Task <SearchResponse <Lifeform> > SearchAsync(FindParams <Data.Shared.Models.Lifeform> findParams, Data.Shared.Models.User user)
{
var searchTerm = findParams.SearchText;
var shoulds = new List <QueryContainer>();
var query = new QueryContainerDescriptor <PlantInfo>();
if (!string.IsNullOrEmpty(searchTerm))
{
shoulds.Add(query.MultiMatch(mm => mm.Fields(mmf => mmf
.Field(m => m.CommonName)
.Field(m => m.ScientificName)
.Field(m => m.Lifeform.CommonName)
.Field(m => m.Lifeform.ScientificName)
.Field("commonName.nameSearch")
.Field("scientificName.nameSearch")
.Field("lifeform.commonName.nameSearch")
.Field("lifeform.scientificName.nameSearch"))
.Query(searchTerm)));
shoulds.Add(query.Nested(n => n
.Path(p => p.Synonyms)
.Query(q => q
.Match(sq => sq
.Field("synonyms.name")
.Query(searchTerm)))));
}
var searchDescriptor = new SearchDescriptor <PlantInfo>()
.Source(s => s.Includes(i => i.Field(p => p.Lifeform)))
.Query(q => q
.Bool(b => b
.Should(shoulds.ToArray())));
var countDescriptor = new CountDescriptor <PlantInfo>()
.Query(q => q
.Bool(b => b
.Should(shoulds.ToArray())));
var response = await _searchClient.SearchAsync(pi => searchDescriptor.Skip(findParams.Skip).Take(findParams.Take), pi => countDescriptor);
return(new SearchResponse <Lifeform>
{
Count = response.Count,
Documents = response.Documents.Select(d =>
new Lifeform
{
Id = d.Lifeform.Id,
CommonName = d.Lifeform.CommonName,
ScientificName = d.Lifeform.ScientificName,
}).ToList(),
Aggregations = null
});
}
public ReplaceDialog(Data data, FindParams findParams,
Getter <string, bool> doFindText,
Getter <string, bool> doSelectAllFound,
Getter <string, bool> doSelectNextFound,
Getter <bool> doUnselectPrevText,
string name)
{
this.data = data;
this.findParams = findParams;
this.doFindText = doFindText;
this.doSelectAllFound = doSelectAllFound;
this.doSelectNextFound = doSelectNextFound;
this.doUnselectPrevText = doUnselectPrevText;
Name = name;
}
public async override Task <FindResult <Taxon> > GetListAsync(FindParams findParams)
{
var findTaxonParams = new FindParams <Taxon>
{
SearchText = findParams.SearchText,
Skip = findParams.Skip,
Take = findParams.Take,
SortBy = findParams.SortBy,
SortDirection = findParams.SortDirection,
Shape = Shape
};
var result = await ApiClient.FindTaxonsAsync(findTaxonParams, Rank);
return(result);
}
private void btnFind_Click(object sender, RoutedEventArgs e)
{
int companyIdInt;
int countryCodeInt;
var vm = (MainViewModel)DataContext;
int.TryParse(txtCompanyId.Text, out companyIdInt);
int.TryParse(txtCompanyId.Text, out countryCodeInt);
FindParams findParams = new FindParams()
{
CompanyId = companyIdInt, CountryCode = countryCodeInt
};
vm.FindCompanyCommand.Execute(findParams);
}
public override async Task <FindResult <Lifeform> > GetListAsync(FindParams findParams)
{
var lifeformFindParams = new FindParams <Lifeform>
{
CreatedBy = findParams.CreatedBy,
SearchText = findParams.SearchText,
Skip = findParams.Skip,
Take = findParams.Take
};
var result = await ApiClient.FindLifeformsAsync(lifeformFindParams);
return(new FindResult <Lifeform>
{
Results = result.Results,
Count = result.Count
});
}
public FindDialog(
Data data,
FindParams findParams,
Getter <string, bool> doFind,
Getter <string, bool> doSelectAllFound,
Getter <string, bool> doSelectNextFound,
Getter <bool> doUnselectPrevText,
string name,
bool allowNormalMode)
{
this.data = data;
this.findParams = findParams;
this.doFind = doFind;
this.doSelectAllFound = doSelectAllFound;
this.doSelectNextFound = doSelectNextFound;
this.doUnselectPrevText = doUnselectPrevText;
this.allowNormalMode = allowNormalMode;
Name = name;
}
public override async Task <FindResult <UserMessage> > GetListAsync(FindParams findParams)
{
FindResult <UserMessage> result;
if (Sent)
{
result = await ApiClient.FindSentMessagesAsync(findParams);
}
else
{
result = await ApiClient.FindMessagesAsync(findParams);
}
return(new FindResult <UserMessage>
{
Results = result.Results,
Count = result.Count
});
}
public async Task <FindResult <Activity> > FindScheduledActivities(FindParams findParams, long?date)
{
var user = await _userService.GetIdentifyingUser(UserId);
DateTime startDate;
if (date.HasValue)
{
startDate = new DateTime(date.Value);
}
else
{
startDate = DateTime.UtcNow;
}
var result = await _activityService.FindScheduledActivities(findParams, user, startDate);
return(await FindResult(result));
}
public override async Task <FindResult <Activity> > GetListAsync(FindParams findParams)
{
FindResult <Activity> result;
findParams.ContactsOnly = ContactsOnly;
if (Specimen != null)
{
result = await ApiClient.FindActivitiesAsync(findParams, Specimen);
}
else if (Upcoming)
{
result = await ApiClient.FindScheduledActivitiesAsync(findParams, DateTime.UtcNow);
}
else
{
result = await ApiClient.FindActivitiesAsync(findParams);
}
return(result);
}
public async Task <FindResult <Data.Shared.Models.Origin> > FindOrigins(FindParams findParams, Data.Shared.Models.User user)
{
var originQuery = _originRepository.WhereWithIncludes(o => findParams.SearchTextQuery == null ||
EF.Functions.Like(o.Name, findParams.SearchTextQuery) ||
EF.Functions.Like(o.Description, findParams.SearchTextQuery) ||
EF.Functions.Like(o.Location.City, findParams.SearchTextQuery) ||
EF.Functions.Like(o.Location.AddressLine1, findParams.SearchTextQuery) ||
EF.Functions.Like(o.Location.StateOrProvince, findParams.SearchTextQuery),
false,
o => o.Include(o => o.Location)
.Include(o => o.User));
originQuery = originQuery.CanViewContent(user);
if (!string.IsNullOrEmpty(findParams.CreatedBy))
{
originQuery = originQuery.Where(s => s.CreatedBy == findParams.CreatedBy);
}
else
{
originQuery = originQuery.Where(s => s.CreatedBy != null);
}
originQuery = OrderBy(originQuery, findParams.SortBy, findParams.SortDirection);
var count = originQuery.Count();
var originResult = originQuery.GetSomeAsync(skip: findParams.Skip, take: findParams.Take, track: false);
var origins = new List <Data.Shared.Models.Origin>();
await foreach (var origin in originResult)
{
origins.Add(origin.AsModel());
}
return(new FindResult <Data.Shared.Models.Origin>
{
Results = origins,
Count = count
});
}
public async Task <FindResult <Data.Shared.Models.Lifeform> > FindLifeforms(FindParams <Data.Shared.Models.Lifeform> findParams)
{
var lifeformSearch = await _lifeformIndex.SearchAsync(findParams, null);
var lifeformIds = lifeformSearch.Documents.Select(p => p.Id).ToArray();
var lifeformQuery = _lifeformRepository.Where(l => lifeformIds.Contains(l.Id), false);
var lifeformResult = lifeformQuery.GetSomeAsync(track: false);
var lifeforms = new List <Data.Shared.Models.Lifeform>();
await foreach (var lifeform in lifeformResult)
{
lifeforms.Add(lifeform.AsModel());
}
return(new FindResult <Data.Shared.Models.Lifeform>
{
Results = lifeforms,
Count = lifeformSearch.Count
});
}
public string Execute(string regexText, FindParams findParams, string directory, string filter, string ignoreDirs)
{
if (string.IsNullOrEmpty(regexText))
{
return(null);
}
Regex regex = null;
string pattern = null;
if (findParams.regex)
{
string error;
regex = DialogManager.ParseRegex(regexText, out error);
if (regex == null || error != null)
{
return("Error: " + error);
}
}
else
{
pattern = regexText;
}
alert = new AlertForm(mainForm, OnCanceled);
tabSize = mainForm.Settings.tabSize.GetValue(null);
thread = new Thread(
new ThreadStart(delegate()
{
Search(directory, regex, pattern, findParams.ignoreCase, filter, ignoreDirs);
})
);
thread.Start();
alert.ShowDialog(mainForm);
if (finishBuffer != null)
{
mainForm.ShowConsoleBuffer(MainForm.FindResultsId, finishBuffer);
}
return(null);
}
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
});
}
public async Task <SearchResponse <Specimen> > SearchAsync(FindParams <Data.Shared.Models.Specimen> findParams, Data.Shared.Models.User user)
{
var specimenFindParams = findParams as SpecimenFindParams;
var searchTerm = findParams.SearchText;
var musts = GetFilters(findParams);
var shoulds = new List <QueryContainer>();
var query = new QueryContainerDescriptor <Specimen>();
if (!string.IsNullOrEmpty(searchTerm))
{
var fields = new FieldsDescriptor <Specimen>();
fields = fields.Field(f => f.Name)
.Field(f => f.Lifeform.CommonName)
.Field(f => f.Lifeform.ScientificName);
if (findParams.UseNGrams)
{
fields = fields.Field("name.nameSearch");
}
shoulds.Add(query.MultiMatch(mm => mm.Fields(mmf => fields)
.Query(searchTerm)
.Fuzziness(Fuzziness.AutoLength(1, 5))));
}
musts.Add(FilterByVisibility(query, user));
var searchDescriptor = new SearchDescriptor <Specimen>()
.Query(q => q
.Bool(b => b
.Should(shoulds.ToArray())
.Must(musts.ToArray()).MinimumShouldMatch(string.IsNullOrEmpty(searchTerm) ? 0 : 1)));
var countDescriptor = new CountDescriptor <Specimen>()
.Query(q => q
.Bool(b => b
.Should(shoulds.ToArray())
.Must(musts.ToArray()).MinimumShouldMatch(string.IsNullOrEmpty(searchTerm) ? 0 : 1)));
// Sort
var specimenSorts = GetSpecimenSorts();
if (!string.IsNullOrEmpty(findParams.SortBy))
{
if (findParams.SortDirection == SortDirection.Ascending)
{
searchDescriptor.Sort(s => s.Field(f => f.Field(specimenSorts[findParams.SortBy]).Ascending()));
}
else
{
searchDescriptor.Sort(s => s.Field(f => f.Field(specimenSorts[findParams.SortBy]).Descending()));
}
}
else if (string.IsNullOrEmpty(findParams.SearchText))
{
searchDescriptor.Sort(s => s.Field(f => f.Field(specimenSorts["DateModified"]).Descending()).Field(f => f.Field(specimenSorts["DateCreated"]).Descending()));
}
var aggregations = new AggregationContainerDescriptor <Specimen>();
var searchFilters = new List <SearchFilter <Specimen> >
{
new SearchValueFilter <Specimen, string>("Stage", "specimenStage", specimenFindParams.Filters.StageFilter.Value)
};
foreach (var filter in searchFilters)
{
if (filter is NestedSearchValueFilter <Specimen, string> nestedFilter)
{
aggregations = nestedFilter.ToAggregationContainerDescriptor(aggregations);
}
else if (filter is SearchRangeFilter <Specimen, double> searchRangeFilter)
{
aggregations = searchRangeFilter.ToAggregationContainerDescriptor(aggregations);
}
else if (filter is SearchValueFilter <Specimen, string> searchValueFilter)
{
aggregations = searchValueFilter.ToAggregationContainerDescriptor(aggregations);
}
}
searchDescriptor.Aggregations(a => aggregations);
var response = await _searchClient.SearchAsync(pi => searchDescriptor.Skip(findParams.Skip).Take(findParams.Take), pi => countDescriptor);
response.AggregationResult = ProcessAggregations(response, specimenFindParams);
return(response);
}
public async Task <SearchResponse <PlantInfo> > SearchAsync(FindParams <Data.Shared.Models.PlantInfo> findParams, Data.Shared.Models.User user)
{
var plantInfoFindParams = findParams as PlantInfoFindParams;
var searchTerm = findParams.SearchText;
var shoulds = new List <QueryContainer>();
var query = new QueryContainerDescriptor <PlantInfo>();
if (!string.IsNullOrEmpty(searchTerm))
{
var fields = new FieldsDescriptor <PlantInfo>();
fields = fields.Field(m => m.CommonName)
.Field(m => m.ScientificName)
.Field(m => m.Lifeform.CommonName)
.Field(m => m.Lifeform.ScientificName)
.Field("commonName.nameSearch")
.Field("scientificName.nameSearch")
.Field("lifeform.commonName.nameSearch")
.Field("lifeform.scientificName.nameSearch");
shoulds.Add(query.MultiMatch(mm => mm.Fields(mmf => fields)
.Query(searchTerm)
.Fuzziness(Fuzziness.AutoLength(3, 5))));
shoulds.Add(query.Nested(n => n
.Path(p => p.Synonyms)
.Query(q => q
.Match(sq => sq
.Field("synonyms.name")
.Query(searchTerm)
.Fuzziness(Fuzziness.AutoLength(3, 5))))));
}
var filters = plantInfoFindParams.Filters;
var searchFilters = new List <SearchFilter <PlantInfo> >
{
new NestedSearchValueFilter <PlantInfo, string>(filters.RegionFilter.Name, "location.region.keyword", "plantLocations", filters.RegionFilter.Value),
new SearchValuesFilter <PlantInfo, string>(filters.WaterFilter.Name, "waterTypes", filters.WaterFilter.MinimumValue, filters.WaterFilter.MaximumValue),
new SearchValuesFilter <PlantInfo, string>(filters.LightFilter.Name, "lightTypes", filters.LightFilter.MinimumValue, filters.LightFilter.MaximumValue),
new SearchValuesFilter <PlantInfo, string>(filters.BloomFilter.Name, "bloomTimes", filters.BloomFilter.MinimumValue?.ToString(), filters.BloomFilter.MaximumValue?.ToString()),
new NestedSearchValueFilter <PlantInfo, string>(filters.ZoneFilter.Name, "id", "zones", filters.ZoneFilter.Value?.ToString()),
new SearchRangeFilter <PlantInfo, double>(filters.HeightFilter.Name, "minHeight", "maxHeight", filters.HeightFilter.Values, filters.HeightFilter.Value, filters.HeightFilter.MaximumValue),
new SearchRangeFilter <PlantInfo, double>(filters.SpreadFilter.Name, "minSpread", "maxSpread", filters.SpreadFilter.Values, filters.SpreadFilter.Value, filters.SpreadFilter.MaximumValue),
new NestedSearchMultiValueFilter <PlantInfo, string, LocationStatus>(filters.NativeFilter.Name, "location.stateOrProvince.keyword", "plantLocations", "status",
filters.NativeFilter.Value, filters.NativeFilter.Status)
};
var musts = GetFilters(plantInfoFindParams, searchFilters);
musts.Add(FilterByVisibility(query, user));
if (plantInfoFindParams.Lifeform != null)
{
musts.Add(query.Bool(b => b.Must(m => m.Term(t => t.Lifeform.Id, plantInfoFindParams.Lifeform.LifeformId))));
}
var searchDescriptor = new SearchDescriptor <PlantInfo>()
.Query(q => q
.Bool(b => b
.Should(shoulds.ToArray())
.Must(musts.ToArray()).MinimumShouldMatch(string.IsNullOrEmpty(searchTerm) ? 0 : 1)));
var countDescriptor = new CountDescriptor <PlantInfo>()
.Query(q => q
.Bool(b => b
.Should(shoulds.ToArray())
.Must(musts.ToArray()).MinimumShouldMatch(string.IsNullOrEmpty(searchTerm) ? 0 : 1)));
var aggregations = new AggregationContainerDescriptor <PlantInfo>();
foreach (var filter in searchFilters)
{
if (filter is NestedSearchMultiValueFilter <PlantInfo, string, LocationStatus> nestedMultiFilter)
{
aggregations = nestedMultiFilter.ToAggregationContainerDescriptor(aggregations);
}
else if (filter is NestedSearchValueFilter <PlantInfo, string> nestedFilter)
{
aggregations = nestedFilter.ToAggregationContainerDescriptor(aggregations);
}
else if (filter is SearchRangeFilter <PlantInfo, double> searchRangeFilter)
{
aggregations = searchRangeFilter.ToAggregationContainerDescriptor(aggregations);
}
else if (filter is SearchValuesFilter <PlantInfo, string> searchValuesFilter)
{
aggregations = searchValuesFilter.ToAggregationContainerDescriptor(aggregations);
}
else if (filter is SearchValueFilter <PlantInfo, string> searchValueFilter)
{
aggregations = searchValueFilter.ToAggregationContainerDescriptor(aggregations);
}
}
searchDescriptor.Aggregations(a => aggregations);
// Sort
var plantInfoSorts = GetPlantInfoSorts();
if (!string.IsNullOrEmpty(findParams.SortBy))
{
if (findParams.SortDirection == SortDirection.Ascending)
{
searchDescriptor.Sort(s => s.Field(f => f.Field(plantInfoSorts[findParams.SortBy]).Ascending()));
}
else
{
searchDescriptor.Sort(s => s.Field(f => f.Field(plantInfoSorts[findParams.SortBy]).Descending()));
}
}
else if (string.IsNullOrEmpty(findParams.SearchText))
{
searchDescriptor.Sort(s => s.Field(f => f.Field(plantInfoSorts["DateModified"]).Descending()).Field(f => f.Field(plantInfoSorts["DateCreated"]).Descending()));
}
var response = await _searchClient.SearchAsync(pi => searchDescriptor.Skip(findParams.Skip).Take(findParams.Take), pi => countDescriptor);
response.AggregationResult = ProcessAggregations(response, plantInfoFindParams);
return(response);
}
public async Task <FindResult <UserMessage> > FindMessagesAsync(FindParams findParams)
{
var result = await _httpClient.PostAsJsonAsync($"/api/message/find", findParams);
return(await ReadResult <FindResult <UserMessage> >(result));
}
public async Task <FindResult <UserContactRequest> > FindContactRequestsAsync(FindParams findParams)
{
var result = await _httpClient.PostAsJsonAsync($"/api/usercontact/request/find", findParams);
return(await ReadResult <FindResult <UserContactRequest> >(result));
}
public async Task <FindResult <Taxon> > FindTaxonsAsync(FindParams <Taxon> findParams, TaxonRank rank)
{
var result = await _httpClient.PostAsJsonAsync($"/api/taxon/find?rank={rank}", findParams);
return(await ReadResult <FindResult <Taxon> >(result));
}
public async Task <FindResult <Origin> > FindOriginsAsync(FindParams findParams)
{
var result = await _httpClient.PostAsJsonAsync($"/api/origin/find", findParams);
return(await ReadResult <FindResult <Origin> >(result));
}
