Refactored filter cache to use string instead of FilterModel

src/EventLogExpert.Eventing/Models/DisplayEventModel.cs

@@ -1,7 +1,6 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Eventing.Helpers;
 using System.Diagnostics.Eventing.Reader;
 using System.Text;
 

src/EventLogExpert.UI/Store/FilterCache/FilterCacheAction.cs

@@ -1,34 +1,33 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.UI.Models;
 using System.Collections.Immutable;
 
 namespace EventLogExpert.UI.Store.FilterCache;
 
 public sealed record FilterCacheAction
 {
-    public sealed record AddFavoriteFilter(FilterModel Filter);
+    public sealed record AddFavoriteFilter(string Filter);
 
-    public sealed record AddFavoriteFilterCompleted(ImmutableList<FilterModel> Filters);
+    public sealed record AddFavoriteFilterCompleted(ImmutableList<string> Filters);
 
-    public sealed record AddRecentFilter(FilterModel Filter);
+    public sealed record AddRecentFilter(string Filter);
 
-    public sealed record AddRecentFilterCompleted(ImmutableQueue<FilterModel> Filters);
+    public sealed record AddRecentFilterCompleted(ImmutableQueue<string> Filters);
 
-    public sealed record ImportFavorites(List<FilterModel> Filters);
+    public sealed record ImportFavorites(List<string> Filters);
 
     public sealed record LoadFilters;
 
     public sealed record LoadFiltersCompleted(
-        ImmutableList<FilterModel> FavoriteFilters,
-        ImmutableQueue<FilterModel> RecentFilters);
+        ImmutableList<string> FavoriteFilters,
+        ImmutableQueue<string> RecentFilters);
 
     public sealed record OpenMenu;
 
-    public sealed record RemoveFavoriteFilter(FilterModel Filter);
+    public sealed record RemoveFavoriteFilter(string Filter);
 
     public sealed record RemoveFavoriteFilterCompleted(
-        ImmutableList<FilterModel> FavoriteFilters,
-        ImmutableQueue<FilterModel> RecentFilters);
+        ImmutableList<string> FavoriteFilters,
+        ImmutableQueue<string> RecentFilters);
 }

src/EventLogExpert.UI/Store/FilterCache/FilterCacheEffects.cs

@@ -19,7 +19,7 @@ public Task HandleAddFavoriteFilter(FilterCacheAction.AddFavoriteFilter action,
 
         var newFilters = state.Value.FavoriteFilters.Add(action.Filter);
 
-        preferencesProvider.FavoriteFiltersPreference = newFilters.Select(filter => filter.Comparison.Value).ToList();
+        preferencesProvider.FavoriteFiltersPreference = newFilters;
 
         dispatcher.Dispatch(new FilterCacheAction.AddFavoriteFilterCompleted(newFilters));
 
@@ -30,16 +30,16 @@ public Task HandleAddFavoriteFilter(FilterCacheAction.AddFavoriteFilter action,
     public Task HandleAddRecentFilter(FilterCacheAction.AddRecentFilter action, IDispatcher dispatcher)
     {
         if (state.Value.RecentFilters.Any(filter =>
-            string.Equals(filter.Comparison.Value, action.Filter.Comparison.Value, StringComparison.OrdinalIgnoreCase)))
+            string.Equals(filter, action.Filter, StringComparison.OrdinalIgnoreCase)))
         {
             return Task.CompletedTask;
         }
 
-        ImmutableQueue<FilterModel> newFilters = state.Value.RecentFilters.Count() >= MaxRecentFilterCount
+        ImmutableQueue<string> newFilters = state.Value.RecentFilters.Count() >= MaxRecentFilterCount
             ? state.Value.RecentFilters.Dequeue().Enqueue(action.Filter)
             : state.Value.RecentFilters.Enqueue(action.Filter);
 
-        preferencesProvider.RecentFiltersPreference = newFilters.Select(filter => filter.Comparison.Value).ToList();
+        preferencesProvider.RecentFiltersPreference = newFilters.ToList();
 
         dispatcher.Dispatch(new FilterCacheAction.AddRecentFilterCompleted(newFilters));
 
@@ -49,15 +49,16 @@ public Task HandleAddRecentFilter(FilterCacheAction.AddRecentFilter action, IDis
     [EffectMethod]
     public Task HandleImportFavorites(FilterCacheAction.ImportFavorites action, IDispatcher dispatcher)
     {
-        List<FilterModel> newFilters = [.. state.Value.FavoriteFilters];
+        List<string> newFilters = [.. state.Value.FavoriteFilters];
 
         foreach (var filter in
-            action.Filters.Where(filter => !newFilters.Any(x => filter.Comparison.Value.Equals(x.Comparison.Value))))
+            action.Filters.Where(filter =>
+                !newFilters.Any(x => string.Equals(filter, x, StringComparison.OrdinalIgnoreCase))))
         {
             newFilters.Add(filter);
         }
 
-        preferencesProvider.FavoriteFiltersPreference = newFilters.Select(filter => filter.Comparison.Value).ToList();
+        preferencesProvider.FavoriteFiltersPreference = newFilters;
 
         dispatcher.Dispatch(new FilterCacheAction.AddFavoriteFilterCompleted([.. newFilters]));
 
@@ -70,17 +71,17 @@ public Task HandleLoadFilters(FilterCacheAction.LoadFilters action, IDispatcher
         var favoritesPreference = preferencesProvider.FavoriteFiltersPreference;
         var recentPreference = preferencesProvider.RecentFiltersPreference;
 
-        List<FilterModel> favorites = [];
-        List<FilterModel> recent = [];
+        List<string> favorites = [];
+        List<string> recent = [];
 
         foreach (var filter in favoritesPreference)
         {
-            favorites.Add(new FilterModel { Comparison = new FilterComparison { Value = filter } });
+            favorites.Add(filter);
         }
 
         foreach (var filter in recentPreference)
         {
-            recent.Add(new FilterModel { Comparison = new FilterComparison { Value = filter } });
+            recent.Add(filter);
         }
 
         dispatcher.Dispatch(
@@ -94,14 +95,11 @@ public Task HandleRemoveFavoriteFilter(FilterCacheAction.RemoveFavoriteFilter ac
     {
         if (!state.Value.FavoriteFilters.Contains(action.Filter)) { return Task.CompletedTask; }
 
-        ImmutableList<FilterModel> favorites;
-        ImmutableQueue<FilterModel> recent;
+        ImmutableList<string> favorites;
+        ImmutableQueue<string> recent;
 
         if (state.Value.RecentFilters.Any(filter =>
-            string.Equals(
-                filter.Comparison.Value,
-                action.Filter.Comparison.Value,
-                StringComparison.OrdinalIgnoreCase)))
+            string.Equals(filter, action.Filter, StringComparison.OrdinalIgnoreCase)))
         {
             favorites = state.Value.FavoriteFilters.Remove(action.Filter);
             recent = state.Value.RecentFilters;
@@ -117,8 +115,8 @@ public Task HandleRemoveFavoriteFilter(FilterCacheAction.RemoveFavoriteFilter ac
             recent = state.Value.RecentFilters.Enqueue(action.Filter);
         }
 
-        preferencesProvider.FavoriteFiltersPreference = favorites.Select(filter => filter.Comparison.Value).ToList();
-        preferencesProvider.RecentFiltersPreference = recent.Select(filter => filter.Comparison.Value).ToList();
+        preferencesProvider.FavoriteFiltersPreference = favorites;
+        preferencesProvider.RecentFiltersPreference = recent.ToList();
 
         dispatcher.Dispatch(new FilterCacheAction.RemoveFavoriteFilterCompleted(favorites, recent));
 

src/EventLogExpert.UI/Store/FilterCache/FilterCacheState.cs

@@ -1,7 +1,6 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.UI.Models;
 using Fluxor;
 using System.Collections.Immutable;
 
@@ -10,7 +9,7 @@ namespace EventLogExpert.UI.Store.FilterCache;
 [FeatureState]
 public sealed record FilterCacheState
 {
-    public ImmutableList<FilterModel> FavoriteFilters { get; init; } = [];
+    public ImmutableList<string> FavoriteFilters { get; init; } = [];
 
-    public ImmutableQueue<FilterModel> RecentFilters { get; init; } = [];
+    public ImmutableQueue<string> RecentFilters { get; init; } = [];
 }

src/EventLogExpert.UI/Store/FilterPane/FilterPaneEffects.cs

@@ -6,7 +6,6 @@
 using EventLogExpert.UI.Store.FilterCache;
 using EventLogExpert.UI.Store.FilterColor;
 using Fluxor;
-using System;
 using System.Collections.Immutable;
 
 namespace EventLogExpert.UI.Store.FilterPane;
@@ -29,7 +28,7 @@ public async Task HandleAddFilter(FilterPaneAction.AddFilter action, IDispatcher
         if (action.FilterModel?.Comparison.Value is not null)
         {
             dispatcher.Dispatch(
-                new FilterCacheAction.AddRecentFilter(action.FilterModel with { }));
+                new FilterCacheAction.AddRecentFilter(action.FilterModel.Comparison.Value));
         }
 
         if (action.FilterModel?.IsEnabled is true)
@@ -89,7 +88,7 @@ public async Task HandleSetAdvancedFilterSuccess(FilterPaneAction.SetAdvancedFil
 
         if (action.FilterModel is not null)
         {
-            dispatcher.Dispatch(new FilterCacheAction.AddRecentFilter(action.FilterModel with { }));
+            dispatcher.Dispatch(new FilterCacheAction.AddRecentFilter(action.FilterModel.Comparison.Value));
         }
     }
 
@@ -100,7 +99,7 @@ public async Task HandleSetFilter(FilterPaneAction.SetFilter action, IDispatcher
 
         if (!string.IsNullOrEmpty(action.FilterModel.Comparison.Value))
         {
-            dispatcher.Dispatch(new FilterCacheAction.AddRecentFilter(action.FilterModel with { }));
+            dispatcher.Dispatch(new FilterCacheAction.AddRecentFilter(action.FilterModel.Comparison.Value));
         }
 
         UpdateFilterColors(action.FilterModel, dispatcher);

src/EventLogExpert/Shared/Components/Filters/FilterCacheModal.razor

@@ -16,7 +16,7 @@
                             <button class="button button-yellow" type="button" @onclick="() => RemoveFavorite(filter)">
                                 <i class="bi bi-star-fill"></i>
                             </button>
-                            <span>@filter.Comparison.Value</span>
+                            <span>@filter</span>
                         </div>
 
                         <button class="button button-green" type="button" @onclick="() => AddFilter(filter)">
@@ -38,7 +38,7 @@
                             <button class="button button-yellow" type="button" @onclick="() => AddFavorite(filter)">
                                 <i class="bi bi-star"></i>
                             </button>
-                            <span>@filter.Comparison.Value</span>
+                            <span>@filter</span>
                         </div>
 
                         <button class="button button-green" type="button" @onclick="() => AddFilter(filter)">

src/EventLogExpert/Shared/Components/Filters/FilterCacheModal.razor.cs

@@ -29,12 +29,15 @@ protected override void OnInitialized()
         base.OnInitialized();
     }
 
-    private void AddFavorite(FilterModel filter) =>
+    private void AddFavorite(string filter) =>
         Dispatcher.Dispatch(new FilterCacheAction.AddFavoriteFilter(filter));
 
-    private void AddFilter(FilterModel filter)
+    private void AddFilter(string filter)
     {
-        Dispatcher.Dispatch(new FilterPaneAction.AddCachedFilter(filter));
+        Dispatcher.Dispatch(
+            new FilterPaneAction.AddCachedFilter(
+                new FilterModel { Comparison = new FilterComparison { Value = filter } }));
+
         Close().AndForget();
     }
 
@@ -64,7 +67,7 @@ private async Task ExportFavorites()
         {
             using var stream = new MemoryStream(
                 JsonSerializer.SerializeToUtf8Bytes(
-                    FilterCacheState.Value.FavoriteFilters.Select(x => x.Comparison.Value)));
+                    FilterCacheState.Value.FavoriteFilters));
 
             await using var fileStream = await result.OpenStreamForWriteAsync();
 
@@ -97,13 +100,9 @@ private async Task ImportFavorites()
         try
         {
             await using var stream = File.OpenRead(result.FullPath);
-            var json = await JsonSerializer.DeserializeAsync<List<string>>(stream);
-
-            if (json is null) { return; }
+            var filters = await JsonSerializer.DeserializeAsync<List<string>>(stream);
 
-            var filters = json
-                .Select(x => new FilterModel { Comparison = new FilterComparison { Value = x } })
-                .ToList();
+            if (filters is null) { return; }
 
             Dispatcher.Dispatch(new FilterCacheAction.ImportFavorites(filters));
         }
@@ -117,6 +116,6 @@ await AlertDialogService.ShowAlert("Import Failed",
 
     private async Task Open() => await JSRuntime.InvokeVoidAsync("openFilterCacheModal");
 
-    private void RemoveFavorite(FilterModel filter) =>
+    private void RemoveFavorite(string filter) =>
         Dispatcher.Dispatch(new FilterCacheAction.RemoveFavoriteFilter(filter));
 }

src/EventLogExpert/Shared/Components/Filters/FilterCacheRow.razor.cs

@@ -27,8 +27,8 @@ public sealed partial class FilterCacheRow
 
     private List<string> Items => _cacheType switch
     {
-        CacheType.Favorites => FilterCacheState.Value.FavoriteFilters.Select(x => x.Comparison.Value).ToList(),
-        CacheType.Recent => FilterCacheState.Value.RecentFilters.Select(x => x.Comparison.Value).ToList(),
+        CacheType.Favorites => [.. FilterCacheState.Value.FavoriteFilters],
+        CacheType.Recent => [.. FilterCacheState.Value.RecentFilters],
         _ => [],
     };
 
@@ -66,7 +66,7 @@ private void SaveFilter()
             _filter.Comparison.Value = _filterValue;
 
             Dispatcher.Dispatch(new FilterPaneAction.RemoveCachedFilter(Value));
-            Dispatcher.Dispatch(new FilterCacheAction.AddRecentFilter(_filter));
+            Dispatcher.Dispatch(new FilterCacheAction.AddRecentFilter(_filterValue));
             Dispatcher.Dispatch(new FilterPaneAction.AddCachedFilter(_filter));
         }
         catch (Exception ex)