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)); }