Merge remote-tracking branch 'origin/develop' into offline-login-error-handling

Author: myieye

.gitignore

@@ -31,7 +31,7 @@ localResourcesCache/
 backend/FwLite/FwLiteShared/wwwroot/viewer
 
 *.csproj.user
-backend/Directory.Build.props.user
+*.props.user
 *.log
 failedSyncs/
 

.vscode/tasks.json

@@ -61,5 +61,39 @@
             ],
             "problemMatcher": "$msCompile"
         },
+        {
+            "label": "FW Lite Web",
+            "dependsOn": [
+                "Fw Lite aspnet server",
+                "Fw Lite vite"
+            ],
+            "group": "build"
+        },
+        {
+            "label": "Fw Lite aspnet server",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "--project",
+                "${workspaceFolder}/backend/FwLite/FwLiteWeb/FwLiteWeb.csproj",
+                "--no-hot-reload",
+                "--",
+                "--FwLiteWeb:OpenBrowser=false"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "Fw Lite vite",
+            "command": "npm",
+            "type": "process",
+            "args": [
+                "run",
+                "dev"
+            ],
+            "options": {
+                "cwd": "${workspaceFolder}/frontend/viewer"
+            },
+        }
     ]
 }

backend/.editorconfig

@@ -96,7 +96,7 @@ csharp_style_deconstructed_variable_declaration = true:suggestion
 csharp_prefer_simple_default_expression = true:suggestion
 csharp_style_prefer_local_over_anonymous_function = true:suggestion
 csharp_style_inlined_variable_declaration = true:suggestion
-# Remove unnecessary using directives 
+# Remove unnecessary using directives
 dotnet_diagnostic.IDE0005.severity = warning
 ###############################
 # C# Formatting Rules         #
@@ -134,6 +134,11 @@ dotnet_diagnostic.VSTHRD200.severity = none
 # "Expression value is never used"
 dotnet_diagnostic.IDE0058.severity = suggestion
 
+# IDE0061: Use block body for local function
+dotnet_diagnostic.IDE0061.severity = silent
+# IDE0022: Use block body for method
+dotnet_diagnostic.IDE0022.severity = silent
+
 [{*Kernel}.cs]
 dotnet_diagnostic.IDE0058.severity = none
 
@@ -146,4 +151,4 @@ indent_size = unset
 indent_style = unset
 insert_final_newline = false
 tab_width = unset
-trim_trailing_whitespace = false
+trim_trailing_whitespace = false

backend/FwLite/FwDataMiniLcmBridge/Api/FwDataMiniLcmApi.cs

@@ -1088,12 +1088,15 @@ private ICmObject FindSenseOrEntryComponent(ComplexFormComponent component)
 
     public Task DeleteComplexFormComponent(ComplexFormComponent complexFormComponent)
     {
+        //complex form entry has been deleted, so this component relationship is gone already
+        if (!EntriesRepository.TryGetObject(complexFormComponent.ComplexFormEntryId, out var lexEntry))
+            return Task.CompletedTask;
+
         UndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW("Delete Complex Form Component",
             "Add Complex Form Component",
             Cache.ServiceLocator.ActionHandler,
             () =>
             {
-                var lexEntry = EntriesRepository.GetObject(complexFormComponent.ComplexFormEntryId);
                 RemoveComplexFormComponent(lexEntry, complexFormComponent);
             });
         return Task.CompletedTask;

backend/FwLite/FwLiteMaui.Tests/ConnectivitySyncTriggerTests.cs

@@ -0,0 +1,18 @@
+using FwLiteMaui.Services;
+
+namespace FwLiteMaui.Tests;
+
+public class ConnectivitySyncTriggerTests
+{
+    [Theory]
+    [InlineData(NetworkAccess.None, NetworkAccess.Internet, true)]
+    [InlineData(NetworkAccess.Unknown, NetworkAccess.Internet, true)]
+    [InlineData(NetworkAccess.ConstrainedInternet, NetworkAccess.Internet, true)]
+    [InlineData(NetworkAccess.Internet, NetworkAccess.Internet, false)] // already online — don't re-run
+    [InlineData(NetworkAccess.Internet, NetworkAccess.None, false)]     // going offline
+    [InlineData(NetworkAccess.None, NetworkAccess.Local, false)]        // local network only, no internet
+    public void ShouldRecover_OnlyOnTransitionIntoInternet(NetworkAccess previous, NetworkAccess current, bool expected)
+    {
+        ConnectivitySyncTrigger.ShouldRecover(previous, current).Should().Be(expected);
+    }
+}

backend/FwLite/FwLiteMaui/App.xaml.cs

@@ -1,3 +1,6 @@
+using FwLiteShared.Projects;
+using FwLiteShared.Services;
+using Microsoft.Extensions.Logging;
 
 namespace FwLiteMaui;
 
@@ -6,11 +9,20 @@ public partial class App : Application
     public IServiceProvider ServiceProvider { get; }
     private readonly MainPage _mainPage;
     public static string? OverrideStartupUrl { get; set; }
+    private readonly LexboxProjectChangeListener _lexboxProjectChangeListener;
+    private readonly ILogger<App> _logger;
 
-    public App(MainPage mainPage, IServiceProvider serviceProvider)
+    public App(MainPage mainPage, IPreferencesService preferences, LexboxProjectChangeListener lexboxProjectChangeListener, ILogger<App> logger, IServiceProvider serviceProvider)
     {
         ServiceProvider = serviceProvider;
         _mainPage = mainPage;
+        _lexboxProjectChangeListener = lexboxProjectChangeListener;
+        _logger = logger;
+        var lastUrl = preferences.Get(nameof(PreferenceKey.AppLastUrl));
+        if (lastUrl?.StartsWith('/') == true)
+        {
+            mainPage.StartPath = lastUrl;
+        }
         InitializeComponent();
     }
 
@@ -21,7 +33,25 @@ internal void LoadAppUrl(string url)
 
     protected override Window CreateWindow(IActivationState? activationState)
     {
-        return CreateWindow(_mainPage);
+        var window = CreateWindow(_mainPage);
+        // An OS-frozen app (e.g. Android Doze/Standby) can come back with its push listener down and no connectivity
+        // transition to recover on; resume is when the user is watching, so recover immediately instead of
+        // waiting for the periodic backstop.
+        window.Resumed += (_, _) => _ = EnsureListenersAfterResume();
+        return window;
+    }
+
+    private async Task EnsureListenersAfterResume()
+    {
+        try
+        {
+            _logger.LogInformation("App resumed; ensuring push listeners");
+            await _lexboxProjectChangeListener.EnsureListenersForTrackedProjects(kickReconnecting: true);
+        }
+        catch (Exception e)
+        {
+            _logger.LogWarning(e, "Failed to ensure push listeners after app resume");
+        }
     }
 
     public static Window CreateWindow(MainPage mainPage, int? width = null)

backend/FwLite/FwLiteMaui/FwLiteMauiKernel.cs

@@ -132,6 +132,8 @@ public static void AddFwLiteMauiServices(this IServiceCollection services,
         services.AddSingleton(_ => Preferences.Default);
         services.AddSingleton(_ => VersionTracking.Default);
         services.AddSingleton(_ => Connectivity.Current);
+        services.AddSingleton<IHostedService, ConnectivitySyncTrigger>();
+        services.AddSingleton<INetworkStatus, ConnectivityNetworkStatus>();
         services.AddSingleton(_ => Launcher.Default);
         services.AddSingleton(_ => Browser.Default);
         services.AddSingleton(_ => Share.Default);

backend/FwLite/FwLiteMaui/Services/ConnectivityNetworkStatus.cs

@@ -0,0 +1,9 @@
+using FwLiteShared.Services;
+
+namespace FwLiteMaui.Services;
+
+public class ConnectivityNetworkStatus(IConnectivity connectivity) : INetworkStatus
+{
+    // ConstrainedInternet (e.g. captive portal) counts as offline, matching ConnectivitySyncTrigger.
+    public bool IsOnline => connectivity.NetworkAccess == NetworkAccess.Internet;
+}

backend/FwLite/FwLiteMaui/Services/ConnectivitySyncTrigger.cs

@@ -0,0 +1,62 @@
+using FwLiteShared.Projects;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace FwLiteMaui.Services;
+
+// Primary use case: app started offline should start syncing if the device comes online
+public sealed class ConnectivitySyncTrigger(
+    IConnectivity connectivity,
+    LexboxProjectChangeListener lexboxProjectChangeListener,
+    ILogger<ConnectivitySyncTrigger> logger) : IHostedService
+{
+    private NetworkAccess _lastAccess;
+
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        _lastAccess = connectivity.NetworkAccess;
+        connectivity.ConnectivityChanged += OnConnectivityChanged;
+        logger.LogInformation("Watching device connectivity to re-establish push listeners (current access: {NetworkAccess})", _lastAccess);
+        return Task.CompletedTask;
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        connectivity.ConnectivityChanged -= OnConnectivityChanged;
+        return Task.CompletedTask;
+    }
+
+    private void OnConnectivityChanged(object? sender, ConnectivityChangedEventArgs e)
+    {
+        var previous = _lastAccess;
+        var current = _lastAccess = e.NetworkAccess;
+
+        logger.LogInformation("Device connectivity changed: {Previous} -> {Current} (profiles: {Profiles})",
+            previous, current, string.Join(", ", e.ConnectionProfiles));
+
+        if (!ShouldRecover(previous, current)) return;
+
+        logger.LogInformation("Connectivity regained (internet access); ensuring push listeners");
+        _ = EnsureListeners();
+    }
+
+    private async Task EnsureListeners(CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await lexboxProjectChangeListener.EnsureListenersForTrackedProjects(kickReconnecting: true, cancellationToken);
+        }
+        catch (Exception e)
+        {
+            logger.LogWarning(e, "Failed to ensure push listeners after connectivity change");
+        }
+    }
+
+    // Only react to a transition INTO internet access, so recovery doesn't re-run on every connectivity
+    // change (e.g. wifi<->cellular) while already online. Idempotent recovery makes a missed edge harmless;
+    // this just keeps the common flapping case quiet.
+    public static bool ShouldRecover(NetworkAccess previous, NetworkAccess current)
+    {
+        return current == NetworkAccess.Internet && previous != NetworkAccess.Internet;
+    }
+}

backend/FwLite/FwLiteProjectSync.Tests/EntrySyncTests.cs

@@ -168,6 +168,27 @@ public async Task FwDataApiDoesNotUpdateMorphType()
         actual.Should().NotBeNull();
         actual.MorphType.Should().Be(MorphTypeKind.BoundStem);
     }
+
+    [Fact]
+    public async Task SyncFull_RemovingComplexFormWhoseParentWasDeleted_DoesNotThrow()
+    {
+        var component = await Api.CreateEntry(new() { Id = Guid.NewGuid(), LexemeForm = { { "en", "component" } } });
+        var complexForm = new Entry { Id = Guid.NewGuid(), LexemeForm = { { "en", "complexForm" } } };
+        complexForm.Components = [ComplexFormComponent.FromEntries(complexForm, component)];
+        await Api.CreateEntry(complexForm);
+
+        var before = await Api.GetEntry(component.Id);
+        before!.ComplexForms.Should().ContainSingle();
+
+        // Deleting the parent already drops the relationship; the sync then redundantly removes it from the surviving component, which used to throw because the parent was gone.
+        await Api.DeleteEntry(complexForm.Id);
+        var after = before.Copy();
+        after.ComplexForms.Clear();
+
+        await EntrySync.SyncFull(before, after, Api);
+
+        (await Api.GetEntry(component.Id)).Should().NotBeNull();
+    }
 }
 
 public abstract class EntrySyncTestsBase(ExtraWritingSystemsSyncFixture fixture) : IClassFixture<ExtraWritingSystemsSyncFixture>, IAsyncLifetime