public void NotifyFiltersChanged() { try { if (_subCategoryDisplayItem.AllProducts != null) { // Check if any filters have been enabled var hasFilters = FilterGroups.Any(fg => fg.IsGroupFiltered); if (hasFilters) { //Filter the list of Product Items from our Filter Groups List <ProductListFilterItem> selectedFilterItems; var filteredProducts = GetFilteredProducts(_subCategoryDisplayItem.AllProducts, FilterGroups.ToList(), out selectedFilterItems); // Update the parent SubCategory with new filtered product list + enabled filters. _subCategoryDisplayItem.SetFilteredProducts(filteredProducts, selectedFilterItems); } else { // Notify the parent Subcategory to reset products back to full unfiltered list _subCategoryDisplayItem.ResetFilteredProducts(); } } } catch (Exception ex) { string msg = ex.Message; } }
/// <summary> /// Validates this object. /// </summary> /// <returns>A List containing an <see cref="Error"/> item for each validation error.</returns> public override List <Error> GetValidationErrors() { var consolidatedList = new List <Error>(); if (SearchGroupId == 0) { consolidatedList.Add(new Error { Message = "A folder must be selected for this Analytic." }); } var entityErrors = Identity.GetAllValidationErrors(); consolidatedList.AddRange(entityErrors); entityErrors = FilterGroups.GetAllValidationErrors(); consolidatedList.AddRange(entityErrors); entityErrors = PriceListGroups.GetAllValidationErrors(); consolidatedList.AddRange(entityErrors); entityErrors = ValueDrivers.GetAllValidationErrors(); consolidatedList.AddRange(entityErrors); return(consolidatedList); }
public async Task <ListResponse <Resource> > Query(string query, IEnumerable <string> requested, IEnumerable <string> excluded) { IEnumerable <Core2Group> groups; if (!string.IsNullOrWhiteSpace(query)) { groups = new FilterGroups(this._context).FilterGen(query); } else { groups = await this._context.CompleteGroups().ToListAsync().ConfigureAwait(false); } NameValueCollection keyedValues = HttpUtility.ParseQueryString(query); IEnumerable <string> keys = keyedValues.AllKeys; string countString = keyedValues[QueryKeys.Count]; string startIndex = keyedValues[QueryKeys.StartIndex]; if (startIndex == null) { startIndex = ControllerConstants.DefaultStartIndexString; } int start = int.Parse(startIndex, CultureInfo.InvariantCulture); if (start < this._defaultStartIndex) { start = this._defaultStartIndex; } int?count = null; int total = groups.Count(); groups = groups.OrderBy(d => d.DisplayName).Skip(start - 1); if (countString != null) { count = int.Parse(countString, CultureInfo.InvariantCulture); groups = groups.Take(count.Value); } groups = groups.Select(u => ColumnsUtility.FilterAttributes(requested, excluded, u, this._alwaysReturnedAttributes)).ToList(); ListResponse <Resource> list = new ListResponse <Resource>() { TotalResults = total, StartIndex = groups.Any() ? start : (int?)null, Resources = groups, }; if (count.HasValue) { list.ItemsPerPage = count.Value; } return(list); }
public FilterGroup AddFilterGroup(string caption, FilterProperty property, ExpressionType expressionType = ExpressionType.In, string description = default) { var group = new FilterGroup(caption, property, expressionType, description); FilterGroups.Add(group); return(group); }
public FilterGroup AddForeignFilterGroup(string caption, string fieldName, Type foreignEntity, ExpressionType expressionType = ExpressionType.In, string description = default) { var group = new FilterGroup(caption, new FilterProperty(fieldName, foreignEntity), expressionType, description); FilterGroups.Add(group); return(group); }
public FilterGroup AddHiddenFilterGroup(FilterProperty property, ExpressionType expressionType = ExpressionType.In) { var group = new FilterGroup(property, expressionType) { Hidden = true }; FilterGroups.Add(group); return(group); }
public FilterGroup AddHiddenFilterGroup <TForeignEntity>(string fieldName, ExpressionType expressionType = ExpressionType.In) { var group = new FilterGroup(new FilterProperty(fieldName, typeof(TForeignEntity)), expressionType) { Hidden = true }; FilterGroups.Add(group); return(group); }
static ReportFilterHelper() { LazyFilterGroups = new Lazy <IEnumerable <ReportFilter> >(() => { var vals = new List <ReportFilter>(); foreach (var val in Enum.GetValues(typeof(ReportFilter)).OfType <ReportFilter>().Where(val => val != ReportFilter.None)) { var temp = ExtractGroup(val); if (temp == val && !vals.Contains(val)) { vals.Add(val); } } return(vals); }, true); LazyFilterCaptions = new Lazy <IDictionary <ReportFilter, string> >(() => { var values = Enum.GetValues(typeof(ReportFilter)).OfType <ReportFilter>(); ReportFilter filters = default(ReportFilter); values.ToList().ForEach(filter => filters |= filter); var descriptions = filters.GetAttributeValues <System.ComponentModel.DescriptionAttribute, string>(x => x.Description); return(descriptions.ToDictionary(tuple => (ReportFilter)tuple.Item1, value => value.Item2)); }, true); LazyFilterGroupValues = new Lazy <IDictionary <ReportFilter, IList <ReportFilter> > >(() => { var result = FilterGroups.ToDictionary(k => k, v => new List <ReportFilter>() as IList <ReportFilter>); var values = Enum.GetValues(typeof(ReportFilter)) as ReportFilter[]; result.Keys.ToList().ForEach(group => { var toAdd = values.Where( (filter) => { var isGroup = filter.IsGroup(); if (!isGroup) { var isGroupValue = (group & filter) == group; return(isGroupValue); } return(false); }); (result[group] as List <ReportFilter>).AddRange(toAdd); }); return(result); }, true); LazyFilterGroupFlag = new Lazy <ReportFilter>(() => { var temp = default(ReportFilter); LazyFilterGroups.Value.ToList() .ForEach(group => temp |= group); return(temp); }, true); }
private async Task OnAddCommandExecuteAsync() { var logFilterGroup = new LogFilterGroup(); if (await _uiVisualizerService.ShowDialogAsync <LogFilterGroupEditorViewModel>(logFilterGroup) ?? false) { FilterGroups.Add(logFilterGroup); await SaveFilterGroupsAsync(); Updated.SafeInvoke(this); } }
private async Task OnRemoveCommandExecuteAsync() { var result = await _messageService.ShowAsync("Are you sure?", button : MessageButton.YesNo, icon : MessageImage.Warning); if (result == MessageResult.Yes) { FilterGroups.Remove(SelectedFilterGroup); await SaveFilterGroupsAsync(); SelectedFilterGroup = null; Updated.SafeInvoke(this); } }
private void FilterGroupPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e) { if (e.PropertyName == "SelectedTrack") { if (Object.ReferenceEquals(sender, _selectedFilterGroup)) { RaisePropertyChanged("SelectedTrack"); } else if ((sender is FilterGroupViewModel) && FilterGroups.Contains(sender)) { SelectedFilterGroup = (FilterGroupViewModel)sender; } } }
private async Task OnRemoveCommandExecuteAsync() { var result = await _messageService.ShowAsync(LanguageHelper.GetString("Controls_LogViewer_AreYouSure"), button : MessageButton.YesNo, icon : MessageImage.Warning); if (result == MessageResult.Yes) { FilterGroups.Remove(SelectedFilterGroup); await SaveFilterGroupsAsync(); SelectedFilterGroup = null; Updated?.Invoke(this, EventArgs.Empty); } }
public IActionResult Filter(FilterGroups model) { var groups = db.Groups.AsNoTracking(); if (!string.IsNullOrWhiteSpace(model.Name)) { groups = groups.Where(s => EF.Functions.Like(s.Name, $"%{model.Name}%")); } var viewModels = groups.Select(g => new ViewModels.FilterGroupsViewModel() { Id = g.Id, Name = g.Name, StudentsCount = g.StudentGroups.Count }).ToList(); return(Ok(viewModels)); }
public FilterGroup GetFilterGroup(string name) => FilterGroups.FirstOrDefault(g => g.GroupID.Equals(name.ToLower()));
protected override void CreateFilterGroups() { FilterGroups.Clear(); FilterGroups.Add(CreateWorkPeriodFilterGroup()); }
private async Task LoadFilterGroupsAsync() { var filterGroups = await _applicationLogFilterGroupService.LoadAsync(); FilterGroups.ReplaceRange(filterGroups /*.Where(x => !x.IsRuntime)*/.OrderBy(x => x.Name)); }
private async Task LoadFilterGroupsAsync() { FilterGroups.ReplaceRange(await _applicationLogFilterGroupService.LoadAsync()); }
public virtual Condition BuildCondition(Type type, VariableResolver variableResolver = null, IEnumerable <string> validProperties = null, IDictionary <string, string> propertyMapping = null) { if (type == null) { throw new ArgumentNullException(nameof(type)); } var arg = new BuildArgument { ValidProperties = validProperties, VariableResolver = variableResolver, EvaluationType = type, PropertyMapping = propertyMapping }; var error = new ConditionBase.ErrorInfo(); var result = new Condition(); var predicates = new List <LambdaExpression>(); var exceptions = new List <Exception>(); OrderByClause orderByClause = null; if (Filters != null && Filters.Any()) { var filtersResult = Filters.TryBuildPredicate(type, arg); if (filtersResult.Succeeded) { predicates.Add(filtersResult.Result); } else { if (filtersResult.Exception != null) { exceptions.Add(filtersResult.Exception); } } } if (FilterGroups != null && FilterGroups.Any()) { var filterGroupsResult = FilterGroups.TryBuildPredicate(type, arg); if (filterGroupsResult.Succeeded) { predicates.Add(filterGroupsResult.Result); } else { if (filterGroupsResult.Exception != null) { exceptions.Add(filterGroupsResult.Exception); } } } if (!string.IsNullOrEmpty(Where)) { var whereResult = ExpressionParser.Parse(Where, type, arg); if (whereResult.Succeeded) { predicates.Add(whereResult.Result); } else { if (whereResult.Exception != null) { exceptions.Add(whereResult.Exception); } } } if (!string.IsNullOrWhiteSpace(OrderBy)) { var orderByResult = OrderByParser.Parse(OrderBy, arg); if (orderByResult.Succeeded) { orderByClause = orderByResult.Result; } else { if (orderByResult.Exception != null) { exceptions.Add(orderByResult.Exception); } } } else if (OrderBys != null && OrderBys.Any()) { var orderBysResult = OrderByParser.Parse(OrderBys.ToArray(), arg); if (orderBysResult.Succeeded) { orderByClause = orderBysResult.Result; } else { if (orderBysResult.Exception != null) { exceptions.Add(orderBysResult.Exception); } } } var isInvalid = arg.InvalidProperties.Any() || arg.InvalidOperators.Any() || arg.InvalidVariables.Any() || exceptions.Any(); result.IsValid = !isInvalid; if (isInvalid) { error.EvaluationResult = new EvaluationResultBase { InvalidProperties = arg.InvalidProperties, InvalidValues = arg.InvalidValues, InvalidOperators = arg.InvalidOperators, InvalidVariables = arg.InvalidVariables, InvalidOrderByDirections = arg.InvalidOrderByDirections }; error.Exceptions = exceptions; result.Error = error; } else { result.Predicates = predicates; result.OrderByClause = orderByClause; } return(result); }