fix(dashboards): treat re-import of soft-deleted UUID as implicit restore (Option C)

Same shape as the charts and datasets importer fixes. The dashboard
importer on this branch had three bugs from the soft-delete refactor:

1. **Null-user `config["id"]` fallthrough was lost.** The `if overwrite
   and can_write and user:` gate excluded the example-loader case
   (ignore_permissions=True, user=None) from id-preservation, so re-import
   over an existing live row would collide with the UUID unique index.

2. **Hard-delete-and-replace on soft-deleted overwrite.** The code called
   `clear_soft_deleted_for_import` for soft-deleted matches, cascading
   through dashboard_slices junctions and role/owner/tag associations.
   The import then had to reconstruct everything.

3. **Silent return of soft-deleted rows on non-overwrite.** The agent's
   "silent resurrection" concern — direct re-import returned the
   soft-deleted dashboard without restoring it, leaving the row hidden
   in the list.

Adopts the Option-C shape from f4768c4 (charts) and 7b2aa39
(datasets):

- Any mutation path (overwrite OR soft-delete restore) applies the
  overwrite path's ownership check (`can_access_dashboard` + owner-or-
  admin), so non-owners cannot resurrect via re-import.
- Soft-deleted match + can_write: restore in place + UPDATE via
  `config["id"] = existing.id`. Preserves the PK and all relationship
  rows (slices junctions, owners, roles, tags).
- Alive match + non-overwrite: returns existing unchanged (master
  behavior).
- Null user path correctly falls through to the mutation path when
  `needs_mutation` is true, preserving the example-loader semantics.

Four new tests pin the contracts:
- test_import_soft_deleted_dashboard_overwrite_restores_in_place
- test_import_soft_deleted_dashboard_non_overwrite_restores_for_owner
- test_import_soft_deleted_dashboard_non_overwrite_raises_for_non_owner
- test_import_soft_deleted_dashboard_ignore_permissions_restores_in_place

This should clear the dashboard zip-import playwright failure on apache#40128.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Mike Bridge

superset/commands/dashboard/importers/v1/utils.py

@@ -252,33 +252,38 @@ def import_dashboard(  # noqa: C901
         "can_write",
         "Dashboard",
     )
-    from superset.commands.importers.v1.utils import (
-        clear_soft_deleted_for_import,
-        find_existing_for_import,
-    )
+    from superset.commands.importers.v1.utils import find_existing_for_import
 
     user = get_user()
 
     if existing := find_existing_for_import(Dashboard, config["uuid"]):
-        if overwrite and can_write and user:
+        is_soft_deleted = existing.deleted_at is not None
+        # A re-import that matches a soft-deleted UUID is implicitly a
+        # restore-with-overwrite: bringing the dashboard back by
+        # uploading it again. Apply the same ownership check as the
+        # explicit overwrite path so non-owners cannot resurrect via
+        # re-import.
+        needs_mutation = overwrite or is_soft_deleted
+        if needs_mutation and can_write and user:
             if not security_manager.can_access_dashboard(existing) or (
                 user not in existing.owners and not security_manager.is_admin()
             ):
                 raise ImportFailedError(
                     "A dashboard already exists and user doesn't "
                     "have permissions to overwrite it"
                 )
-            # Permission check passed. If the existing row is
-            # soft-deleted, hard-delete it now so the fresh insert
-            # below doesn't collide on the UUID unique constraint.
-            # Destructive op happens *after* the permission check, not
-            # as a side effect of the lookup.
-            if existing.deleted_at is not None:
-                clear_soft_deleted_for_import(existing)
-            else:
-                config["id"] = existing.id
-        elif not overwrite or not can_write:
+        if not needs_mutation or not can_write:
             return existing
+        # Mutation path. Restore a soft-deleted match in place rather
+        # than hard-delete-and-replace: a hard delete cascades through
+        # dashboard_slices junctions and dashboard role / owner / tag
+        # associations, breaking the relationships the import would then
+        # need to reconstruct. Setting config["id"] = existing.id routes
+        # import_from_dict through UPDATE, preserving the PK and the
+        # dependent rows.
+        if is_soft_deleted:
+            existing.deleted_at = None
+        config["id"] = existing.id
     elif not can_write:
         raise ImportFailedError(
             "Dashboard doesn't exist and user doesn't "

tests/unit_tests/dashboards/commands/importers/v1/import_test.py

@@ -18,6 +18,7 @@
 
 import copy
 from collections.abc import Generator
+from datetime import datetime
 from unittest.mock import patch
 
 import pytest
@@ -245,6 +246,152 @@ def test_import_existing_dashboard_with_permission(
     mock_can_access_dashboard.assert_called_once_with(dashboard)
 
 
+def test_import_soft_deleted_dashboard_overwrite_restores_in_place(
+    mocker: MockerFixture,
+    session_with_data: Session,
+) -> None:
+    """
+    Overwrite-importing a soft-deleted dashboard must restore the row in
+    place rather than hard-delete-and-replace. A hard delete cascades
+    through dashboard_slices junctions and role/owner/tag associations;
+    in-place restore preserves them.
+    """
+    mocker.patch.object(security_manager, "can_access", return_value=True)
+    mocker.patch.object(
+        security_manager, "can_access_dashboard", return_value=True
+    )
+
+    existing = (
+        session_with_data.query(Dashboard)
+        .filter(Dashboard.uuid == dashboard_config["uuid"])
+        .one_or_none()
+    )
+    assert existing is not None
+    original_id = existing.id
+    existing.deleted_at = datetime(2026, 1, 1, 12, 0, 0)
+    session_with_data.flush()
+
+    admin = User(
+        first_name="Alice",
+        last_name="Doe",
+        email="adoe@example.org",
+        username="admin",
+        roles=[Role(name="Admin")],
+    )
+
+    with override_user(admin):
+        dashboard = import_dashboard(dashboard_config, overwrite=True)
+
+    assert dashboard.id == original_id
+    assert dashboard.deleted_at is None
+
+
+def test_import_soft_deleted_dashboard_non_overwrite_restores_for_owner(
+    mocker: MockerFixture,
+    session_with_data: Session,
+) -> None:
+    """
+    Non-overwrite re-import of a soft-deleted UUID is implicitly a
+    restore-and-update: the user is bringing the dashboard back by
+    uploading it again. The same ownership rule as the overwrite path
+    applies, so an owner (or admin) succeeds without setting
+    overwrite=True.
+    """
+    mocker.patch.object(security_manager, "can_access", return_value=True)
+    mocker.patch.object(
+        security_manager, "can_access_dashboard", return_value=True
+    )
+
+    existing = (
+        session_with_data.query(Dashboard)
+        .filter(Dashboard.uuid == dashboard_config["uuid"])
+        .one_or_none()
+    )
+    assert existing is not None
+    original_id = existing.id
+    existing.deleted_at = datetime(2026, 1, 1, 12, 0, 0)
+    session_with_data.flush()
+
+    admin = User(
+        first_name="Alice",
+        last_name="Doe",
+        email="adoe@example.org",
+        username="admin",
+        roles=[Role(name="Admin")],
+    )
+
+    with override_user(admin):
+        dashboard = import_dashboard(dashboard_config, overwrite=False)
+
+    assert dashboard.id == original_id
+    assert dashboard.deleted_at is None
+
+
+def test_import_soft_deleted_dashboard_non_overwrite_raises_for_non_owner(
+    mocker: MockerFixture,
+    session_with_data: Session,
+) -> None:
+    """
+    Non-overwrite re-import that would resurrect a soft-deleted dashboard
+    must respect ownership: a non-owner without admin role cannot
+    restore-via-import. Mirrors the explicit /restore endpoint's check.
+    """
+    mocker.patch.object(security_manager, "can_access", return_value=True)
+    mocker.patch.object(
+        security_manager, "can_access_dashboard", return_value=True
+    )
+
+    existing = (
+        session_with_data.query(Dashboard)
+        .filter(Dashboard.uuid == dashboard_config["uuid"])
+        .one_or_none()
+    )
+    assert existing is not None
+    existing.deleted_at = datetime(2026, 1, 1, 12, 0, 0)
+    session_with_data.flush()
+
+    non_owner = User(
+        first_name="Bob",
+        last_name="Roe",
+        email="bob@example.org",
+        username="bob",
+        roles=[Role(name="Gamma")],
+    )
+
+    with override_user(non_owner):
+        with pytest.raises(ImportFailedError) as excinfo:
+            import_dashboard(dashboard_config, overwrite=False)
+    assert "permissions to overwrite" in str(excinfo.value)
+
+
+def test_import_soft_deleted_dashboard_ignore_permissions_restores_in_place(
+    mocker: MockerFixture,
+    session_with_data: Session,
+) -> None:
+    """
+    The example loader path: ignore_permissions=True with no logged-in
+    user. The needs_mutation gate must still trigger the overwrite path
+    so config["id"] is preserved on the fallthrough, otherwise the
+    example loader's re-import collides on the UUID unique index.
+    """
+    existing = (
+        session_with_data.query(Dashboard)
+        .filter(Dashboard.uuid == dashboard_config["uuid"])
+        .one_or_none()
+    )
+    assert existing is not None
+    original_id = existing.id
+    existing.deleted_at = datetime(2026, 1, 1, 12, 0, 0)
+    session_with_data.flush()
+
+    dashboard = import_dashboard(
+        dashboard_config, overwrite=True, ignore_permissions=True
+    )
+
+    assert dashboard.id == original_id
+    assert dashboard.deleted_at is None
+
+
 def test_import_tag_logic_for_dashboards(session_with_schema: Session):
     contents = {
         "tags.yaml": yaml.dump(