MudDataGrid: Allow overriding default filter operators per column (MudBlazor#10254)

Author: Anu6is

src/MudBlazor.UnitTests.Viewer/TestComponents/DataGrid/DataGridFilterPerColumnTest.razor

@@ -0,0 +1,32 @@
+<MudPopoverProvider></MudPopoverProvider>
+
+<MudDataGrid Items="@_items" Filterable="true">
+    <Columns>
+        <PropertyColumn Property="x => x.Firstname" FilterOperators="@_nameOperators" />
+        <PropertyColumn Property="x => x.Lastname" />
+        <PropertyColumn Property="x => x.Age" FilterOperators="_ageOperators" />
+        <PropertyColumn Property="x => x.Status" FilterOperators="@(AddInvalid ? _invalidOperators : [])" />
+        <PropertyColumn Property="x => x.HiredOn" FilterOperators="_dateOperators" />
+    </Columns>
+</MudDataGrid>
+
+@code {
+    private HashSet<string> _nameOperators = [FilterOperator.String.StartsWith, FilterOperator.String.EndsWith, FilterOperator.String.Equal, FilterOperator.String.Contains];
+    private HashSet<string> _ageOperators = [FilterOperator.Number.LessThan, FilterOperator.Number.GreaterThan, FilterOperator.Number.Equal];
+    private HashSet<string> _dateOperators = [FilterOperator.DateTime.Before, FilterOperator.DateTime.After];
+
+    private HashSet<string> _invalidOperators = [FilterOperator.Enum.Is, FilterOperator.Enum.IsNot, FilterOperator.Number.LessThan];
+
+    private IEnumerable<Model> _items = new List<Model>()
+    {
+        new Model("Sam", "Smith", 56, Severity.Normal, null),
+        new Model("Alicia", "Applewood", 54, Severity.Info, null),
+        new Model("Ira", "Irving", 27, Severity.Success, new DateTime(2011, 1, 2)),
+        new Model("John", "Jameson", 32, Severity.Warning, null)
+    };
+
+    [Parameter]
+    public bool AddInvalid { get; set; }
+
+    public record Model(string Firstname, string Lastname, int Age, Severity Status, DateTime? HiredOn);
+}

src/MudBlazor.UnitTests/Components/DataGridTests.cs

@@ -2599,6 +2599,46 @@ await comp.InvokeAsync(() => dataGrid.Instance.AddFilterAsync(new FilterDefiniti
             filterDefinition6.Value.Should().Be(guid);
         }
 
+        [Test]
+        public void DataGridFilterPerColumnTest()
+        {
+            var comp = Context.RenderComponent<DataGridFilterPerColumnTest>();
+            var dataGrid = comp.FindComponent<MudDataGrid<DataGridFilterPerColumnTest.Model>>();
+
+            IElement FirstnameFilterButton() => dataGrid.FindAll(".filter-button")[0];
+
+            // click on the filter button
+            FirstnameFilterButton().Click();
+
+            // check the number of filters displayed in the filters panel is 1
+            comp.FindAll(".filters-panel .mud-grid-item.d-flex").Count.Should().Be(1);
+
+            // get select menus
+            var selects = comp.FindAll(".filters-panel .mud-grid-item .mud-input-control.mud-select");
+            selects.Count.Should().Be(2);
+
+            // open operator menu
+            selects[1].PointerDown();
+
+            //check available operators
+            var items = comp.FindAll("div.mud-list-item");
+
+            items.Count.Should().Be(4);
+            items.ToMarkup()
+                 .Should().Contain("starts with")
+                 .And.Contain("ends with")
+                 .And.Contain("equals")
+                 .And.Contain("contains");
+        }
+
+        [Test]
+        public void DataGridInvalidFilterPerColumnTest()
+        {
+            var exception = Assert.Throws<ArgumentException>(() => Context.RenderComponent<DataGridFilterPerColumnTest>(parameters => parameters.Add(x => x.AddInvalid, true)));
+
+            exception.Message.Should().Be("Invalid filter operators for Severity: <");
+        }
+
         [Test]
         public async Task DataGridIDictionaryFiltersTest()
         {

src/MudBlazor/Components/DataGrid/Column.razor.cs

@@ -325,6 +325,12 @@ public Func<T, object> SortBy
         [Parameter]
         public RenderFragment<FilterContext<T>> FilterTemplate { get; set; }
 
+        /// <summary>
+        /// The operators to use for this column's filter.
+        /// </summary>
+        [Parameter]
+        public HashSet<string> FilterOperators { get; set; } = [];
+
         /// <summary>
         /// The unique identifier for this column.
         /// </summary>
@@ -532,7 +538,7 @@ public FilterContext<T> FilterContext
                 // Make sure that when we access filterContext properties, they have been defined...
                 if (filterContext.FilterDefinition == null)
                 {
-                    var operators = FilterOperator.GetOperatorByDataType(PropertyType);
+                    var operators = GetFilterOperators(FieldType.Identify(PropertyType));
                     var filterDefinition = DataGrid.CreateFilterDefinitionInstance();
                     filterDefinition.Title = Title;
                     filterDefinition.Operator = operators.FirstOrDefault();
@@ -569,11 +575,22 @@ private async Task OnGroupingParameterChangedAsync()
 
         protected override void OnInitialized()
         {
+            if (FilterOperators.Count > 0)
+            {
+                var defaultOperators = FilterOperator.GetOperatorByDataType(PropertyType);
+                var invalidOperators = FilterOperators.Where(@operator => !defaultOperators.Contains(@operator)).ToArray();
+
+                if (invalidOperators.Length > 0)
+                {
+                    throw new ArgumentException($"Invalid filter operators for {PropertyType.Name}: {string.Join(", ", invalidOperators)}");
+                }
+            }
+
             base.OnInitialized();
+
             groupBy = GroupBy;
 
-            if (DataGrid != null)
-                DataGrid.AddColumn(this);
+            DataGrid?.AddColumn(this);
 
             // Add the HeaderContext
             headerContext = new HeaderContext<T>(DataGrid);
@@ -600,6 +617,18 @@ protected override void OnInitialized()
             footerContext = new FooterContext<T>(DataGrid);
         }
 
+        internal IReadOnlyCollection<string> GetFilterOperators(FieldType fieldType)
+        {
+            if (FilterOperators.Count == 0)
+            {
+                return FilterOperator.GetOperatorByDataType(fieldType);
+            }
+            else
+            {
+                return FilterOperators;
+            }
+        }
+
         internal Func<T, object> GetLocalSortFunc()
         {
             if (_sortBy == null)

src/MudBlazor/Components/DataGrid/Filter.cs

@@ -61,7 +61,7 @@ internal async Task RemoveFilterAsync()
         internal void FieldChanged(Column<T> column)
         {
             _filterDefinition.Column = column;
-            var operators = FilterOperator.GetOperatorByDataType(column.PropertyType);
+            var operators = column.GetFilterOperators(FieldType.Identify(column.PropertyType));
             _filterDefinition.Operator = operators.FirstOrDefault();
             _filterDefinition.Title = column.Title;
             _filterDefinition.Value = null;

src/MudBlazor/Components/DataGrid/FilterHeaderCell.razor.cs

@@ -62,11 +62,11 @@ private Type dataType
 
         private FieldType fieldType => FieldType.Identify(dataType);
 
-        private string[] operators
+        private IReadOnlyCollection<string> operators
         {
             get
             {
-                return FilterOperator.GetOperatorByDataType(dataType);
+                return Column.GetFilterOperators(FieldType.Identify(dataType));
             }
         }
 

src/MudBlazor/Components/DataGrid/MudDataGrid.razor

@@ -534,7 +534,7 @@
                     <MudItem xs="3">
                         <MudSelect @bind-Value="filterDefinition.Operator" FullWidth="true" Label="@Localizer[LanguageResource.MudDataGrid_Operator]" Dense="true" Margin="@Margin.Dense"
                                    Class="filter-operator">
-                            @foreach (var fieldOperator in FilterOperator.GetOperatorByDataType(fieldType))
+                            @foreach (var fieldOperator in filterDefinition.Column.GetFilterOperators(fieldType))
                             {
                                 <MudSelectItem Value="@fieldOperator">@Localizer[FilterOperator.GetTranslationKeyByOperatorName(fieldOperator)]</MudSelectItem>
                             }
@@ -597,7 +597,7 @@
                     <MudItem xs="12">
                         <MudSelect @bind-Value="filterDefinition.Operator" FullWidth="true" Dense="true" Margin="@Margin.Dense"
                                    Class="filter-operator">
-                            @foreach (var o in FilterOperator.GetOperatorByDataType(fieldType))
+                            @foreach (var o in column.GetFilterOperators(fieldType))
                             {
                                 <MudSelectItem Value="@o">@Localizer[FilterOperator.GetTranslationKeyByOperatorName(o)]</MudSelectItem>
                             }