teams: slightly changed the design and improved filtering options

TournamentOrganizer/ViewModels/TeamsViewModel.cs

@@ -42,10 +42,28 @@ public partial class TeamsViewModel : ViewModelBase
     private string _filterMemberName = string.Empty;
 
     [ObservableProperty]
-    private string _filterEventName = string.Empty;
+    private string? _selectedEventFilter;
 
     [ObservableProperty]
-    private string _filterTournamentName = string.Empty;
+    private string? _selectedTournamentFilter;
+
+    [ObservableProperty]
+    private ObservableCollection<string> _availableEvents = [];
+
+    [ObservableProperty]
+    private ObservableCollection<string> _availableTournaments = [];
+
+    [ObservableProperty]
+    private string _eventFilterSearch = string.Empty;
+
+    [ObservableProperty]
+    private string _tournamentFilterSearch = string.Empty;
+
+    [ObservableProperty]
+    private bool _isEventDropdownOpen;
+
+    [ObservableProperty]
+    private bool _isTournamentDropdownOpen;
 
     [ObservableProperty]
     private bool _isEditing;
@@ -53,6 +71,34 @@ public partial class TeamsViewModel : ViewModelBase
     [ObservableProperty]
     private string _statusMessage = string.Empty;
 
+    private readonly ObservableCollection<string> _filteredEvents = [];
+    public ObservableCollection<string> FilteredEvents => _filteredEvents;
+
+    private readonly ObservableCollection<string> _filteredTournaments = [];
+    public ObservableCollection<string> FilteredTournaments => _filteredTournaments;
+
+    partial void OnEventFilterSearchChanged(string value) => UpdateFilteredEvents();
+
+    partial void OnTournamentFilterSearchChanged(string value) => UpdateFilteredTournaments();
+
+    private void UpdateFilteredEvents()
+    {
+        _filteredEvents.Clear();
+        foreach (var e in AvailableEvents.Where(e => string.IsNullOrWhiteSpace(EventFilterSearch) || e.ToLower().Contains(EventFilterSearch.ToLower())))
+        {
+            _filteredEvents.Add(e);
+        }
+    }
+
+    private void UpdateFilteredTournaments()
+    {
+        _filteredTournaments.Clear();
+        foreach (var t in AvailableTournaments.Where(t => string.IsNullOrWhiteSpace(TournamentFilterSearch) || t.ToLower().Contains(TournamentFilterSearch.ToLower())))
+        {
+            _filteredTournaments.Add(t);
+        }
+    }
+
     public TeamsViewModel()
     {
         _context = new TournamentContext();
@@ -60,6 +106,25 @@ public partial class TeamsViewModel : ViewModelBase
 
     public async Task LoadTeams()
     {
+        var events = await _context.Events.ToListAsync();
+        AvailableEvents.Clear();
+        foreach (var e in events)
+        {
+            AvailableEvents.Add(e.Name);
+        }
+        UpdateFilteredEvents();
+
+        var games = await _context.Games.ToListAsync();
+        AvailableTournaments.Clear();
+        foreach (var g in games)
+        {
+            foreach (var e in events)
+            {
+                AvailableTournaments.Add($"{g.Name} @ {e.Name}");
+            }
+        }
+        UpdateFilteredTournaments();
+
         var query = _context.Teams
             .Include(t => t.Players)
             .Include(t => t.Leader)
@@ -79,15 +144,15 @@ public partial class TeamsViewModel : ViewModelBase
             filtered = filtered.Where(t => t.Players.Any(p => p.Name.ToLower().Contains(filter)));
         }
 
-        if (!string.IsNullOrWhiteSpace(FilterEventName))
+        if (!string.IsNullOrWhiteSpace(SelectedEventFilter))
         {
-            var filter = FilterEventName.ToLower();
+            var filter = SelectedEventFilter.ToLower();
             filtered = filtered.Where(t => GetAssociatedEvents(t).Any(e => e.ToLower().Contains(filter)));
         }
 
-        if (!string.IsNullOrWhiteSpace(FilterTournamentName))
+        if (!string.IsNullOrWhiteSpace(SelectedTournamentFilter))
         {
-            var filter = FilterTournamentName.ToLower();
+            var filter = SelectedTournamentFilter.ToLower();
             filtered = filtered.Where(t => GetAssociatedTournaments(t).Any(tn => tn.ToLower().Contains(filter)));
         }
 
@@ -101,6 +166,36 @@ public partial class TeamsViewModel : ViewModelBase
         IsEditing = false;
     }
 
+    public void SelectEventFilter(string eventName)
+    {
+        SelectedEventFilter = eventName;
+        IsEventDropdownOpen = false;
+        EventFilterSearch = string.Empty;
+        _ = LoadTeams();
+    }
+
+    public void ClearEventFilter()
+    {
+        SelectedEventFilter = null;
+        EventFilterSearch = string.Empty;
+        _ = LoadTeams();
+    }
+
+    public void SelectTournamentFilter(string tournamentName)
+    {
+        SelectedTournamentFilter = tournamentName;
+        IsTournamentDropdownOpen = false;
+        TournamentFilterSearch = string.Empty;
+        _ = LoadTeams();
+    }
+
+    public void ClearTournamentFilter()
+    {
+        SelectedTournamentFilter = null;
+        TournamentFilterSearch = string.Empty;
+        _ = LoadTeams();
+    }
+
     [RelayCommand]
     private async Task RefreshTeams()
     {
@@ -351,8 +446,6 @@ public partial class TeamsViewModel : ViewModelBase
     }
 
     partial void OnFilterMemberNameChanged(string value) => ApplyFilters();
-    partial void OnFilterEventNameChanged(string value) => ApplyFilters();
-    partial void OnFilterTournamentNameChanged(string value) => ApplyFilters();
 
     private async void ApplyFilters()
     {