From 0ac6970e9d1d8cd00744536d8b45b1d75fdf44fa Mon Sep 17 00:00:00 2001 From: Paul Schneider Date: Fri, 13 Nov 2026 12:32:58 +0000 Subject: [PATCH] feat(postit): keep sessions online and replace banner with auth modal Remove the sticky session banner, keep the app connected when possible, restore sessions silently on startup, and show a blocking authentication modal with login, register, and forgot-password actions when auto-reconnect cannot resume the session. Add targeted auth and responsive-layout regressions and update the architecture notes to match the session lifecycle. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- CHANGELOG.md | 2 + doc/architecture/postit-oidc.md | 69 +++-- doc/architecture/postit.md | 6 +- .../AndroidMarkdownEditorTestActivity.cs | 7 +- .../Fixtures/OidcStubAuthority.cs | 6 + .../PostIt.Tests/MarkdownEditorScrollTests.cs | 10 +- .../SessionAuthenticationTests.cs | 293 ++++++++++++++++++ .../PostIt.Tests/YavscApiClientTests.cs | 27 +- src/PostIt/PostIt/App.axaml.cs | 11 +- .../Helpers/ServiceCollectionHelpers.cs | 4 +- src/PostIt/PostIt/Services/YavscApiClient.cs | 74 +++-- .../Layout/SessionStatusViewModel.cs | 141 ++++++--- src/PostIt/PostIt/Views/Layout/HomePage.axaml | 14 + src/PostIt/PostIt/Views/Layout/MainView.axaml | 40 ++- .../PostIt/Views/Layout/MainView.axaml.cs | 40 +++ .../Views/Layout/SessionStatusBanner.axaml | 36 --- .../Views/Layout/SessionStatusBanner.axaml.cs | 11 - 17 files changed, 628 insertions(+), 163 deletions(-) create mode 100644 src/PostIt/PostIt.Tests/SessionAuthenticationTests.cs delete mode 100644 src/PostIt/PostIt/Views/Layout/SessionStatusBanner.axaml delete mode 100644 src/PostIt/PostIt/Views/Layout/SessionStatusBanner.axaml.cs diff --git a/CHANGELOG.md b/CHANGELOG.md index d25b2269f..b359d92cc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ ### Added +* [PostIt/Authentication] Remove the persistent session status bar to recover small-screen space. Restore cached sessions silently and launch OIDC login automatically at startup when restoration fails. Keep proactive renewal and transient-failure retries; display a blocking, scrollable authentication modal on login failure, logout, expired/revoked sessions or a final authenticated 401, with login, registration and password recovery on the configured authority. Move settings, About and logout to the Home menu, preserve the current page during recovery, and cover startup, renewal, account URLs, focus and compact layouts. + * [Resources/Notifications] Persist private user alerts when net resource consumption crosses 50%, 75%, 90%, 95% or 99% of the personal limit, atomically with accounting. Report only the highest threshold crossed per update and rearm after credits or released storage lower consumption. Keep notification consultation and dismissal accessible at quota without consuming resources; no email or live push is sent. * [Yavsc.Api] Preserve `application/problem+json` for resource-usage relief errors instead of overriding it with a JSON-only Produces attribute; document success/error media types in OpenAPI and verify error payloads. Restore the haircut and grouped-haircut commands removed from the test seed while retaining its three catalog prestations, with repeated-reset coverage. diff --git a/doc/architecture/postit-oidc.md b/doc/architecture/postit-oidc.md index ddedbfde8..cf11320c1 100644 --- a/doc/architecture/postit-oidc.md +++ b/doc/architecture/postit-oidc.md @@ -20,7 +20,10 @@ L'authentification suit **RFC 8252 §7.1** (OAuth 2.0 for Native Apps — Custom URI Scheme Redirect), pas le pattern loopback historique. La séquence : -1. L'utilisateur clique **Se connecter** sur `LoginPage`. +1. Au démarrage, PostIt restaure la session silencieusement. Si cette + reprise échoue, il lance directement le login OIDC, sans confirmation. + Une nouvelle tentative peut aussi être lancée avec **Se connecter** + dans la modale d'authentification. 2. `YavscApiClient.LoginInteractiveAsync` demande à `OidcClient` de calculer l'authorize URL et de la passer à `CustomSchemeBrowser.InvokeAsync`. @@ -61,8 +64,8 @@ pas vers un serveur HTTP. | `Services/CustomSchemeBrowser` | `IBrowser` OidcClient qui ouvre le système + attend le pipe. | | `Services/SchemeUrlDetector` | Détection pure, testable, du `postit://callback` dans argv. | | `Services/TokenStore` | Persiste `RefreshTokenRecord` (access/refresh/id + expiry). Mode 0600 sur POSIX. | -| `ViewModels/SessionStatusViewModel` | VM du bandeau persistant Connecté/Déconnecté + Logout. | -| `Views/SessionStatusBanner` | Bandeau affiché en haut de `MainWindow`, visible sur toutes les pages. | +| `ViewModels/SessionStatusViewModel` | État partagé de session, démarrage automatique, login/logout et liens de compte. | +| `Views/Layout/MainView` | Modale d'authentification superposée à la navigation, sans barre d'état persistante. | ## Plateformes (`PostIt.Desktop`, `PostIt.Android`, `PostIt.Browser`) @@ -78,8 +81,9 @@ Chaque plateforme injecte son propre `IBrowser` via ## UX observable -`LoginPage` affiche en continu la **phase** courante du flow -(badge `PhaseLabel`) en plus du `StatusMessage` textuel : +La modale affiche l'attente du navigateur et les erreurs de connexion. +Les actions sont désactivées pendant le login pour éviter les ouvertures +concurrentes. Le client expose aussi les phases suivantes à ses appelants : | Phase | Signification | |--------------------|------------------------------------------------------------------| @@ -89,7 +93,7 @@ Chaque plateforme injecte son propre `IBrowser` via | `ExchangingCode` | Trade du `code` contre les tokens à `/connect/token`. | | `Success` / `Error`| Issue du flow. | -Si le badge reste bloqué sur `OpeningBrowser`, **l'OS n'a jamais +Si le flow reste bloqué sur `OpeningBrowser`, **l'OS n'a jamais relancé PostIt avec l'URL `postit://callback`** : le scheme handler n'est pas enregistré correctement. @@ -100,19 +104,42 @@ Au boot, `App.OnFrameworkInitializationCompleted` : 1. Construit le `TokenStore` (~/.config/PostIt/tokens.json) et `YavscApiClient`. Ce dernier charge `_tokens = store.Load()` dans son constructeur. -2. Ouvre `MainWindow` avec `HomePage` comme racine. -3. Sur l'événement `Opened`, appelle `TrySilentLoginAsync` : +2. Crée la racine `MainView` et démarre la maintenance de session. +3. À l'initialisation de la racine, appelle `TrySilentLoginAsync` une + seule fois par processus : - si l'access token a encore `> RefreshSkew` (60 s) de vie → - `Success` immédiat, push `MainPage`. + `Success` immédiat. - sinon, tente un refresh via le refresh token. Si l'IdP - accepte → push `MainPage`. Si l'IdP rejette (révocation, - vol, expiration du refresh) → `_store.Clear()`, retour à - `HomePage`. + accepte → la session est restaurée. Un rejet permanent + (`invalid_grant` / `invalid_client`) purge le store ; une erreur + temporaire conserve les jetons pour une nouvelle tentative. + - sans session restaurée, lance immédiatement le login interactif. +4. Initialise la messagerie et affiche `HomePage` si la pile est vide. -Le bandeau `SessionStatusBanner` reflète `Api.HasValidSession` -en continu et expose le bouton **Se déconnecter**, qui appelle -`Api.LogoutAsync()` (purge du store) puis `PopToRootAsync` -pour ramener sur `HomePage`. +La maintenance renouvelle les jetons 60 secondes avant expiration, +sans attendre un appel API. Les échecs temporaires sont retentés après +30 secondes ; la reprise d'activité réveille également la maintenance. +L'option Android de maintien en arrière-plan conserve son comportement. + +Un échec de login ou de renouvellement, l'expiration sans refresh token, +une déconnexion explicite ou un 401 authentifié persistant après la +tentative de refresh affiche la modale de `MainView`. La navigation en +dessous est désactivée et le clavier reste dans la modale. Celle-ci +défile sur les petits écrans et propose : + +- **Se connecter** : nouveau flow OIDC/PKCE ; +- **Créer un compte** : navigateur sur `Account/Register` de l'autorité ; +- **Mot de passe oublié** : navigateur sur `Account/ForgotPassword` + de la même autorité configurée. + +Les liens conservent l'éventuel préfixe de chemin de l'autorité. +L'ouverture d'un lien de compte ne valide pas une session : l'utilisateur +revient ensuite sur **Se connecter**. Un renouvellement silencieux réussi +ferme la modale sans changer la page ni les brouillons. + +**Paramètres**, **À propos** et **Se déconnecter** sont dans le menu +secondaire de l'accueil. La déconnexion purge le store puis ramène la +navigation à l'accueil ; elle ne relance pas le navigateur automatiquement. ## Garanties testées @@ -125,9 +152,13 @@ pour ramener sur `HomePage`. case-insensitive, refuse les faux positifs (`postit-…://`), retourne le premier match de manière déterministe. -Le chemin "refresh token rejeté → purge du store" est testé -manuellement ; le stub `OidcStubAuthority` ne sait pas encore -rejeter un refresh token précis — extension future. +- Démarrage sans session, avec session valide et après refresh silencieux. +- Rejet du refresh token, erreur temporaire puis reprise, expiration sans + refresh token, refus 401 persistant et déconnexion explicite. +- Modale en portrait compact et paysage bas : actions accessibles par + défilement, navigation bloquée, restauration du focus et de la page. +- Liens de création de compte et de récupération du mot de passe sur + l'autorité configurée, y compris avec un préfixe de chemin. ## Voir aussi diff --git a/doc/architecture/postit.md b/doc/architecture/postit.md index 7dba2ba78..e7198ccc5 100644 --- a/doc/architecture/postit.md +++ b/doc/architecture/postit.md @@ -124,7 +124,7 @@ La taille maximale par fichier et les quotas podcast restent inchangés. L'accueil présente un seul accès **Administration**, visible et exécutable uniquement pour le rôle exact `Administrator`. `SessionStatusViewModel.RefreshAsync` lit les rôles dans `GET account/me` après le rafraîchissement de session ; -une erreur de lecture masque l'accès et affiche une erreur dans la bannière. +une erreur de lecture masque l'accès et affiche une erreur sur l'accueil. La déconnexion invalide aussi les vérifications de droits encore en vol. `AdministrationPage` regroupe sept onglets : utilisateurs, usages globaux, @@ -430,7 +430,7 @@ le DI est construit. Ordre, dans cet ordre : | `SettingsPage` | **Singleton** | Une seule instance pour la vie de l'app : le `DataContext` est câblé une fois au boot, le push est idempotent (cf. section *Garde anti-empilement* ci-dessous). | | `MainPage` / `HomePage` / `SignaturePage` | Transient | Résolution à la demande par le `ViewLocator`. | | `MainPageViewModel` / `HomePageViewModel` / `SignaturePageViewModel` | Transient | VM reconstruites à chaque navigation ; pas d'état partagé à conserver. | -| `SessionStatusViewModel` + `SessionStatusBanner` | Singleton + Transient | Le VM est un singleton (survit à la navigation), le bandeau est transient (réinstancié quand la fenêtre le recrée). | +| `SessionStatusViewModel` | Singleton | État partagé de session ; la modale de `MainView` survit fonctionnellement à la navigation et à la recréation d'activité via ce VM. | > **Invariant** : `Settings` est **uniquement** un singleton. Un > `AddTransient()` supplémentaire (qui réécrase le @@ -621,7 +621,7 @@ pour `[RelayCommand]`". | Page | DataContext | Rôle | |----------------------------|--------------------------|-----------------------------------------------------------------------| | `MainWindow` | `HomePageViewModel` (initial) | Host de la `NavigationPage`. | -| `SessionStatusBanner` | `SessionStatusViewModel` | Bandeau persistant en haut de la fenêtre, visible sur toutes les pages. Boutons Login / Logout / Paramètres. | +| Modale de `MainView` | `SessionStatusViewModel` | Connexion requise : login, inscription et mot de passe oublié. Navigation bloquée jusqu'à la reprise de session ; aucune barre d'état persistante. | | `HomePage` | `HomePageViewModel` | Page d'accueil publique. | | `MainPage` | `MainPageViewModel` | Éditeur de post de blog (après login). | | `SignaturePage` | `SignaturePageViewModel` | Capture de signature (estimateur). | diff --git a/src/PostIt/PostIt.Tests/Fixtures/AndroidMarkdownEditorTestActivity.cs b/src/PostIt/PostIt.Tests/Fixtures/AndroidMarkdownEditorTestActivity.cs index 02580a7cc..615de9540 100644 --- a/src/PostIt/PostIt.Tests/Fixtures/AndroidMarkdownEditorTestActivity.cs +++ b/src/PostIt/PostIt.Tests/Fixtures/AndroidMarkdownEditorTestActivity.cs @@ -186,15 +186,14 @@ public sealed class AndroidMarkdownEditorTestActivity : Activity activity.CurrentFocus!.GetLocationInWindow(location); var topLevel = TopLevel.GetTopLevel(root)!; var navigation = root.FindControl("NavRoot")!; - var banner = root.FindControl("SessionBanner")!; var top = navigation.TranslatePoint(new Point(), topLevel)!.Value.Y * topLevel.RenderScaling + location[1]; - var bottom = banner.TranslatePoint(new Point(0, banner.Bounds.Height), topLevel)!.Value.Y + var bottom = navigation.TranslatePoint(new Point(0, navigation.Bounds.Height), topLevel)!.Value.Y * topLevel.RenderScaling + location[1]; var visibleBottom = decor.Height - bars.Bottom; if (KeyboardVisible()) visibleBottom = Math.Min(visibleBottom, decor.Height - insets.GetInsets(WindowInsets.Type.Ime()).Bottom); - if (top < bars.Top - 2 || bottom > visibleBottom + 2 || !banner.IsVisible) - throw new InvalidOperationException($"Controls overlap system bars: top={top}, safeTop={bars.Top}, bottom={bottom}, safeBottom={visibleBottom}, banner={banner.IsVisible}."); + if (top < bars.Top - 2 || bottom > visibleBottom + 2) + throw new InvalidOperationException($"Controls overlap system bars: top={top}, safeTop={bars.Top}, bottom={bottom}, safeBottom={visibleBottom}."); if (navigation.NavigationStack.LastOrDefault() is BlogsPage page) { var bar = NavigationPage.GetTopCommandBar(page)!; diff --git a/src/PostIt/PostIt.Tests/Fixtures/OidcStubAuthority.cs b/src/PostIt/PostIt.Tests/Fixtures/OidcStubAuthority.cs index 6de94e090..120e3a9e4 100644 --- a/src/PostIt/PostIt.Tests/Fixtures/OidcStubAuthority.cs +++ b/src/PostIt/PostIt.Tests/Fixtures/OidcStubAuthority.cs @@ -26,6 +26,7 @@ public sealed class OIDCStubAuthority : IAsyncDisposable, IDisposable public string Issuer { get; } public string LoopbackRedirectUri { get; } public int RefreshRequestCount { get; private set; } + public string? RefreshError { get; set; } private OIDCStubAuthority(HttpListener listener, RSA rsa, string kid, string issuer, string loopback) { @@ -137,6 +138,11 @@ public sealed class OIDCStubAuthority : IAsyncDisposable, IDisposable if (form.TryGetValue("grant_type", out var grantType) && grantType == "refresh_token") { RefreshRequestCount++; + if (RefreshError is { } error) + { + await WriteJsonAsync(ctx.Response, new { error }, 503); + return; + } if (!form.TryGetValue("refresh_token", out var suppliedToken) || !_refreshTokens.Remove(suppliedToken)) { diff --git a/src/PostIt/PostIt.Tests/MarkdownEditorScrollTests.cs b/src/PostIt/PostIt.Tests/MarkdownEditorScrollTests.cs index 9e49d8d8c..2fb0e5a78 100644 --- a/src/PostIt/PostIt.Tests/MarkdownEditorScrollTests.cs +++ b/src/PostIt/PostIt.Tests/MarkdownEditorScrollTests.cs @@ -44,7 +44,7 @@ public class MarkdownEditorScrollTests window.UpdateLayout(); Assert.True(page.DraftTitleTextBox.IsVisible); Assert.True(page.AttachmentsBorder.IsVisible); - Assert.True(root.SessionBanner.IsVisible); + Assert.False(root.AuthenticationModal.IsVisible); Assert.Equal(1, Grid.GetColumn(page.DraftTitleTextBox)); Assert.Equal(1, Grid.GetColumn(page.AttachmentsBorder)); Assert.True(page.StatusBar.IsVisible); @@ -60,7 +60,7 @@ public class MarkdownEditorScrollTests window.UpdateLayout(); Assert.True(page.DraftTitleTextBox.IsVisible); Assert.True(page.AttachmentsBorder.IsVisible); - Assert.True(root.SessionBanner.IsVisible); + Assert.False(root.AuthenticationModal.IsVisible); Assert.Equal(0, Grid.GetColumn(page.DraftTitleTextBox)); Assert.Same(document, source.Document); Assert.True(source.TextArea.IsFocused); @@ -98,10 +98,10 @@ public class MarkdownEditorScrollTests window.UpdateLayout(); Assert.Equal(new Thickness(20, 26, 22, 32), root.Padding); var navigationTop = root.NavRoot.TranslatePoint(new Point(), window)!.Value.Y; - var bannerBottom = root.SessionBanner.TranslatePoint(new Point(0, root.SessionBanner.Bounds.Height), window)!.Value.Y; + var navigationBottom = root.NavRoot.TranslatePoint(new Point(0, root.NavRoot.Bounds.Height), window)!.Value.Y; Assert.True(navigationTop >= 26); - Assert.True(bannerBottom <= 768); - Assert.True(root.SessionBanner.IsVisible); + Assert.True(navigationBottom <= 768); + Assert.False(root.AuthenticationModal.IsVisible); } finally { diff --git a/src/PostIt/PostIt.Tests/SessionAuthenticationTests.cs b/src/PostIt/PostIt.Tests/SessionAuthenticationTests.cs new file mode 100644 index 000000000..080a1470a --- /dev/null +++ b/src/PostIt/PostIt.Tests/SessionAuthenticationTests.cs @@ -0,0 +1,293 @@ +using System.Net.Http; +using System.Text.Json; +using Avalonia; +using Avalonia.Controls; +using Avalonia.Input; +using Avalonia.Threading; +using Avalonia.VisualTree; +using PostIt.Services; +using PostIt.ViewModels; +using PostIt.Views; + +namespace PostIt.Tests; + +[Trait("Category", "non-reg")] +[Collection(AvaloniaUiCollection.Name)] +public sealed class SessionAuthenticationTests(AvaloniaUiFixture ui) +{ + [Theory] + [InlineData(false, 0)] + [InlineData(true, 600)] + [InlineData(true, -10)] + public Task Startup_restores_the_session_or_logs_in_without_confirmation(bool cached, int lifetime) + => ui.RunAsync(async () => + { + using var authority = await OIDCStubAuthority.StartAsync(); + var path = Path.Combine(Path.GetTempPath(), $"postit-session-{Guid.NewGuid():N}.json"); + var previousBrowser = Platform.CreateBrowser; + var launches = 0; + try + { + var store = new TokenStore(path); + var settings = SettingsFor(authority); + Platform.CreateBrowser = () => + { + launches++; + return new FakeAuthorizingBrowser(authority.LoopbackRedirectUri).CreateBrowser(); + }; + if (cached) + { + await using var original = new ProfileApi(settings, store); + await original.LoginInteractiveAsync(); + store.Save(store.Load()! with { AccessTokenExpiresAt = DateTimeOffset.UtcNow.AddSeconds(lifetime) }); + } + launches = 0; + await using var api = new ProfileApi(settings, store); + var model = new SessionStatusViewModel { Api = api }; + await model.InitializeAsync(); + Assert.Equal(cached ? 0 : 1, launches); + Assert.Equal(cached && lifetime < 0 ? 1 : 0, authority.RefreshRequestCount); + Assert.True(model.IsLoggedIn); + Assert.True(model.IsAdministrator); + Assert.False(model.IsAuthenticationRequired); + Assert.NotNull(store.Load()); + } + finally + { + Platform.CreateBrowser = previousBrowser; + File.Delete(path); + } + }, TestContext.Current.CancellationToken); + + [Fact] + public Task Failed_startup_login_exposes_retry_and_account_actions() + => ui.RunAsync(async () => + { + var path = Path.Combine(Path.GetTempPath(), $"postit-session-{Guid.NewGuid():N}.json"); + var previousBrowser = Platform.CreateBrowser; + try + { + Platform.CreateBrowser = null; + await using var api = new ProfileApi(new Settings(), new TokenStore(path)); + var model = new SessionStatusViewModel { Api = api }; + await model.InitializeAsync(); + Assert.True(model.IsAuthenticationRequired); + Assert.False(model.IsLoggedIn); + Assert.Contains("Connexion impossible", model.SessionLabel); + Assert.True(model.LoginCommand.CanExecute(null)); + Assert.True(model.RegisterCommand.CanExecute(null)); + Assert.True(model.ForgotPasswordCommand.CanExecute(null)); + } + finally + { + Platform.CreateBrowser = previousBrowser; + File.Delete(path); + } + }, TestContext.Current.CancellationToken); + + [Fact] + public Task Transient_refresh_failure_keeps_tokens_and_successful_retry_closes_the_modal() + => ui.RunAsync(async () => + { + using var authority = await OIDCStubAuthority.StartAsync(); + var path = Path.Combine(Path.GetTempPath(), $"postit-session-{Guid.NewGuid():N}.json"); + var previousBrowser = Platform.CreateBrowser; + try + { + var store = new TokenStore(path); + var settings = SettingsFor(authority); + Platform.CreateBrowser = () => new FakeAuthorizingBrowser(authority.LoopbackRedirectUri).CreateBrowser(); + await using (var original = new ProfileApi(settings, store)) + await original.LoginInteractiveAsync(); + store.Save(store.Load()! with { AccessTokenExpiresAt = DateTimeOffset.UtcNow.AddSeconds(40) }); + await using var api = new ProfileApi(settings, store); + var model = new SessionStatusViewModel { Api = api }; + model.Refresh(); + authority.RefreshError = "temporarily_unavailable"; + var error = await Assert.ThrowsAsync(() => + api.RefreshSessionIfNeededAsync(true, TestContext.Current.CancellationToken)); + Dispatcher.UIThread.RunJobs(); + Assert.False(error.IsPermanent); + Assert.NotNull(store.Load()); + Assert.True(model.IsAuthenticationRequired); + authority.RefreshError = null; + await api.RefreshSessionIfNeededAsync(true, TestContext.Current.CancellationToken); + Dispatcher.UIThread.RunJobs(); + Assert.True(model.IsLoggedIn); + Assert.True(model.IsAdministrator); + Assert.False(model.IsAuthenticationRequired); + Assert.Equal(2, authority.RefreshRequestCount); + } + finally + { + Platform.CreateBrowser = previousBrowser; + File.Delete(path); + } + }, TestContext.Current.CancellationToken); + + [Fact] + public Task Expired_session_without_refresh_token_requires_authentication() + => ui.RunAsync(async () => + { + var path = Path.Combine(Path.GetTempPath(), $"postit-session-{Guid.NewGuid():N}.json"); + try + { + var store = new TokenStore(path); + store.Save(new RefreshTokenRecord("access", "", DateTimeOffset.UtcNow.AddSeconds(-1))); + await using var api = new ProfileApi(new Settings(), store); + var model = new SessionStatusViewModel { Api = api }; + Assert.Equal(TimeSpan.Zero, api.GetSessionRefreshDelay(DateTimeOffset.UtcNow, true)); + await Assert.ThrowsAsync(() => + api.RefreshSessionIfNeededAsync(true, TestContext.Current.CancellationToken)); + Dispatcher.UIThread.RunJobs(); + Assert.True(model.IsAuthenticationRequired); + Assert.False(api.HasValidSession); + Assert.Null(store.Load()); + } + finally { File.Delete(path); } + }, TestContext.Current.CancellationToken); + + [Fact] + public async Task Modal_restores_the_previous_page_and_focus_after_silent_recovery() + { + var path = Path.Combine(Path.GetTempPath(), $"postit-session-{Guid.NewGuid():N}.json"); + try + { + var store = new TokenStore(path); + store.Save(new RefreshTokenRecord("access", "refresh", DateTimeOffset.UtcNow.AddMinutes(10))); + await using var api = new ProfileApi(new Settings(), store); + var session = new SessionStatusViewModel { Api = api }; + session.Refresh(); + await ui.WithWindowAsync(() => new MainView + { + DataContext = new HomePageViewModel(api, api.Settings, session, null!) + }, async window => + { + var root = Assert.IsType(window.Content); + var editor = new TextBox { Text = "Brouillon conservé" }; + var page = new ContentPage { Content = editor }; + await root.NavRoot.PushAsync(page, null); + Dispatcher.UIThread.RunJobs(); + window.UpdateLayout(); + Assert.True(editor.Focus()); + session.SetError("Session temporairement indisponible"); + Dispatcher.UIThread.RunJobs(); + Assert.True(root.LoginButton.IsFocused); + session.Refresh(); + Dispatcher.UIThread.RunJobs(); + Assert.False(root.AuthenticationModal.IsVisible); + Assert.True(root.NavRoot.IsEnabled); + Assert.True(editor.IsFocused); + Assert.Same(page, root.NavRoot.NavigationStack.Last()); + Assert.Equal("Brouillon conservé", editor.Text); + }, TestContext.Current.CancellationToken); + } + finally { File.Delete(path); } + } + + [Fact] + public Task Revoked_background_session_opens_the_modal_and_login_recovers() + => ui.RunAsync(async () => + { + using var authority = await OIDCStubAuthority.StartAsync(); + var path = Path.Combine(Path.GetTempPath(), $"postit-session-{Guid.NewGuid():N}.json"); + var previousBrowser = Platform.CreateBrowser; + try + { + var settings = SettingsFor(authority); + var store = new TokenStore(path); + store.Save(new RefreshTokenRecord("access", "revoked", DateTimeOffset.UtcNow.AddSeconds(40))); + await using var api = new ProfileApi(settings, store); + var model = new SessionStatusViewModel { Api = api }; + model.Refresh(); + Assert.False(model.IsAuthenticationRequired); + await Assert.ThrowsAsync(() => + api.RefreshSessionIfNeededAsync(true, TestContext.Current.CancellationToken)); + Dispatcher.UIThread.RunJobs(); + Assert.False(model.IsLoggedIn); + Assert.False(model.IsAdministrator); + Assert.True(model.IsAuthenticationRequired); + Assert.Contains("Session expirée", model.SessionLabel); + Platform.CreateBrowser = () => new FakeAuthorizingBrowser(authority.LoopbackRedirectUri).CreateBrowser(); + await model.LoginCommand.ExecuteAsync(null); + Assert.True(model.IsLoggedIn); + Assert.False(model.IsAuthenticationRequired); + await model.LogoutAsync(); + Assert.True(model.IsAuthenticationRequired); + Assert.Null(store.Load()); + } + finally + { + Platform.CreateBrowser = previousBrowser; + File.Delete(path); + } + }, TestContext.Current.CancellationToken); + + [Theory] + [InlineData(320, 480)] + [InlineData(640, 240)] + public Task Modal_blocks_navigation_and_scrolls_on_small_screens_without_a_status_bar(int width, int height) + { + var session = new SessionStatusViewModel(); + session.SetError("Session expirée"); + var model = new HomePageViewModel(null!, new Settings(), session, null!); + return ui.WithWindowAsync(() => new MainView { DataContext = model }, async window => + { + var root = Assert.IsType(window.Content); + Assert.True(root.AuthenticationModal.IsVisible); + Assert.False(root.NavRoot.IsEnabled); + Assert.True(root.LoginButton.IsFocused); + Assert.Equal(KeyboardNavigationMode.Cycle, KeyboardNavigation.GetTabNavigation(root.AuthenticationModal)); + var buttons = new[] { root.LoginButton, root.RegisterButton, root.ForgotPasswordButton }; + foreach (var button in buttons) + { + Assert.True(button.IsEffectivelyEnabled); + button.BringIntoView(); + Dispatcher.UIThread.RunJobs(); + window.UpdateLayout(); + var top = button.TranslatePoint(new Point(), root)!.Value.Y; + Assert.InRange(top, 0, root.Bounds.Height - button.Bounds.Height); + Assert.InRange(button.Bounds.Width, 1, width - 24); + } + Assert.DoesNotContain(root.GetVisualDescendants(), + control => control.GetType().Name == "SessionStatusBanner"); + Assert.Equal(root.Bounds.Height, root.NavRoot.Bounds.Height); + await Task.CompletedTask; + }, TestContext.Current.CancellationToken, width, height); + } + + [Theory] + [InlineData("https://oidc.example", "https://oidc.example/Account/")] + [InlineData("https://oidc.example/tenant/", "https://oidc.example/tenant/Account/")] + public async Task Account_actions_target_the_configured_authority(string authority, string expectedBase) + { + var path = Path.Combine(Path.GetTempPath(), $"postit-session-{Guid.NewGuid():N}.json"); + await using var api = new ProfileApi(new Settings + { + Authentication = new AuthenticationSettings { Authority = authority } + }, new TokenStore(path)); + var model = new SessionStatusViewModel { Api = api }; + Assert.Equal(expectedBase + "Register", model.RegistrationUri.AbsoluteUri); + Assert.Equal(expectedBase + "ForgotPassword", model.ForgotPasswordUri.AbsoluteUri); + api.Settings.Authentication.Authority = "https://new.example"; + Assert.Equal("https://new.example/Account/ForgotPassword", model.ForgotPasswordUri.AbsoluteUri); + } + + private static Settings SettingsFor(OIDCStubAuthority authority) => new() + { + Authentication = new AuthenticationSettings + { + Authority = authority.Issuer, + ClientId = "postit-tests", + RedirectUri = authority.LoopbackRedirectUri, + Scopes = ["openid", "profile", "blog"] + } + }; + + private sealed class ProfileApi(Settings settings, TokenStore store) : YavscApiClient(settings, store) + { + public override Task CallAsync(HttpMethod method, string path, object? body = null, + CancellationToken ct = default) + => Task.FromResult(JsonSerializer.Deserialize("""{"Roles":["Administrator"]}""")!); + } +} diff --git a/src/PostIt/PostIt.Tests/YavscApiClientTests.cs b/src/PostIt/PostIt.Tests/YavscApiClientTests.cs index bc8a4e7b4..2fba36b43 100644 --- a/src/PostIt/PostIt.Tests/YavscApiClientTests.cs +++ b/src/PostIt/PostIt.Tests/YavscApiClientTests.cs @@ -19,6 +19,30 @@ namespace PostIt.Tests; [Trait("Category", "non-reg")] public class YavscApiClientTests { + [Theory] + [InlineData(false)] + [InlineData(true)] + public async Task Rejected_authenticated_retry_requires_login_but_anonymous_401_does_not(bool anonymous) + { + using var authority = await OIDCStubAuthority.StartAsync(); + using var apiServer = new StubApiServer { AlwaysUnauthorized = true }; + await apiServer.StartAsync(); + var path = TokensPath(); + try + { + await using var client = await LoginAndPersistAsync(BuildSettings(authority, apiServer.BaseUrl), authority, path); + var changes = new List(); + client.SessionChanged += changes.Add; + await Assert.ThrowsAsync(() => anonymous + ? client.GetAnonymousAsync>(apiServer.BaseUrl, TestContext.Current.CancellationToken) + : client.CallAsync>(HttpMethod.Get, apiServer.BaseUrl, TestContext.Current.CancellationToken)); + Assert.Equal(anonymous ? 0 : 1, authority.RefreshRequestCount); + if (anonymous) Assert.Empty(changes); + else Assert.Contains("Veuillez vous reconnecter", changes.Last()); + } + finally { File.Delete(path); } + } + [Theory] [InlineData(600, true, false, 540)] [InlineData(3600, false, true, 3540)] @@ -792,6 +816,7 @@ internal sealed class StubApiServer : IAsyncDisposable, IDisposable public List SeenBearers { get; } = new(); public int RequestCount => _requestCount; public string? RejectedBearer { get; set; } + public bool AlwaysUnauthorized { get; set; } public StubApiServer(bool forceFirstRequest = false) { @@ -824,7 +849,7 @@ internal sealed class StubApiServer : IAsyncDisposable, IDisposable if (!string.IsNullOrEmpty(auth)) SeenBearers.Add(auth!); - if ((_forceFirstRequest && _requestCount == 1) + if (AlwaysUnauthorized || (_forceFirstRequest && _requestCount == 1) || (RejectedBearer is not null && auth == RejectedBearer)) { ctx.Response.StatusCode = 401; diff --git a/src/PostIt/PostIt/App.axaml.cs b/src/PostIt/PostIt/App.axaml.cs index d3ff07aad..1e970c2ba 100644 --- a/src/PostIt/PostIt/App.axaml.cs +++ b/src/PostIt/PostIt/App.axaml.cs @@ -270,7 +270,6 @@ public partial class App : Application, ILiveView, IVMPusherApp if (rootView.DataContext==null) rootView.DataContext = ServiceProvider!.GetRequiredService(); - rootView.SessionBanner.DataContext = sessionStatus; this.View = rootView; } @@ -296,21 +295,17 @@ public partial class App : Application, ILiveView, IVMPusherApp private Task BootOnceAsync() { - var api = ServiceProvider!.GetRequiredService(); - return _bootTask ??= BootAsync(ServiceProvider!, api); + return _bootTask ??= BootAsync(ServiceProvider!); } /// /// Refresh cached OIDC tokens once per application process. /// Each root view initializes or restores its own navigation stack separately. /// - private static async Task BootAsync( - IServiceProvider provider, - YavscApiClient api) + private static async Task BootAsync(IServiceProvider provider) { - await api.TrySilentLoginAsync().ConfigureAwait(true); var sessionStatus = provider.GetRequiredService(); - await sessionStatus.RefreshAsync(); + await sessionStatus.InitializeAsync(); await provider.GetRequiredService().StartAsync(connectOnLogin: OperatingSystem.IsAndroid()); } diff --git a/src/PostIt/PostIt/Helpers/ServiceCollectionHelpers.cs b/src/PostIt/PostIt/Helpers/ServiceCollectionHelpers.cs index a139971f6..0a4855b1d 100644 --- a/src/PostIt/PostIt/Helpers/ServiceCollectionHelpers.cs +++ b/src/PostIt/PostIt/Helpers/ServiceCollectionHelpers.cs @@ -144,12 +144,10 @@ public static class ServiceCollectionHelpers services.AddTransient(); services.AddTransient(); services.AddTransient(); - // Persistent session banner: one instance for the lifetime of - // the app so the same VM survives page navigation. + // Authentication state survives page navigation and Android activity recreation. var sessionStatus = new SessionStatusViewModel { Api = api }; sessionStatus.Refresh(); services.AddSingleton(sessionStatus); - services.AddSingleton(); services.AddSingleton(); return services.BuildServiceProvider(); } diff --git a/src/PostIt/PostIt/Services/YavscApiClient.cs b/src/PostIt/PostIt/Services/YavscApiClient.cs index 7cd1ee210..0917f46a2 100644 --- a/src/PostIt/PostIt/Services/YavscApiClient.cs +++ b/src/PostIt/PostIt/Services/YavscApiClient.cs @@ -28,6 +28,8 @@ namespace PostIt.Services; public class YavscApiClient : IYavscApiClient, IAsyncDisposable { public event Func? SigningOut; + /// A null error announces renewal or logout; failures require authentication UI. + public event Action? SessionChanged; private int _signingOut; public bool IsSigningOut => Volatile.Read(ref _signingOut) != 0; // 60s of slack before the access_token's nominal expiry. Covers @@ -138,16 +140,19 @@ public class YavscApiClient : IYavscApiClient, IAsyncDisposable { var tokens = _tokens; if ((!applicationActive && !Settings.AndroidKeepChatConnected) - || IsSigningOut || string.IsNullOrEmpty(tokens?.RefreshToken)) + || IsSigningOut || tokens is null) return Timeout.InfiniteTimeSpan; - var delay = tokens.AccessTokenExpiresAt - RefreshSkew - now; + var delay = tokens.AccessTokenExpiresAt + - (string.IsNullOrEmpty(tokens.RefreshToken) ? TimeSpan.Zero : RefreshSkew) - now; return delay > TimeSpan.Zero ? delay : TimeSpan.Zero; } internal async Task RefreshSessionIfNeededAsync(bool applicationActive, CancellationToken ct) { if ((!applicationActive && !Settings.AndroidKeepChatConnected) - || IsSigningOut || string.IsNullOrEmpty(_tokens?.RefreshToken)) return; + || IsSigningOut || _tokens is null) return; + if (string.IsNullOrEmpty(_tokens.RefreshToken) + && _tokens.AccessTokenExpiresAt > DateTimeOffset.UtcNow) return; await ForceRefreshAsync(ct).ConfigureAwait(false); } @@ -174,6 +179,7 @@ public class YavscApiClient : IYavscApiClient, IAsyncDisposable catch (Exception ex) { Console.Error.WriteLine($"Session maintenance failed: {ex}"); + SessionChanged?.Invoke($"Renouvellement automatique de la session impossible : {ex.Message}"); Settings.SetActionStatus($"Renouvellement automatique de la session impossible : {ex.Message}", PostIt.Models.StatusSeverity.Error); await _maintenanceChanged.WaitAsync(TimeSpan.FromSeconds(30), ct).ConfigureAwait(false); @@ -230,14 +236,18 @@ public class YavscApiClient : IYavscApiClient, IAsyncDisposable "Missing refresh_token — vérifie le scope 'offline_access'."); } - _tokens = new RefreshTokenRecord( - AccessToken: result.AccessToken, - RefreshToken: result.RefreshToken, - AccessTokenExpiresAt: ComputeExpiry(result.AccessTokenExpiration, result.AccessToken), - IdToken: result.IdentityToken); - - _store.Save(_tokens); - WakeSessionMaintenance(); + await _refreshGate.WaitAsync(ct).ConfigureAwait(false); + try + { + _tokens = new RefreshTokenRecord( + AccessToken: result.AccessToken, + RefreshToken: result.RefreshToken, + AccessTokenExpiresAt: ComputeExpiry(result.AccessTokenExpiration, result.AccessToken), + IdToken: result.IdentityToken); + _store.Save(_tokens); + WakeSessionMaintenance(); + } + finally { _refreshGate.Release(); } progress?.Report(OIDCLoginPhase.Success); } @@ -264,11 +274,7 @@ public class YavscApiClient : IYavscApiClient, IAsyncDisposable return true; } - // Access token expired but we have a refresh token: try the - // silent refresh once. If the OP rejects (revoked, rotation - // theft, network down), the refresh path already purges the - // store and throws RefreshFailedException; we catch and route - // the user back to the login page. + // Only a permanent rejection clears the store; transient failures retain it for retry. try { progress?.Report(OIDCLoginPhase.ExchangingCode); @@ -276,13 +282,19 @@ public class YavscApiClient : IYavscApiClient, IAsyncDisposable progress?.Report(OIDCLoginPhase.Success); return true; } - catch (RefreshFailedException) + catch (RefreshFailedException ex) { + Console.Error.WriteLine($"Silent login failed: {ex}"); progress?.Report(OIDCLoginPhase.Idle); return false; } - catch + catch (OperationCanceledException) when (ct.IsCancellationRequested) { + throw; + } + catch (Exception ex) + { + Console.Error.WriteLine($"Silent login failed: {ex}"); progress?.Report(OIDCLoginPhase.Idle); return false; } @@ -433,7 +445,7 @@ public class YavscApiClient : IYavscApiClient, IAsyncDisposable /// here is enough to make the next "click Save" self-explanatory /// (e.g. "Error: 400 — The Title field is required."). /// - private static async Task EnsureSuccessOrThrowAsync(HttpResponseMessage response, CancellationToken ct) + private async Task EnsureSuccessOrThrowAsync(HttpResponseMessage response, CancellationToken ct) { if (response.IsSuccessStatusCode) return; @@ -458,6 +470,9 @@ public class YavscApiClient : IYavscApiClient, IAsyncDisposable var msg = body.Length > 0 ? $"{(int)response.StatusCode} {response.ReasonPhrase}: {body}" : $"{(int)response.StatusCode} {response.ReasonPhrase}"; + if (response.StatusCode == HttpStatusCode.Unauthorized + && !(response.RequestMessage?.Options.TryGetValue(AnonymousRequest, out var anonymous) == true && anonymous)) + SessionChanged?.Invoke("Le serveur a refusé la session. Veuillez vous reconnecter."); throw new HttpRequestException(msg, inner: null, statusCode: response.StatusCode); } @@ -484,8 +499,15 @@ public class YavscApiClient : IYavscApiClient, IAsyncDisposable if (IsSigningOut) throw new InvalidOperationException("Deconnexion en cours."); var tokens = _tokens; - if (tokens is null || string.IsNullOrEmpty(tokens.RefreshToken)) + if (tokens is null) throw new InvalidOperationException("Session expirée. Veuillez vous reconnecter."); + if (string.IsNullOrEmpty(tokens.RefreshToken)) + { + _store.Clear(); + _tokens = null; + WakeSessionMaintenance(); + throw new RefreshFailedException("Session expirée. Veuillez vous reconnecter.", isPermanent: true); + } if (rejectedAccessToken is null ? tokens.AccessTokenExpiresAt - DateTimeOffset.UtcNow > RefreshSkew @@ -517,6 +539,17 @@ public class YavscApiClient : IYavscApiClient, IAsyncDisposable _store.Save(_tokens); WakeSessionMaintenance(); + SessionChanged?.Invoke(null); + } + catch (OperationCanceledException) when (ct.IsCancellationRequested) + { + throw; + } + catch (Exception ex) + { + if (!IsSigningOut) + SessionChanged?.Invoke(ex.Message); + throw; } finally { @@ -671,6 +704,7 @@ public class YavscApiClient : IYavscApiClient, IAsyncDisposable _refreshGate.Release(); Interlocked.Exchange(ref _signingOut, 0); WakeSessionMaintenance(); + SessionChanged?.Invoke(null); } } // Optional: clear the IdP session in the browser too. diff --git a/src/PostIt/PostIt/ViewModels/Layout/SessionStatusViewModel.cs b/src/PostIt/PostIt/ViewModels/Layout/SessionStatusViewModel.cs index dedf210f2..7c32b88a0 100644 --- a/src/PostIt/PostIt/ViewModels/Layout/SessionStatusViewModel.cs +++ b/src/PostIt/PostIt/ViewModels/Layout/SessionStatusViewModel.cs @@ -2,6 +2,8 @@ using System; using System.Linq; using System.Net.Http; using System.Threading.Tasks; +using Avalonia.Controls; +using Avalonia.Threading; using CommunityToolkit.Mvvm.ComponentModel; using CommunityToolkit.Mvvm.Input; using Microsoft.Extensions.DependencyInjection; @@ -11,19 +13,7 @@ using PostIt.Services; namespace PostIt.ViewModels; /// -/// Persistent session banner VM, hosted in -/// MainWindow.axaml. Mirrors 's -/// session state ("Connecté" / "Déconnecté") and exposes a -/// Logout command that purges the token store and asks the -/// navigation owner to route the user back to HomePage, plus -/// a Login command that drives the OIDC interactive flow -/// and raises a event on success so -/// MainWindow can push MainPage on top of -/// HomePage. -/// -/// Construction is deferred until the API client exists; the -/// App.axaml.cs wiring sets after building both, -/// so the banner reflects reality from frame zero. +/// Shared authentication state and commands for the modal and home menu. /// public partial class SessionStatusViewModel : ViewModelBase { @@ -31,9 +21,7 @@ public partial class SessionStatusViewModel : ViewModelBase /// App.axaml.cs listens and swaps the navigation root. public event System.Action? LogoutCompleted; - /// Raised after acquired a valid session; - /// App.axaml.cs listens and pushes MainPage on top of - /// HomePage so the user lands on the blog editor. + /// Raised after an interactive login acquired a valid session. public event System.Action? LoginSucceeded; [ObservableProperty] @@ -44,27 +32,62 @@ public partial class SessionStatusViewModel : ViewModelBase private int _accessVersion; - /// Inverse of , for XAML bindings - /// (the banner shows the Login button when the user is logged out). - /// Updated from . [ObservableProperty] public partial bool IsLoggedOut { get; private set; } = true; + [ObservableProperty] + public partial bool IsAuthenticationRequired { get; private set; } + [ObservableProperty] public partial string SessionLabel { get; private set; } = "Déconnecté"; - /// True while a Login flow is in flight; the Login button - /// binds IsEnabled to !IsBusy via - /// 's CanExecute. + [ObservableProperty] + public partial string? ProfileError { get; private set; } + [ObservableProperty] public partial bool IsBusy { get; private set; } - /// The API client backing the banner. Set once at startup; - /// the banner polls HasValidSession on demand rather than - /// subscribing to a stream — the session state only changes at - /// login, logout, and silent refresh, all of which already - /// re-evaluate from the same _tokens snapshot. - public YavscApiClient? Api { get; set; } + private YavscApiClient? _api; + public YavscApiClient? Api + { + get => _api; + set + { + if (_api is not null) _api.SessionChanged -= OnSessionChanged; + _api = value; + if (_api is not null) _api.SessionChanged += OnSessionChanged; + } + } + + public Uri RegistrationUri => AccountUri("Register"); + public Uri ForgotPasswordUri => AccountUri("ForgotPassword"); + + private Uri AccountUri(string action) => new( + new Uri((Api?.Settings.Authentication.Authority ?? AuthenticationSettings.DefaultAuthority).TrimEnd('/') + "/"), + "Account/" + action); + + private void OnSessionChanged(string? error) + { + void Update() + { + if (error is not null) + SetError(error); + else if (!IsLoggedIn || Api?.HasValidSession != true) + _ = RefreshAsync(); + } + if (Dispatcher.UIThread.CheckAccess()) Update(); + else Dispatcher.UIThread.Post(Update); + } + + public async Task InitializeAsync() + { + if (Api is null) + throw new InvalidOperationException("Client d'authentification indisponible."); + if (await Api.TrySilentLoginAsync()) + await RefreshAsync(); + else + await LoginAsync(); + } public override bool CanNavigateNext { @@ -85,6 +108,8 @@ public partial class SessionStatusViewModel : ViewModelBase var has = Api?.HasValidSession ?? false; IsLoggedIn = has; IsLoggedOut = !has; + IsAuthenticationRequired = !has; + ProfileError = null; SessionLabel = has ? "Connecté" : "Déconnecté"; } @@ -108,44 +133,40 @@ public partial class SessionStatusViewModel : ViewModelBase catch (Exception ex) { if (version == _accessVersion) + { SessionLabel = $"Impossible de vérifier les droits : {ex.Message}"; + ProfileError = SessionLabel; + } } } - /// - /// Override the banner label with an error message. Used when - /// an interactive login attempt fails so the operator sees - /// something on the persistent UI without us needing a - /// dedicated error page. The next call - /// reverts to "Connecté" / "Déconnecté". - /// public void SetError(string message) { ++_accessVersion; IsAdministrator = false; IsLoggedIn = false; IsLoggedOut = true; + IsAuthenticationRequired = true; + ProfileError = null; SessionLabel = message; } - /// - /// Drive the OIDC interactive login. On success, refreshes - /// the banner state and raises so - /// the navigation owner can push MainPage. On failure, - /// surfaces the error in the banner via . - /// [RelayCommand(CanExecute = nameof(CanLogin))] public async Task LoginAsync() { - if (Api is null) return; + if (IsBusy) return; + var api = Api; IsBusy = true; + SessionLabel = "Connexion en cours dans le navigateur…"; try { - await Api.LoginInteractiveAsync().ConfigureAwait(true); + if (api is null) + throw new InvalidOperationException("Client d'authentification indisponible."); + await api.LoginInteractiveAsync().ConfigureAwait(true); } catch (Exception ex) { - SetError($"Login failed: {ex.Message}"); + SetError($"Connexion impossible : {ex.Message}"); return; } finally @@ -154,13 +175,41 @@ public partial class SessionStatusViewModel : ViewModelBase } await RefreshAsync(); - if (Api.HasValidSession) + if (IsLoggedIn) LoginSucceeded?.Invoke(); } private bool CanLogin() => !IsBusy; - partial void OnIsBusyChanged(bool value) => LoginCommand.NotifyCanExecuteChanged(); + partial void OnIsBusyChanged(bool value) + { + LoginCommand.NotifyCanExecuteChanged(); + RegisterCommand.NotifyCanExecuteChanged(); + ForgotPasswordCommand.NotifyCanExecuteChanged(); + } + + [RelayCommand(CanExecute = nameof(CanLogin))] + private Task Register() => OpenAccountPageAsync("Register"); + + [RelayCommand(CanExecute = nameof(CanLogin))] + private Task ForgotPassword() => OpenAccountPageAsync("ForgotPassword"); + + private async Task OpenAccountPageAsync(string action) + { + try + { + var uri = AccountUri(action); + var view = (App.Current as App)?.View; + var topLevel = view is null ? null : TopLevel.GetTopLevel(view); + if (topLevel is null || !await topLevel.Launcher.LaunchUriAsync(uri)) + throw new InvalidOperationException("Impossible d'ouvrir le navigateur."); + SessionLabel = "Terminez l'opération dans le navigateur, puis choisissez Se connecter."; + } + catch (Exception ex) + { + SetError(ex.Message); + } + } [RelayCommand] public async System.Threading.Tasks.Task LogoutAsync() diff --git a/src/PostIt/PostIt/Views/Layout/HomePage.axaml b/src/PostIt/PostIt/Views/Layout/HomePage.axaml index ad74eb802..1370b78fb 100644 --- a/src/PostIt/PostIt/Views/Layout/HomePage.axaml +++ b/src/PostIt/PostIt/Views/Layout/HomePage.axaml @@ -26,6 +26,15 @@ Label="Podcasts : directs et replays" /> + + + + + @@ -13,11 +12,38 @@ - - + - + + + + + + + + +