K2GO-430 fix(dependency): gate retries and proceed on suggestion dismiss

ModuleRetry.fire now checks DashNodeGate.allowInstall, since a retry starts the index directly and bypassed the batch gate. Dismissing the soft suggestion now proceeds with the install instead of swallowing it. Add a DashboardVersion.atLeast unit test.

Author: luisguzman-adfa

controller/app/src/main/java/org/appdevforall/k2go/dependency/presentation/DashNodeGate.java

@@ -3,19 +3,20 @@
  * Name        : DashNodeGate.java
  * Author      : AppDevForAll
  * Copyright   : Copyright (c) 2026 AppDevForAll
- * Description : K2GO-430. Gate a module install batch on the box dash-node version. Two mechanisms:
+ * Description : K2GO-430. Gate a module install on the box dash-node version. Two mechanisms:
  *               HARD block : a module that declares a minimum (DashNodeRequirement, e.g. Forgejo -> 1.3.7)
  *               cannot install on a box below it; show a dialog and route to the dashboard update.
- *               SOFT suggest : for any install, when a dashboard update is available, recommend updating
- *               first (Update / Install anyway). Reuses the existing version read (DashboardVersion, from
- *               the rootfs, no network/proot) and the cached update-check (UpdateStatusCache), so the gate
- *               is synchronous.
+ *               SOFT suggest : for a batch, when a dashboard update is available, recommend updating first
+ *               (Update / Install anyway). Reuses the existing version read (DashboardVersion, from the
+ *               rootfs, no network/proot) and the cached update-check (UpdateStatusCache), so the gate is
+ *               synchronous.
  * ============================================================================
  */
 package org.appdevforall.k2go.dependency.presentation;
 
 import android.app.Activity;
 import android.content.Context;
+import android.content.Intent;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -30,7 +31,9 @@
 public final class DashNodeGate {
     private DashNodeGate() {}
 
-    /** True when the box dash-node is below {@code moduleKey}'s hard minimum (null key / no minimum = false). */
+    /** True when the box dash-node is below {@code moduleKey}'s hard minimum (null key / no minimum = false).
+     *  A null (unreadable) installed version blocks a module that HAS a minimum: do not install it against
+     *  a dashboard we cannot verify. */
     public static boolean installBlocked(@NonNull Context ctx, @Nullable String moduleKey) {
         int[] min = DashNodeRequirement.minFor(moduleKey);
         return min != null && !DashboardVersion.atLeast(DashboardVersion.installed(ctx), min[0], min[1], min[2]);
@@ -56,27 +59,43 @@ public static void guardModuleBatch(@NonNull Activity act, @Nullable String[] ba
         onProceed.run();
     }
 
-    private static void showBlocked(@NonNull Activity act, @NonNull String moduleKey) {
-        new BrandDialog(act)
+    /**
+     * Gate a single-module (re)install, e.g. a retry: returns false (and shows the block dialog) when the
+     * module is below its dash-node minimum, true when it may proceed. Hard block only (a retry does not
+     * carry the soft update suggestion). Covers the install paths that start the index directly, not via
+     * the batch gate.
+     */
+    public static boolean allowInstall(@NonNull Context ctx, @Nullable String moduleKey) {
+        if (installBlocked(ctx, moduleKey)) { showBlocked(ctx, moduleKey); return false; }
+        return true;
+    }
+
+    private static void showBlocked(@NonNull Context ctx, @NonNull String moduleKey) {
+        new BrandDialog(ctx)
                 .setTitle(R.string.k2go_dep_required_title)
-                .setMessage(act.getString(R.string.k2go_dep_required_msg_fmt, DashNodeRequirement.minLabel(moduleKey)))
-                .setPositive(R.string.k2go_dep_update_dashboard, BrandDialog.Role.PRIMARY, () -> openDashboard(act))
+                .setMessage(ctx.getString(R.string.k2go_dep_required_msg_fmt, DashNodeRequirement.minLabel(moduleKey)))
+                .setPositive(R.string.k2go_dep_update_dashboard, BrandDialog.Role.PRIMARY, () -> openDashboard(ctx))
                 .setNegative(android.R.string.cancel, null)
                 .show();
     }
 
-    private static void showSuggest(@NonNull Activity act, @NonNull Runnable onProceed) {
-        new BrandDialog(act)
+    private static void showSuggest(@NonNull Context ctx, @NonNull Runnable onProceed) {
+        new BrandDialog(ctx)
                 .setTitle(R.string.k2go_dep_suggest_title)
                 .setMessage(R.string.k2go_dep_suggest_msg)
-                .setPositive(R.string.k2go_dep_update_dashboard, BrandDialog.Role.PRIMARY, () -> openDashboard(act))
+                .setPositive(R.string.k2go_dep_update_dashboard, BrandDialog.Role.PRIMARY, () -> openDashboard(ctx))
                 .setNegative(R.string.k2go_dep_install_anyway, onProceed::run)
+                // The suggestion is optional: dismissing it (back / tap-outside) proceeds with the install
+                // the user already asked for, rather than silently swallowing it.
+                .setOnCancel(onProceed::run)
                 .show();
     }
 
-    /** Open the dashboard detail (the Rebuild/Update card) so the user can update the dash-node. Reuses
-     *  the canonical navigation intent instead of rebuilding it here. */
-    private static void openDashboard(@NonNull Activity act) {
-        act.startActivity(OpReturnNavigator.dashboardRebuild(act));
+    /** Open the dashboard detail (the Rebuild/Update card) so the user can update the dash-node. Reuses the
+     *  canonical navigation intent instead of rebuilding it here. */
+    private static void openDashboard(@NonNull Context ctx) {
+        Intent i = OpReturnNavigator.dashboardRebuild(ctx);
+        if (!(ctx instanceof Activity)) i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        ctx.startActivity(i);
     }
 }

controller/app/src/main/java/org/appdevforall/k2go/redesign/ModuleRetry.java

@@ -54,6 +54,12 @@ public static boolean fire(View anchor, String moduleKey) {
             Snackbars.make(anchor, BusyMessage.resFor(ctx)).show();
             return false;
         }
+        // K2GO-430: a retry starts the install directly (not via openModuleIndex), so gate the dash-node
+        // dependency here too. If the box dash-node is below the module's minimum, the gate shows the
+        // "update the dashboard first" dialog and the retry does not fire.
+        if (!org.appdevforall.k2go.dependency.presentation.DashNodeGate.allowInstall(ctx, moduleKey)) {
+            return false;
+        }
         InstallService.retryModules(ctx, Collections.singletonList(moduleKey));
         return true;
     }

controller/app/src/test/java/org/appdevforall/k2go/redesign/DashboardVersionTest.java

@@ -0,0 +1,45 @@
+package org.appdevforall.k2go.redesign;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/** K2GO-430: the version compare behind the dash-node dependency gate (installBlocked uses it). Pure,
+ *  so a plain JVM test; installed(Context) reads a file and is not covered here. */
+public class DashboardVersionTest {
+
+    @Test
+    public void nullOrJunkIsBelowAnyMinimum() {
+        assertFalse(DashboardVersion.atLeast(null, 1, 3, 7));
+        assertFalse(DashboardVersion.atLeast("", 1, 3, 7));
+        assertFalse(DashboardVersion.atLeast("not-a-version", 1, 3, 7));
+    }
+
+    @Test
+    public void exactMinimumMeetsIt() {
+        assertTrue(DashboardVersion.atLeast("1.3.7", 1, 3, 7));
+    }
+
+    @Test
+    public void belowMinimumFails() {
+        assertFalse(DashboardVersion.atLeast("1.3.6", 1, 3, 7));
+        assertFalse(DashboardVersion.atLeast("1.2.9", 1, 3, 7));
+        assertFalse(DashboardVersion.atLeast("0.9.9", 1, 3, 7));
+        assertFalse(DashboardVersion.atLeast("1.3", 1, 3, 7));   // missing patch = .0, so 1.3.0 < 1.3.7
+    }
+
+    @Test
+    public void aboveMinimumPasses() {
+        assertTrue(DashboardVersion.atLeast("1.3.8", 1, 3, 7));
+        assertTrue(DashboardVersion.atLeast("1.3.10", 1, 3, 7));   // numeric compare, not lexical
+        assertTrue(DashboardVersion.atLeast("1.4.0", 1, 3, 7));
+        assertTrue(DashboardVersion.atLeast("2.0.0", 1, 3, 7));
+    }
+
+    @Test
+    public void suffixesAreIgnored() {
+        assertTrue(DashboardVersion.atLeast("1.3.7-beta", 1, 3, 7));
+        assertTrue(DashboardVersion.atLeast("1.4.0+build5", 1, 3, 7));
+    }
+}