Feature/01 black on white

src/MoissonMontreal.Desktop/App.axaml

@@ -2,8 +2,7 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              x:Class="MoissonMontreal.Desktop.App"
              xmlns:local="using:MoissonMontreal.Desktop"
-             RequestedThemeVariant="Default">
-             <!-- "Default" ThemeVariant follows system theme variant. "Dark" or "Light" are other available options. -->
+             RequestedThemeVariant="Light">
 
     <Application.DataTemplates>
         <local:ViewLocator />

src/MoissonMontreal.Desktop/App.axaml.cs

@@ -1,25 +1,67 @@
+using System;
 using Avalonia;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Markup.Xaml;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using MoissonMontreal.Desktop.Services;
 using MoissonMontreal.Desktop.ViewModels;
 using MoissonMontreal.Desktop.Views;
 
+
 namespace MoissonMontreal.Desktop;
 
+/// <summary>
+/// Entry point of the Avalonia application: reads the configuration, sets up the services and opens the main window.
+/// </summary>
 public partial class App : Application
 {
+    /// <summary>
+    /// Loads the application's XAML (styles and resources).
+    /// </summary>
     public override void Initialize()
     {
         AvaloniaXamlLoader.Load(this);
     }
 
+    /// <summary>
+    /// Runs once Avalonia is ready: reads <c>appsettings.json</c>, registers the services and opens the main window.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when <c>appsettings.json</c> is missing, or when <c>Api:BaseUrl</c> is missing or invalid.</exception>
     public override void OnFrameworkInitializationCompleted()
     {
         if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
         {
+            var configuration = new ConfigurationBuilder()
+                .SetBasePath(AppContext.BaseDirectory)
+                .AddJsonFile("appsettings.json", optional: true)
+                .Build();
+
+            var apiBaseUrl = configuration["Api:BaseUrl"]
+                ?? throw new InvalidOperationException(
+                    $"Missing 'Api:BaseUrl': check that appsettings.json exists in '{AppContext.BaseDirectory}' and contains it.");
+
+            if (!Uri.TryCreate(apiBaseUrl, UriKind.Absolute, out var apiBaseUri)
+                || (apiBaseUri.Scheme != Uri.UriSchemeHttp && apiBaseUri.Scheme != Uri.UriSchemeHttps))
+            {
+                throw new InvalidOperationException($"Invalid 'Api:BaseUrl' in appsettings.json: '{apiBaseUrl}'. It must be a full URL starting with http:// or https://.");
+            }
+
+            var services = new ServiceCollection();
+
+            services.AddHttpClient<IApiClient, ApiClient>(client =>
+            {
+                client.BaseAddress = apiBaseUri;
+                client.Timeout = TimeSpan.FromSeconds(15);
+            });
+            services.AddSingleton<Func<IApiClient>>(sp => () => sp.GetRequiredService<IApiClient>());
+            services.AddSingleton<MainViewModel>();
+
+            var serviceProvider = services.BuildServiceProvider();
+
             desktop.MainWindow = new MainWindow
             {
-                DataContext = new MainViewModel(),
+                DataContext = serviceProvider.GetRequiredService<MainViewModel>(),
             };
         }
 

src/MoissonMontreal.Desktop/Design/DesignData.cs

@@ -0,0 +1,24 @@
+using MoissonMontreal.Desktop.ViewModels;
+
+namespace MoissonMontreal.Desktop.Design;
+
+/// <summary>
+/// Ready-made ViewModels for the IDE previewer. Never used when the app runs.
+/// </summary>
+public static class DesignData
+{
+    /// <summary>
+    /// Main window ViewModel backed by a <see cref="FakeApiClient"/>.
+    /// </summary>
+    public static MainViewModel Main { get; } = new(() => new FakeApiClient());
+
+    /// <summary>
+    /// Home page ViewModel backed by a <see cref="FakeApiClient"/>.
+    /// </summary>
+    public static HomeViewModel Home { get; } = new(new FakeApiClient());
+
+    /// <summary>
+    /// Login page ViewModel whose sign-in does nothing.
+    /// </summary>
+    public static LoginViewModel Login { get; } = new(() => { });
+}

src/MoissonMontreal.Desktop/Design/FakeApiClient.cs

@@ -0,0 +1,17 @@
+using System.Threading;
+using System.Threading.Tasks;
+using MoissonMontreal.Desktop.Services;
+
+namespace MoissonMontreal.Desktop.Design;
+
+/// <summary>
+/// Fake API client for the IDE previewer. Always reports the API as online, without any network call.
+/// </summary>
+public class FakeApiClient : IApiClient
+{
+    /// <inheritdoc/>
+    public Task<bool> IsApiReachableAsync(CancellationToken cancellationToken = default)
+    {
+        return Task.FromResult(true);
+    }
+}

src/MoissonMontreal.Desktop/MoissonMontreal.Desktop.csproj

@@ -9,6 +9,7 @@
   <ItemGroup>
     <Folder Include="Models\" />
     <AvaloniaResource Include="Assets\**" />
+    <None Update="appsettings.json" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 
   <ItemGroup>
@@ -21,6 +22,9 @@
       <PrivateAssets Condition="'$(Configuration)' != 'Debug'">All</PrivateAssets>
     </PackageReference>
     <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.2" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.14" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.14" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.14" />
   </ItemGroup>
 
   <ItemGroup>

src/MoissonMontreal.Desktop/Program.cs

@@ -3,16 +3,27 @@
 
 namespace MoissonMontreal.Desktop;
 
+/// <summary>
+/// Starts the desktop application.
+/// </summary>
 sealed class Program
 {
-    // Initialization code. Don't use any Avalonia, third-party APIs or any
-    // SynchronizationContext-reliant code before AppMain is called: things aren't initialized
-    // yet and stuff might break.
+    /// <summary>
+    /// Program entry point: starts Avalonia with a classic desktop window.
+    /// </summary>
+    /// <remarks>
+    /// Don't use any Avalonia, third-party APIs or any SynchronizationContext-reliant code
+    /// before AppMain is called: things aren't initialized yet and stuff might break.
+    /// </remarks>
+    /// <param name="args">Command-line arguments.</param>
     [STAThread]
     public static void Main(string[] args) => BuildAvaloniaApp()
         .StartWithClassicDesktopLifetime(args);
 
-    // Avalonia configuration, don't remove; also used by visual designer.
+    /// <summary>
+    /// Configures Avalonia. Don't remove: the visual designer uses it too.
+    /// </summary>
+    /// <returns>The configured application builder.</returns>
     public static AppBuilder BuildAvaloniaApp()
         => AppBuilder.Configure<App>()
             .UsePlatformDetect()

src/MoissonMontreal.Desktop/Services/ApiClient.cs

@@ -0,0 +1,44 @@
+using System.Threading.Tasks;
+using System.Net.Http;
+using System.Threading;
+
+namespace MoissonMontreal.Desktop.Services;
+
+/// <summary>
+/// Calls the central API over HTTP.
+/// </summary>
+public class ApiClient : IApiClient
+{
+    /// <summary>
+    /// HTTP client configured in <c>App</c> with the API's base address and timeout.
+    /// </summary>
+    private readonly HttpClient _httpClient;
+
+    /// <summary>
+    /// Creates the client.
+    /// </summary>
+    /// <param name="httpClient">HTTP client provided by the dependency injection container.</param>
+    public ApiClient(HttpClient httpClient)
+    {
+        _httpClient = httpClient;
+    }
+
+    /// <inheritdoc/>
+    public async Task<bool> IsApiReachableAsync(CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            // Any endpoint that answers successfully proves the API is reachable.
+            using var response = await _httpClient.GetAsync("WeatherForecast", cancellationToken);
+            return response.IsSuccessStatusCode;
+        }
+        catch (HttpRequestException)
+        {
+            return false;
+        }
+        catch (TaskCanceledException)
+        {
+            return false;
+        }
+    }
+}

src/MoissonMontreal.Desktop/Services/IApiClient.cs

@@ -0,0 +1,19 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MoissonMontreal.Desktop.Services;
+
+/// <summary>
+/// Talks to the central Moisson Montréal API.
+/// </summary>
+public interface IApiClient
+{
+    /// <summary>
+    /// Checks whether the API answers.
+    /// </summary>
+    /// <param name="cancellationToken">Lets the caller stop the check early (for example when leaving the page). If cancelled, the method returns <c>false</c>.</param>
+    /// <returns><c>true</c> if the API answered successfully; <c>false</c> if it is unreachable or returned an error.</returns>
+    Task<bool> IsApiReachableAsync(CancellationToken cancellationToken = default);
+}
+
+

src/MoissonMontreal.Desktop/ViewLocator.cs

@@ -14,6 +14,11 @@ namespace MoissonMontreal.Desktop;
     Url = "https://docs.avaloniaui.net/docs/concepts/view-locator")]
 public class ViewLocator : IDataTemplate
 {
+    /// <summary>
+    /// Creates the view that matches a ViewModel (for example <c>HomeViewModel</c> → <c>HomeView</c>).
+    /// </summary>
+    /// <param name="param">The ViewModel to show.</param>
+    /// <returns>The matching view, a "Not Found" text if there is none, or <c>null</c> if <paramref name="param"/> is <c>null</c>.</returns>
     public Control? Build(object? param)
     {
         if (param is null)
@@ -30,6 +35,11 @@ public class ViewLocator : IDataTemplate
         return new TextBlock { Text = "Not Found: " + name };
     }
 
+    /// <summary>
+    /// Tells Avalonia whether this locator can show the given object.
+    /// </summary>
+    /// <param name="data">The object to show.</param>
+    /// <returns><c>true</c> if the object is a ViewModel.</returns>
     public bool Match(object? data)
     {
         return data is ViewModelBase;

src/MoissonMontreal.Desktop/ViewModels/DonationsViewModel.cs

@@ -0,0 +1,12 @@
+namespace MoissonMontreal.Desktop.ViewModels;
+
+/// <summary>
+/// Logic of the donations page (placeholder for now).
+/// </summary>
+public class DonationsViewModel : ViewModelBase
+{
+    /// <summary>
+    /// Title shown at the top of the donations page.
+    /// </summary>
+    public string Title => "Donations";
+}

src/MoissonMontreal.Desktop/ViewModels/DonorsViewModel.cs

@@ -0,0 +1,12 @@
+namespace MoissonMontreal.Desktop.ViewModels;
+
+/// <summary>
+/// Logic of the donors page (placeholder for now).
+/// </summary>
+public class DonorsViewModel : ViewModelBase
+{
+    /// <summary>
+    /// Title shown at the top of the donors page.
+    /// </summary>
+    public string Title => "Donors";
+}

src/MoissonMontreal.Desktop/ViewModels/HomeViewModel.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using MoissonMontreal.Desktop.Services;
+
+namespace MoissonMontreal.Desktop.ViewModels;
+
+/// <summary>
+/// Logic of the home page: shows whether the API is reachable.
+/// </summary>
+public partial class HomeViewModel : ViewModelBase
+{
+    /// <summary>
+    /// Client used to check whether the API is reachable.
+    /// </summary>
+    private readonly IApiClient _apiClient;
+
+    /// <summary>
+    /// Status message shown while the API check is running.
+    /// </summary>
+    private const string CheckingApiMessage = "Checking the API...";
+
+    /// <summary>
+    /// Status message shown when the API cannot be reached.
+    /// </summary>
+    private const string ServerUnavailableMessage = "Server unavailable";
+
+    /// <summary>
+    /// Status message shown when the API answered successfully.
+    /// </summary>
+    private const string ApiOnlineMessage = "API online";
+
+    /// <summary>
+    /// Title shown at the top of the home page.
+    /// </summary>
+    public string Title => "Welcome";
+
+    /// <summary>
+    /// API status message shown to the user.
+    /// </summary>
+    [ObservableProperty]
+    public partial string ApiStatus { get; set; } = CheckingApiMessage;
+
+    /// <summary>
+    /// Creates the home page. The API check starts when the view is loaded.
+    /// </summary>
+    /// <param name="apiClient">Client used to call the API.</param>
+    public HomeViewModel(IApiClient apiClient)
+    {
+        _apiClient = apiClient;
+    }
+
+    /// <summary>
+    /// Checks the API and updates <see cref="ApiStatus"/>. Any error shows <see cref="ServerUnavailableMessage"/> instead of crashing the app.
+    /// </summary>
+    /// <param name="cancellationToken">Cancelled when the user leaves the home page, so the check doesn't keep running.</param>
+    [RelayCommand]
+    private async Task CheckApiAsync(CancellationToken cancellationToken)
+    {
+        ApiStatus = CheckingApiMessage;
+        try
+        {
+            var isReachable = await _apiClient.IsApiReachableAsync(cancellationToken);
+            ApiStatus = isReachable ? ApiOnlineMessage : ServerUnavailableMessage;
+        }
+        catch (Exception)
+        {
+            ApiStatus = ServerUnavailableMessage;
+        }
+    }
+}