Export now filters based on the filter row, meaning view exports don't take 56.2 years

InABox.Core/CoreUtils.cs

@@ -2311,13 +2311,13 @@ namespace InABox.Core
             //return CreateExpression(type, comps[comps.Length - 1]);
         }
 
-        public static Expression<Func<T, object>> CreateLambdaExpression<T>(string column)
+        public static Expression<Func<T, object?>> CreateLambdaExpression<T>(string column)
         {
             var parameter = Expression.Parameter(typeof(T), "x");
             var property = CreateMemberExpression(typeof(T), column);
             var converted = Expression.Convert(property, typeof(object));
             //var property = Expression.Convert(Expression.Property(parameter, column),typeof(object));
-            return Expression.Lambda<Func<T, object>>(converted, parameter);
+            return Expression.Lambda<Func<T, object?>>(converted, parameter);
         }
 
         public static Expression ConvertExpression(Type source, Expression lambda, Type target, Expression anchor)

InABox.DynamicGrid/BaseDynamicGrid.cs

@@ -72,10 +72,10 @@ namespace InABox.DynamicGrid
             Options.OnChanged += OptionsChanged;
             StyleSelector = GetStyleSelector();
             StyleSelector.GetStyle += (row, style) => GetStyle(row, style);
-            HiddenColumns = new List<Expression<Func<T, object>>>();
+            HiddenColumns = new List<Expression<Func<T, object?>>>();
         }
 
-        public List<Expression<Func<T, object>>> HiddenColumns { get; }
+        public List<Expression<Func<T, object?>>> HiddenColumns { get; }
 
         public virtual bool EditItems(object[] items, Func<Type, CoreTable>? PageDataHandler = null, bool PreloadPages = false)
         {

InABox.DynamicGrid/DynamicDataGrid.cs

@@ -876,7 +876,7 @@ namespace InABox.DynamicGrid
         {
             base.CustomiseExportFilters(filters, visiblerows);
 
-            if (IsEntity)
+            /*if (IsEntity)
             {
                 var ids = visiblerows.Select(r => r.Get<TEntity, Guid>(c => c.ID)).ToArray();
                 filters.Add(new Filter<TEntity>(x => x.ID).InList(ids));
@@ -901,7 +901,7 @@ namespace InABox.DynamicGrid
                     }
                 }
                 filters.Add(filter);
-            }
+            }*/
         }
 
         protected override IEnumerable<Tuple<Type?, CoreTable>> LoadExportTables(Filters<TEntity> filter, IEnumerable<Tuple<Type, IColumns>> tableColumns)

InABox.DynamicGrid/DynamicGrid.cs

@@ -1884,7 +1884,7 @@ namespace InABox.DynamicGrid
                 foreach (var column in MasterData.Columns)
                     Data.Columns.Add(column);
 
-            FilterRows();
+            LoadData();
         }
 
         private readonly Dictionary<CoreRow, CoreRow> _recordmap = new();
@@ -1934,22 +1934,19 @@ namespace InABox.DynamicGrid
             Refresh(false, false);
         }
 
-        private void FilterRows()
+        private void FilterRows(CoreTable from, CoreTable into, Dictionary<CoreRow, CoreRow>? recordMap = null, Func<CoreRow, bool>? filter = null)
         {
-            ResetClipBuffer();
-            Data.Rows.Clear();
-            _recordmap.Clear();
-            if (MasterData is null)
-                return;
-            foreach (var row in MasterData.Rows)
-                if (FilterRecord(row))
+            into.Rows.Clear();
+            recordMap?.Clear();
+            foreach (var row in from.Rows)
+                if (FilterRecord(row) && filter?.Invoke(row) != false)
                 {
-                    var newrow = Data.NewRow();
-                    for (var i = 0; i < Data.Columns.Count; i++)
+                    var newrow = into.NewRow();
+                    for (var i = 0; i < into.Columns.Count; i++)
                     {
                         var value = i < row.Values.Count ? row.Values[i] : null;
-                        if (Data.Columns[i].DataType.IsNumeric())
-                            value = Data.Columns[i].DataType.IsDefault(value) ? null : value;
+                        if (into.Columns[i].DataType.IsNumeric())
+                            value = into.Columns[i].DataType.IsDefault(value) ? null : value;
                         //else if (Data.Columns[i].DataType == typeof(String[]))
                         //    value = String.Join("\n", value as String[]);
                         newrow.Values.Add(value);
@@ -1957,15 +1954,22 @@ namespace InABox.DynamicGrid
 
                     //newrow.Values.AddRange(row.Values);
                     //if ((OnFilterRecord == null) || (OnFilterRecord(row)))
-                    Data.Rows.Add(newrow);
-                    _recordmap[newrow] = row;
+                    into.Rows.Add(newrow);
+                    recordMap?.TryAdd(newrow, row);
                 }
+        }
 
+        private void LoadData()
+        {
+            ResetClipBuffer();
+            if (MasterData is null)
+                return;
+            FilterRows(MasterData, Data, _recordmap);
 
             InvalidateGrid();
 
             //ScrollBar.Value = _CurrentRow <= 0 ? 0 : _CurrentRow;
-            SelectedRows = new CoreRow[] { };
+            SelectedRows = Array.Empty<CoreRow>();
         }
 
         //IncrementalList<T> _data = null;
@@ -2852,6 +2856,46 @@ namespace InABox.DynamicGrid
         protected virtual void ApplyExportFilter(CoreTable table, object data)
         {
         }
+        private static bool FilterByPredicate(CoreRow row, string column, FilterPredicate predicate)
+        {
+            var value = row[column];
+            var vStr = value?.ToString() ?? "";
+            var pValue = predicate.FilterValue;
+            var pStr = pValue?.ToString() ?? "";
+            return predicate.FilterType switch
+            {
+                FilterType.Contains => vStr.Contains(pStr),
+                FilterType.EndsWith => vStr.EndsWith(pStr),
+                FilterType.Equals => vStr.Equals(pStr),
+                FilterType.GreaterThan => vStr.CompareTo(pStr) > 0,
+                FilterType.GreaterThanOrEqual => vStr.CompareTo(pStr) >= 0,
+                FilterType.LessThan => vStr.CompareTo(pStr) < 0,
+                FilterType.LessThanOrEqual => vStr.CompareTo(pStr) <= 0,
+                FilterType.NotContains => !vStr.Contains(pStr),
+                FilterType.NotEndsWith => !vStr.EndsWith(pStr),
+                FilterType.NotEquals => !vStr.Equals(pStr),
+                FilterType.NotStartsWith => !vStr.StartsWith(pStr),
+                FilterType.StartsWith => vStr.StartsWith(pStr),
+                _ => true,
+            };
+        }
+        private List<Tuple<string, FilterPredicate>> GetFilterPredicates()
+        {
+            var list = new List<Tuple<string, FilterPredicate>>();
+            foreach (var column in DataGrid.Columns)
+            {
+                var colIndex = DataGrid.Columns.IndexOf(column);
+                var col = ColumnList[colIndex];
+                if (col is DynamicGridColumn gridColumn)
+                {
+                    foreach (var predicate in column.FilterPredicates)
+                    {
+                        list.Add(new(gridColumn.ColumnName, predicate));
+                    }
+                }
+            }
+            return list;
+        }
 
         private void Export_Click(object sender, RoutedEventArgs e)
         {
@@ -2864,6 +2908,8 @@ namespace InABox.DynamicGrid
             var filters = new Filters<T>();
             filters.Add(DefineFilter());
 
+            var predicates = GetFilterPredicates();
+
             var visiblerows = GetVisibleRows();
             CustomiseExportFilters(filters, visiblerows);
 
@@ -2874,11 +2920,41 @@ namespace InABox.DynamicGrid
                     (Activator.CreateInstance(typeof(Columns<>).MakeGenericType(x.Key), new object[] { x.Value }) as IColumns)!))
                 .Where(x => x.Item2.ColumnNames().Any()).ToList();
 
+            var reloadColumns = new Columns<T>();
+            foreach(var column in columns.ColumnNames())
+            {
+                reloadColumns.Add(column);
+            }
+            foreach(var column in HiddenColumns)
+            {
+                reloadColumns.Add(column);
+            }
+            foreach(var (column, _) in predicates)
+            {
+                reloadColumns.Add(column);
+            }
+
             var sort = LookupFactory.DefineSort<T>();
-            Reload(filters, columns, ref sort, (data, err) => Dispatcher.Invoke(() => {
+            Reload(filters, reloadColumns, ref sort, (data, err) => Dispatcher.Invoke(() => {
                 if(data is not null)
                 {
-                    var list = new List<Tuple<Type?, CoreTable>>() { new(typeof(T), data) };
+                    var newData = new CoreTable();
+                    foreach (var column in columns.Items)
+                        newData.Columns.Add(new CoreColumn { ColumnName = column.Property, DataType = column.ExpressionType()});
+
+                    FilterRows(data, newData, filter: (row) =>
+                    {
+                        foreach(var (column, predicate) in predicates)
+                        {
+                            if(!FilterByPredicate(row, column, predicate))
+                            {
+                                return false;
+                            }
+                        }
+                        return true;
+                    });
+
+                    var list = new List<Tuple<Type?, CoreTable>>() { new(typeof(T), newData) };
                     list.AddRange(LoadExportTables(filters, otherColumns));
                     DoExport(list);
                 }