Event management

TournamentOrganizer/ViewModels/EventsViewModel.cs

@@ -0,0 +1,386 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Microsoft.EntityFrameworkCore;
+using TournamentOrganizer.Models;
+
+namespace TournamentOrganizer.ViewModels;
+
+public partial class EventsViewModel : ViewModelBase
+{
+    private readonly TournamentContext _context;
+
+    [ObservableProperty]
+    private ObservableCollection<EventDisplay> _events = [];
+
+    [ObservableProperty]
+    private EventDisplay? _selectedEvent;
+
+    [ObservableProperty]
+    private string _eventName = string.Empty;
+
+    [ObservableProperty]
+    private DateTime _eventStart = DateTime.Today;
+
+    [ObservableProperty]
+    private DateTime _eventEnd = DateTime.Today.AddDays(1);
+
+    [ObservableProperty]
+    private ObservableCollection<TournamentDisplay> _tournaments = [];
+
+    [ObservableProperty]
+    private TournamentDisplay? _selectedTournament;
+
+    [ObservableProperty]
+    private GameOption? _selectedGameToAdd;
+
+    [ObservableProperty]
+    private string _filterEventName = string.Empty;
+
+    [ObservableProperty]
+    private bool _isEditing;
+
+    [ObservableProperty]
+    private string _statusMessage = string.Empty;
+
+    private readonly ObservableCollection<GameOption> _availableGames = [];
+    private readonly ObservableCollection<GameOption> _availableGamesToAdd = [];
+    public ObservableCollection<GameOption> AvailableGamesToAdd => _availableGamesToAdd;
+
+    public EventsViewModel()
+    {
+        _context = new TournamentContext();
+    }
+
+    partial void OnFilterEventNameChanged(string value) => ApplyFilters();
+
+    private async void ApplyFilters()
+    {
+        await LoadEvents();
+    }
+
+    public async Task LoadEvents()
+    {
+        var games = await _context.Games.ToListAsync();
+        _availableGames.Clear();
+        _availableGamesToAdd.Clear();
+        foreach (var g in games)
+        {
+            var option = new GameOption(g);
+            _availableGames.Add(option);
+            _availableGamesToAdd.Add(option);
+        }
+
+        var allEvents = await _context.Events
+            .Include(e => e.Tournaments)
+                .ThenInclude(t => t.Game)
+            .ToListAsync();
+
+        var filtered = allEvents.AsEnumerable();
+
+        if (!string.IsNullOrWhiteSpace(FilterEventName))
+        {
+            var filter = FilterEventName.ToLower();
+            filtered = filtered.Where(e => e.Name.ToLower().Contains(filter));
+        }
+
+        Events.Clear();
+        foreach (var evt in filtered)
+        {
+            Events.Add(new EventDisplay(evt));
+        }
+
+        SelectedEvent = null;
+        IsEditing = false;
+    }
+
+    [RelayCommand]
+    private async Task RefreshEvents()
+    {
+        await LoadEvents();
+    }
+
+    [RelayCommand]
+    private void CreateNewEvent()
+    {
+        EventName = "New Event";
+        EventStart = DateTime.Today;
+        EventEnd = DateTime.Today.AddDays(1);
+        Tournaments.Clear();
+        IsEditing = true;
+        SelectedEvent = null;
+        SelectedGameToAdd = null;
+        StatusMessage = "Creating new event";
+    }
+
+    [RelayCommand]
+    private async Task SaveEvent()
+    {
+        if (string.IsNullOrWhiteSpace(EventName))
+        {
+            StatusMessage = "Event name is required";
+            return;
+        }
+
+        if (EventEnd <= EventStart)
+        {
+            StatusMessage = "End date must be after start date";
+            return;
+        }
+
+        Event? evt;
+        if (SelectedEvent != null && SelectedEvent.Id > 0)
+        {
+            evt = await _context.Events
+                .Include(e => e.Tournaments)
+                .FirstOrDefaultAsync(e => e.Id == SelectedEvent.Id);
+
+            if (evt == null)
+            {
+                StatusMessage = "Event not found";
+                return;
+            }
+
+            evt.Name = EventName;
+            evt.Start = EventStart;
+            evt.End = EventEnd;
+        }
+        else
+        {
+            evt = new Event
+            {
+                Name = EventName,
+                Start = EventStart,
+                End = EventEnd,
+                Tournaments = []
+            };
+
+            _context.Events.Add(evt);
+        }
+
+        await _context.SaveChangesAsync();
+        StatusMessage = $"Event '{EventName}' saved successfully";
+        await LoadEvents();
+    }
+
+    [RelayCommand]
+    private async Task DeleteEvent()
+    {
+        if (SelectedEvent == null || SelectedEvent.Id == 0)
+        {
+            StatusMessage = "Select an event to delete";
+            return;
+        }
+
+        var evt = await _context.Events
+            .Include(e => e.Tournaments)
+            .FirstOrDefaultAsync(e => e.Id == SelectedEvent.Id);
+
+        if (evt == null)
+        {
+            StatusMessage = "Event not found";
+            return;
+        }
+
+        _context.Events.Remove(evt);
+        await _context.SaveChangesAsync();
+        StatusMessage = $"Event '{evt.Name}' deleted";
+        await LoadEvents();
+    }
+
+    [RelayCommand]
+    private async Task AddGameToEvent()
+    {
+        if (SelectedGameToAdd == null)
+        {
+            StatusMessage = "Select a game to add";
+            return;
+        }
+
+        if (SelectedEvent == null || SelectedEvent.Id == 0)
+        {
+            StatusMessage = "Save the event first before adding games";
+            return;
+        }
+
+        var evt = await _context.Events
+            .Include(e => e.Tournaments)
+            .FirstOrDefaultAsync(e => e.Id == SelectedEvent.Id);
+
+        if (evt == null)
+        {
+            StatusMessage = "Event not found";
+            return;
+        }
+
+        if (evt.Tournaments.Any(t => t.GameId == SelectedGameToAdd.Game.Id))
+        {
+            StatusMessage = "This game is already added to the event";
+            return;
+        }
+
+        var tournament = new Tournament
+        {
+            GameId = SelectedGameToAdd.Game.Id,
+            EventId = evt.Id,
+            Start = evt.Start,
+            End = evt.End,
+            S1RuleSet = SelectedGameToAdd.Game.S1RuleSet,
+            S1Groups = SelectedGameToAdd.Game.S1Groups,
+            S1GroupAdvances = SelectedGameToAdd.Game.S1GroupAdvances,
+            S2RuleSet = SelectedGameToAdd.Game.S2RuleSet,
+            Game = SelectedGameToAdd.Game,
+            Event = evt
+        };
+
+        evt.Tournaments.Add(tournament);
+        await _context.SaveChangesAsync();
+        StatusMessage = $"Added '{SelectedGameToAdd.Game.Name}' to event";
+        await LoadEventDetails();
+    }
+
+    [RelayCommand]
+    private async Task RemoveGameFromEvent()
+    {
+        if (SelectedTournament == null)
+        {
+            StatusMessage = "Select a tournament to remove";
+            return;
+        }
+
+        if (SelectedEvent == null || SelectedEvent.Id == 0)
+        {
+            StatusMessage = "Select an event first";
+            return;
+        }
+
+        var tournament = await _context.Tournaments.FirstOrDefaultAsync(t => t.Id == SelectedTournament.Id);
+        if (tournament == null)
+        {
+            StatusMessage = "Tournament not found";
+            return;
+        }
+
+        _context.Tournaments.Remove(tournament);
+        await _context.SaveChangesAsync();
+        StatusMessage = $"Removed '{SelectedTournament.GameName}' from event";
+        await LoadEventDetails();
+    }
+
+    private async Task LoadEventDetails()
+    {
+        var allEvents = await _context.Events
+            .Include(e => e.Tournaments)
+                .ThenInclude(t => t.Game)
+            .ToListAsync();
+
+        var evt = allEvents.FirstOrDefault(e => e.Id == (SelectedEvent?.Id ?? 0));
+        if (evt == null)
+        {
+            Tournaments.Clear();
+            return;
+        }
+
+        Tournaments.Clear();
+        foreach (var t in evt.Tournaments)
+        {
+            Tournaments.Add(new TournamentDisplay(t));
+        }
+
+        SelectedTournament = null;
+
+        _availableGamesToAdd.Clear();
+        foreach (var g in _availableGames)
+        {
+            if (!Tournaments.Any(t => t.GameId == g.Game.Id))
+            {
+                _availableGamesToAdd.Add(g);
+            }
+        }
+
+        SelectedGameToAdd = null;
+    }
+
+    partial void OnSelectedEventChanged(EventDisplay? value)
+    {
+        if (value == null)
+        {
+            IsEditing = false;
+            Tournaments.Clear();
+            return;
+        }
+
+        EventName = value.Name;
+        EventStart = value.Start;
+        EventEnd = value.End;
+        IsEditing = true;
+        _ = LoadEventDetails();
+        StatusMessage = $"Editing event '{value.Name}'";
+    }
+}
+
+public class EventDisplay
+{
+    public int Id { get; set; }
+    public string Name { get; set; } = string.Empty;
+    public DateTime Start { get; set; }
+    public DateTime End { get; set; }
+    public List<string> TournamentNames { get; set; } = [];
+
+    public EventDisplay() { }
+
+    public EventDisplay(Event evt)
+    {
+        Id = evt.Id;
+        Name = evt.Name;
+        Start = evt.Start;
+        End = evt.End;
+
+        if (evt.Tournaments != null)
+        {
+            TournamentNames = evt.Tournaments.Select(t => t.Game.Name).ToList();
+        }
+    }
+}
+
+public class TournamentDisplay
+{
+    public int Id { get; set; }
+    public int GameId { get; set; }
+    public string GameName { get; set; } = string.Empty;
+    public RuleSet S1RuleSet { get; set; }
+    public string S1RuleSetName => S1RuleSet.ToDisplayName();
+    public RuleSet? S2RuleSet { get; set; }
+    public string? S2RuleSetName => S2RuleSet?.ToDisplayName();
+
+    public TournamentDisplay() { }
+
+    public TournamentDisplay(Tournament tournament)
+    {
+        Id = tournament.Id;
+        GameId = tournament.GameId;
+        GameName = tournament.Game.Name;
+        S1RuleSet = tournament.S1RuleSet;
+        S2RuleSet = tournament.S2RuleSet;
+    }
+}
+
+public class GameOption
+{
+    public Game Game { get; set; } = null!;
+    public string DisplayName { get; set; } = string.Empty;
+
+    public GameOption() { }
+
+    public GameOption(Game game)
+    {
+        Game = game;
+        DisplayName = game.Name;
+    }
+
+    public override string ToString() => DisplayName;
+}

TournamentOrganizer/ViewModels/MainViewModel.cs

@@ -32,6 +32,24 @@ public partial class MainViewModel : ViewModelBase
         Title = "Teams Management";
         await teamsVm.LoadTeams();
     }
+
+    [RelayCommand]
+    private async Task NavigateToGames()
+    {
+        var gamesVm = new GamesViewModel();
+        CurrentView = gamesVm;
+        Title = "Games Management";
+        await gamesVm.LoadGames();
+    }
+
+    [RelayCommand]
+    private async Task NavigateToEvents()
+    {
+        var eventsVm = new EventsViewModel();
+        CurrentView = eventsVm;
+        Title = "Events Management";
+        await eventsVm.LoadEvents();
+    }
 }
 
 public partial class HomeViewModel : ViewModelBase

TournamentOrganizer/Views/EventsView.axaml

@@ -0,0 +1,143 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:vm="using:TournamentOrganizer.ViewModels"
+             mc:Ignorable="d" d:DesignWidth="1000" d:DesignHeight="600"
+             x:Class="TournamentOrganizer.Views.EventsView"
+             x:DataType="vm:EventsViewModel">
+  <Design.DataContext>
+    <vm:EventsViewModel />
+  </Design.DataContext>
+
+  <UserControl.Styles>
+    <Style Selector="Button.dropdown-item">
+      <Setter Property="Padding" Value="8,4"/>
+      <Setter Property="BorderThickness" Value="0"/>
+      <Setter Property="Background" Value="Transparent"/>
+      <Setter Property="HorizontalContentAlignment" Value="Left"/>
+    </Style>
+    <Style Selector="Button.dropdown-item:pointerover">
+      <Setter Property="Background" Value="{DynamicResource SystemControlBackgroundListLowBrush}"/>
+    </Style>
+  </UserControl.Styles>
+
+  <Grid RowDefinitions="Auto,*,Auto" ColumnDefinitions="*,*">
+    <TextBlock Grid.ColumnSpan="2" Grid.Row="0" Text="Events Management" FontSize="20" FontWeight="Bold" Margin="16,16,16,8"/>
+
+    <!-- Left Panel: Event List and Filter -->
+    <Border Grid.Column="0" Grid.Row="1" BorderBrush="Gray" BorderThickness="1" Margin="8" CornerRadius="4" Padding="8">
+      <DockPanel>
+        <!-- Header with New Event button -->
+        <DockPanel DockPanel.Dock="Top" Margin="0,0,0,8">
+          <Button Command="{Binding CreateNewEventCommand}" DockPanel.Dock="Right" Padding="8,4">
+            <StackPanel Orientation="Horizontal" Spacing="4">
+              <TextBlock Text="+" FontSize="16" FontWeight="Bold" VerticalAlignment="Center"/>
+              <TextBlock Text="New Event" VerticalAlignment="Center"/>
+            </StackPanel>
+          </Button>
+          <TextBlock Text="Events" FontSize="16" FontWeight="SemiBold" VerticalAlignment="Center"/>
+        </DockPanel>
+
+        <!-- Filter -->
+        <StackPanel DockPanel.Dock="Top" Spacing="6" Margin="0,0,0,8">
+          <TextBlock Text="Filters" FontWeight="SemiBold" FontSize="12"/>
+          <TextBox Watermark="Filter by event name..." Text="{Binding FilterEventName}"/>
+        </StackPanel>
+
+        <!-- Event List -->
+        <ListBox ItemsSource="{Binding Events}"
+                 SelectedItem="{Binding SelectedEvent}">
+          <ListBox.ItemTemplate>
+            <DataTemplate x:DataType="vm:EventDisplay">
+              <StackPanel Spacing="2">
+                <TextBlock Text="{Binding Name}" FontWeight="SemiBold"/>
+                <TextBlock Text="{Binding Start, StringFormat='{}{0:d}'}" FontSize="11" Foreground="Gray"/>
+                <TextBlock Text="{Binding End, StringFormat='to {0:d}'}" FontSize="11" Foreground="Gray"/>
+                <ItemsControl ItemsSource="{Binding TournamentNames}">
+                  <ItemsControl.ItemTemplate>
+                    <DataTemplate x:DataType="x:String">
+                      <TextBlock Text="{Binding, StringFormat='Game: {0}'}" FontSize="10" Foreground="#1976D2"/>
+                    </DataTemplate>
+                  </ItemsControl.ItemTemplate>
+                </ItemsControl>
+              </StackPanel>
+            </DataTemplate>
+          </ListBox.ItemTemplate>
+        </ListBox>
+      </DockPanel>
+    </Border>
+
+    <!-- Right Panel: Event Editor -->
+    <Border Grid.Column="1" Grid.Row="1" BorderBrush="Gray" BorderThickness="1" Margin="8" CornerRadius="4" Padding="8">
+      <DockPanel>
+        <TextBlock DockPanel.Dock="Top" Text="Event Details" FontSize="16" FontWeight="SemiBold" Margin="0,0,0,8"/>
+
+        <StackPanel DockPanel.Dock="Bottom" Spacing="6" Margin="0,8,0,0">
+          <Button Content="Save Event" Command="{Binding SaveEventCommand}" HorizontalAlignment="Stretch" IsEnabled="{Binding IsEditing}"/>
+          <Button Content="Delete Event" Command="{Binding DeleteEventCommand}" HorizontalAlignment="Stretch" IsEnabled="{Binding IsEditing}"/>
+        </StackPanel>
+
+        <ScrollViewer>
+          <StackPanel Spacing="8" IsEnabled="{Binding IsEditing}">
+            <!-- Event Name -->
+            <StackPanel Spacing="4">
+              <TextBlock Text="Event Name" FontWeight="SemiBold"/>
+              <TextBox Text="{Binding EventName}"/>
+            </StackPanel>
+
+            <!-- Start Date -->
+            <StackPanel Spacing="4">
+              <TextBlock Text="Start Date" FontWeight="SemiBold"/>
+              <CalendarDatePicker SelectedDate="{Binding EventStart}"/>
+            </StackPanel>
+
+            <!-- End Date -->
+            <StackPanel Spacing="4">
+              <TextBlock Text="End Date" FontWeight="SemiBold"/>
+              <CalendarDatePicker SelectedDate="{Binding EventEnd}"/>
+            </StackPanel>
+
+            <!-- Tournaments / Games Section -->
+            <StackPanel Spacing="4">
+              <TextBlock Text="Tournaments" FontWeight="SemiBold"/>
+
+              <!-- Add Game Dropdown -->
+              <Grid ColumnDefinitions="*,Auto" ColumnSpacing="4">
+                <ComboBox Grid.Column="0" ItemsSource="{Binding AvailableGamesToAdd}" SelectedItem="{Binding SelectedGameToAdd}">
+                  <ComboBox.ItemTemplate>
+                    <DataTemplate x:DataType="vm:GameOption">
+                      <TextBlock Text="{Binding DisplayName}"/>
+                    </DataTemplate>
+                  </ComboBox.ItemTemplate>
+                </ComboBox>
+                <Button Grid.Column="1" Content="Add" Command="{Binding AddGameToEventCommand}" IsEnabled="{Binding SelectedGameToAdd, Converter={x:Static ObjectConverters.IsNotNull}}" VerticalAlignment="Center"/>
+              </Grid>
+
+              <!-- Tournament List -->
+              <ListBox ItemsSource="{Binding Tournaments}"
+                       SelectedItem="{Binding SelectedTournament}"
+                       MinHeight="100"
+                       MaxHeight="200">
+                <ListBox.ItemTemplate>
+                  <DataTemplate x:DataType="vm:TournamentDisplay">
+                    <StackPanel Spacing="2">
+                      <TextBlock Text="{Binding GameName}" FontWeight="SemiBold"/>
+                      <TextBlock Text="{Binding S1RuleSetName, StringFormat='Stage 1: {0}'}" FontSize="11" Foreground="Gray"/>
+                      <TextBlock Text="{Binding S2RuleSetName, StringFormat='Stage 2: {0}'}" FontSize="11" Foreground="Gray" IsVisible="{Binding S2RuleSet, Converter={x:Static ObjectConverters.IsNotNull}}"/>
+                    </StackPanel>
+                  </DataTemplate>
+                </ListBox.ItemTemplate>
+              </ListBox>
+
+              <Button Content="Remove Selected" Command="{Binding RemoveGameFromEventCommand}" IsEnabled="{Binding SelectedTournament, Converter={x:Static ObjectConverters.IsNotNull}}" HorizontalAlignment="Left"/>
+            </StackPanel>
+          </StackPanel>
+        </ScrollViewer>
+      </DockPanel>
+    </Border>
+
+    <!-- Status Bar -->
+    <TextBlock Grid.ColumnSpan="2" Grid.Row="2" Text="{Binding StatusMessage}" Margin="8" Foreground="Gray" FontSize="12"/>
+  </Grid>
+</UserControl>

TournamentOrganizer/Views/EventsView.axaml.cs

@@ -0,0 +1,11 @@
+using Avalonia.Controls;
+
+namespace TournamentOrganizer.Views;
+
+public partial class EventsView : UserControl
+{
+    public EventsView()
+    {
+        InitializeComponent();
+    }
+}

TournamentOrganizer/Views/MainView.axaml

@@ -15,6 +15,8 @@
     <Border DockPanel.Dock="Top" Background="#2D2D30" Padding="8">
       <StackPanel Orientation="Horizontal" Spacing="4">
         <Button Content="Home" Command="{Binding NavigateToHomeCommand}" Padding="16,8" FontSize="14" Foreground="White" Background="Transparent" BorderThickness="0"/>
+        <Button Content="Events" Command="{Binding NavigateToEventsCommand}" Padding="16,8" FontSize="14" Foreground="White" Background="Transparent" BorderThickness="0"/>
+        <Button Content="Games" Command="{Binding NavigateToGamesCommand}" Padding="16,8" FontSize="14" Foreground="White" Background="Transparent" BorderThickness="0"/>
         <Button Content="Teams" Command="{Binding NavigateToTeamsCommand}" Padding="16,8" FontSize="14" Foreground="White" Background="Transparent" BorderThickness="0"/>
       </StackPanel>
     </Border>