You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@superset.apache.org by mi...@apache.org on 2026/10/12 04:06:57 UTC

(superset) branch master updated: fix(mcp): support custom user models during dashboard and chart operations (#45036)

This is an automated email from the ASF dual-hosted git repository.

aminghadersohi pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/superset.git


The following commit(s) were added to refs/heads/master by this push:
     new f4fe4e13c47 fix(mcp): support custom user models during dashboard and chart operations (#45036)
f4fe4e13c47 is described below

commit f4fe4e13c47d204dffca5e9408e388811d220f9f
Author: Francesco.Castaldi <in...@francescocastaldi.it>
AuthorDate: Mon Oct 12 06:06:49 2026 +0200

    fix(mcp): support custom user models during dashboard and chart operations (#45036)
    
    Co-authored-by: Francesco Castaldi <fr...@mapsgroup.it>
---
 superset/initialization/__init__.py                |   6 +
 superset/models/dashboard.py                       |  82 ++++++---
 tests/unit_tests/models/dashboard_test.py          | 191 +++++++++++++++++++++
 .../subjects/test_creator_group_call_sites.py      |  22 +--
 4 files changed, 269 insertions(+), 32 deletions(-)

diff --git a/superset/initialization/__init__.py b/superset/initialization/__init__.py
index 73dbc5d4c01..78066fc9743 100644
--- a/superset/initialization/__init__.py
+++ b/superset/initialization/__init__.py
@@ -1322,6 +1322,12 @@ class SupersetAppInitializer:  # pylint: disable=too-many-public-methods
 
         register_session_invalidation_events(appbuilder.sm.user_model)
 
+        from superset.models.dashboard import (
+            register_dashboard_copy_events,
+        )
+
+        register_dashboard_copy_events(appbuilder.sm.user_model)
+
         @self.superset_app.context_processor
         def get_common_bootstrap_data() -> dict[str, Any]:
             # Import here to avoid circular imports
diff --git a/superset/models/dashboard.py b/superset/models/dashboard.py
index e6a09759e17..ffa7d71a943 100644
--- a/superset/models/dashboard.py
+++ b/superset/models/dashboard.py
@@ -19,13 +19,13 @@ from __future__ import annotations
 import logging
 import uuid
 from collections import defaultdict, deque
+from collections.abc import Sequence
 from typing import Any, Callable, Optional, TYPE_CHECKING
 
 import sqlalchemy as sqla
 from flask import current_app as app, has_request_context, url_for
 from flask_appbuilder import Model
 from flask_appbuilder.models.decorators import renders
-from flask_appbuilder.security.sqla.models import User
 from markupsafe import escape, Markup
 from sqlalchemy import (
     Boolean,
@@ -37,7 +37,7 @@ from sqlalchemy import (
     Text,
 )
 from sqlalchemy.engine.base import Connection
-from sqlalchemy.orm import relationship, subqueryload
+from sqlalchemy.orm import relationship, Session, subqueryload
 from sqlalchemy.orm.mapper import Mapper
 from sqlalchemy.sql.elements import BinaryExpression
 from superset_core.common.models import Dashboard as CoreDashboard
@@ -70,26 +70,41 @@ metadata = Model.metadata  # pylint: disable=no-member
 logger = logging.getLogger(__name__)
 
 
-def copy_dashboard(_mapper: Mapper, _connection: Connection, target: Dashboard) -> None:
-    dashboard_id = app.config["DASHBOARD_TEMPLATE_ID"]
-    if dashboard_id is None:
-        return
+def _copy_dashboard_for_user(
+    session: Session,
+    target: Any,
+    dashboard_id: int | str,
+) -> None:
+    """Copy the configured template dashboard to a newly created user.
 
+    Clones the template dashboard metadata and slices, associates the new user
+    as an editor and their groups as viewers, and configures the cloned dashboard
+    as the user's welcome dashboard.
+
+    :param session: The active SQLAlchemy session to use for queries and persistence.
+    :param target: The newly created user instance.
+    :param dashboard_id: The ID of the template dashboard to copy.
+    """
+    from superset.subjects.models import Subject
     from superset.subjects.utils import (
         get_default_viewers_for_groups,
         get_user_subject,
     )
 
-    session = sqla.inspect(target).session  # pylint: disable=disallowed-name
-    new_user = session.query(User).filter_by(id=target.id).first()
+    def _rebind(subjects: Sequence[Subject | None]) -> list[Subject]:
+        """The helpers resolve subjects on ``db.session``; a persistent object
+        cannot be cascaded into a second session."""
+        ids = [s.id for s in subjects if s is not None]
+        return session.query(Subject).filter(Subject.id.in_(ids)).all() if ids else []
 
-    # copy template dashboard to user
     template = session.query(Dashboard).filter_by(id=int(dashboard_id)).first()
-    editors = []
-    if new_user:
-        subj = get_user_subject(new_user.id)
-        if subj:
-            editors.append(subj)
+    if not template:
+        return
+
+    editors = _rebind([get_user_subject(target.id)])
+    viewers = _rebind(
+        get_default_viewers_for_groups(list(getattr(target, "groups", []) or []))
+    )
     dashboard = Dashboard(
         dashboard_title=template.dashboard_title,
         position_json=template.position_json,
@@ -98,15 +113,10 @@ def copy_dashboard(_mapper: Mapper, _connection: Connection, target: Dashboard)
         json_metadata=template.json_metadata,
         slices=template.slices,
         editors=editors,
-        # Resolved from the in-memory collection: this runs in ``after_insert``
-        # for the user, before their ``ab_user_group`` rows are written.
-        viewers=get_default_viewers_for_groups(
-            list(getattr(new_user, "groups", []) or [])
-        ),
+        viewers=viewers,
     )
     session.add(dashboard)
-
-    # set dashboard as the welcome dashboard
+    session.flush()
     extra_attributes = UserAttribute(
         user_id=target.id, welcome_dashboard_id=dashboard.id
     )
@@ -114,7 +124,35 @@ def copy_dashboard(_mapper: Mapper, _connection: Connection, target: Dashboard)
     session.commit()  # pylint: disable=consider-using-transaction
 
 
-sqla.event.listen(User, "after_insert", copy_dashboard)
+def copy_dashboard(_mapper: Mapper, _connection: Connection, target: Any) -> None:
+    """SQLAlchemy mapper event hook triggered on user creation (after_insert).
+
+    Creates a personal copy of the configured template dashboard for the user.
+    Uses an isolated session bound to the active transaction connection to avoid
+    SQLAlchemy FlushError or overlapping flush issues during the flush lifecycle.
+
+    :param _mapper: The SQLAlchemy mapper for the entity.
+    :param _connection: The active database connection for the event.
+    :param target: The user entity instance being inserted.
+    """
+    dashboard_id = app.config["DASHBOARD_TEMPLATE_ID"]
+    if dashboard_id is None:
+        return
+
+    with Session(bind=_connection) as session:  # pylint: disable=disallowed-name
+        _copy_dashboard_for_user(session, target, dashboard_id)
+
+
+def register_dashboard_copy_events(user_model: Any) -> None:
+    """Register the after_insert listener that copies dashboard templates for new users.
+
+    Dynamically attaches the listener to the active security manager user model,
+    supporting custom and extended user models. Idempotent across repeated calls.
+
+    :param user_model: The user model class to attach the event listener to.
+    """
+    if not sqla.event.contains(user_model, "after_insert", copy_dashboard):
+        sqla.event.listen(user_model, "after_insert", copy_dashboard)
 
 
 dashboard_slices = Table(
diff --git a/tests/unit_tests/models/dashboard_test.py b/tests/unit_tests/models/dashboard_test.py
index 40e0836f2fb..e86af63793f 100644
--- a/tests/unit_tests/models/dashboard_test.py
+++ b/tests/unit_tests/models/dashboard_test.py
@@ -16,10 +16,13 @@
 # under the License.
 
 import logging
+from typing import Any
 from unittest.mock import Mock, patch, PropertyMock
 
 import pytest
+import sqlalchemy as sqla
 from flask import current_app
+from flask_appbuilder.security.sqla.models import User
 
 from superset.connectors.sqla.models import BaseDatasource
 from superset.models.dashboard import Dashboard
@@ -737,3 +740,191 @@ def test_datasets_trimmed_for_slices_keeps_colliding_ids_separate() -> None:
     # with the exact slice list (no semantic-view slice leaking into it).
     assert result == [(table_datasource, {"cols": ["column"]})]
     table_datasource.data_for_slices.assert_called_once_with([sesh_table_slice])
+
+
+def test_custom_user_model_dashboard_copy_listener(app_context: None) -> None:
+    """Ensure dashboard copy events can be registered dynamically
+    for custom user models.
+    """
+    from superset.models.dashboard import register_dashboard_copy_events
+
+    assert callable(register_dashboard_copy_events)
+
+
+class CustomUserModel(User):
+    """Custom user model subclass for testing dynamic security manager models."""
+
+    __tablename__ = "ab_user"
+    custom_field = "custom_value"
+
+
+@pytest.fixture
+def custom_user_model() -> type[CustomUserModel]:
+    """Fixture providing a mock CustomUserModel class."""
+    return CustomUserModel
+
+
+@pytest.fixture
+def mock_dashboard_template() -> Dashboard:
+    """Fixture providing a mock template Dashboard instance."""
+    dash = Dashboard()
+    dash.id = 100
+    dash.dashboard_title = "Template Dashboard"
+    dash.position_json = "{}"
+    dash.description = "Template description"
+    dash.css = ""
+    dash.json_metadata = "{}"
+    dash.slices = []
+    return dash
+
+
+def test_register_dashboard_copy_events_dynamic_and_idempotent(
+    custom_user_model: type[CustomUserModel],
+) -> None:
+    """Ensure dynamic listener registration attaches to custom user model
+    and is strictly idempotent.
+    """
+    from superset.models.dashboard import (
+        copy_dashboard,
+        register_dashboard_copy_events,
+    )
+
+    register_dashboard_copy_events(custom_user_model)
+    assert sqla.event.contains(custom_user_model, "after_insert", copy_dashboard)
+
+    # Calling a second time should not register duplicate listeners
+    register_dashboard_copy_events(custom_user_model)
+    assert sqla.event.contains(custom_user_model, "after_insert", copy_dashboard)
+
+
+def test_copy_dashboard_early_return_when_no_template_configured(
+    app_context: None,
+) -> None:
+    """Ensure copy_dashboard returns early without query when no template
+    is configured.
+    """
+    from superset.models.dashboard import copy_dashboard
+
+    mock_connection = Mock()
+    mock_target = Mock()
+    with patch.dict(current_app.config, {"DASHBOARD_TEMPLATE_ID": None}):
+        copy_dashboard(Mock(), mock_connection, mock_target)
+
+    mock_connection.execute.assert_not_called()
+
+
+def test_copy_dashboard_missing_template_returns_early(
+    app_context: None,
+) -> None:
+    """Ensure copy_dashboard exits gracefully if template dashboard is not found."""
+    from superset.models.dashboard import copy_dashboard
+
+    mock_session = Mock()
+    mock_session.query.return_value.filter_by.return_value.first.return_value = None
+
+    target = Mock(id=42, groups=[])
+    with (
+        patch.dict(current_app.config, {"DASHBOARD_TEMPLATE_ID": 999}),
+        patch(
+            "superset.models.dashboard.Session",
+            return_value=mock_session,
+        ),
+    ):
+        mock_session.__enter__ = Mock(return_value=mock_session)
+        mock_session.__exit__ = Mock(return_value=None)
+        copy_dashboard(Mock(), Mock(), target)
+
+    mock_session.add.assert_not_called()
+    mock_session.commit.assert_not_called()
+
+
+def test_copy_dashboard_with_custom_user_model_in_isolated_session(
+    app_context: None,
+    mock_dashboard_template: Dashboard,
+) -> None:
+    """Ensure copy_dashboard copies the template dashboard for custom user model
+    using an isolated session without SQLAlchemy FlushError.
+    """
+    from superset.models.dashboard import copy_dashboard
+
+    target = Mock(id=55, groups=[])
+
+    mock_session = Mock()
+    mock_session.query.return_value.filter_by.return_value.first.return_value = (
+        mock_dashboard_template
+    )
+    mock_session.__enter__ = Mock(return_value=mock_session)
+    mock_session.__exit__ = Mock(return_value=None)
+
+    added_objects: list[Any] = []
+    mock_session.add.side_effect = lambda obj: added_objects.append(obj)
+
+    with (
+        patch.dict(current_app.config, {"DASHBOARD_TEMPLATE_ID": 100}),
+        patch(
+            "superset.models.dashboard.Session",
+            return_value=mock_session,
+        ),
+        patch("superset.subjects.utils.get_user_subject", return_value=None),
+        patch(
+            "superset.subjects.utils.get_default_viewers_for_groups",
+            return_value=[],
+        ),
+    ):
+        copy_dashboard(Mock(), Mock(), target)
+
+    mock_session.flush.assert_called_once()
+    mock_session.commit.assert_called_once()
+    assert len(added_objects) == 2
+    cloned_dashboard = added_objects[0]
+    extra_attributes = added_objects[1]
+    assert cloned_dashboard.dashboard_title == "Template Dashboard"
+    assert extra_attributes.user_id == 55
+
+
+def test_copy_dashboard_rebinds_subjects_in_isolated_session(
+    app_context: None,
+    mock_dashboard_template: Dashboard,
+) -> None:
+    """Ensure editors and viewers subjects are rebound in the isolated session."""
+    from superset.models.dashboard import copy_dashboard
+    from superset.subjects.models import Subject
+
+    group = Mock(id=10)
+    target = Mock(id=55, groups=[group])
+
+    db_subject = Subject()
+    db_subject.id = 1
+    rebound_subject = Subject()
+    rebound_subject.id = 1
+
+    mock_session = Mock()
+    mock_session.query.return_value.filter_by.return_value.first.return_value = (
+        mock_dashboard_template
+    )
+    mock_session.query.return_value.filter.return_value.all.return_value = [
+        rebound_subject
+    ]
+    mock_session.__enter__ = Mock(return_value=mock_session)
+    mock_session.__exit__ = Mock(return_value=None)
+
+    added_objects: list[Any] = []
+    mock_session.add.side_effect = lambda obj: added_objects.append(obj)
+
+    with (
+        patch.dict(current_app.config, {"DASHBOARD_TEMPLATE_ID": 100}),
+        patch("superset.models.dashboard.Session", return_value=mock_session),
+        patch("superset.subjects.utils.get_user_subject", return_value=db_subject),
+        patch(
+            "superset.subjects.utils.get_default_viewers_for_groups",
+            return_value=[db_subject],
+        ),
+    ):
+        copy_dashboard(Mock(), Mock(), target)
+
+    mock_session.flush.assert_called_once()
+    mock_session.commit.assert_called_once()
+    assert len(added_objects) == 2
+    cloned_dashboard = added_objects[0]
+    assert cloned_dashboard.editors == [rebound_subject]
+    assert cloned_dashboard.viewers == [rebound_subject]
diff --git a/tests/unit_tests/subjects/test_creator_group_call_sites.py b/tests/unit_tests/subjects/test_creator_group_call_sites.py
index 2d2f6b13080..7cc05000fba 100644
--- a/tests/unit_tests/subjects/test_creator_group_call_sites.py
+++ b/tests/unit_tests/subjects/test_creator_group_call_sites.py
@@ -173,13 +173,11 @@ def test_copy_dashboard_attaches_viewers_from_the_users_in_memory_groups(
 
     viewer = _group_subject()
     group = MagicMock()
-    new_user = MagicMock()
-    new_user.id = 5
-    new_user.groups = [group]
+    user = SimpleNamespace(id=5, groups=[group])
+    template = MagicMock()
     session = MagicMock()
-    # Both lookups (the user, then the template dashboard) go through the same
-    # mocked chain; a MagicMock stands in for either.
-    session.query.return_value.filter_by.return_value.first.return_value = new_user
+    session.query.return_value.filter_by.return_value.first.return_value = template
+    session.query.return_value.filter.return_value.all.return_value = [viewer]
 
     created: dict[str, Any] = {}
 
@@ -190,7 +188,9 @@ def test_copy_dashboard_attaches_viewers_from_the_users_in_memory_groups(
     with (
         patch.dict(dashboard_module.app.config, {"DASHBOARD_TEMPLATE_ID": 1}),
         patch.object(
-            dashboard_module.sqla, "inspect", return_value=MagicMock(session=session)
+            dashboard_module,
+            "Session",
+            return_value=MagicMock(__enter__=MagicMock(return_value=session)),
         ),
         patch.object(dashboard_module, "Dashboard", side_effect=_capture),
         patch("superset.subjects.utils.get_user_subject", return_value=None),
@@ -202,7 +202,7 @@ def test_copy_dashboard_attaches_viewers_from_the_users_in_memory_groups(
         dashboard_module.copy_dashboard(
             MagicMock(),
             MagicMock(),
-            SimpleNamespace(id=5),  # type: ignore[arg-type]
+            user,
         )
 
     assert created["viewers"] == [viewer]
@@ -283,8 +283,10 @@ def test_dashboard_copy_dao_attaches_default_viewers(app_context) -> None:
         patch.object(
             dashboard_dao,
             "Dashboard",
-            side_effect=lambda: created.append(MagicMock())  # type: ignore[func-returns-value]
-            or created[-1],
+            side_effect=lambda: (
+                created.append(MagicMock())  # type: ignore[func-returns-value]
+                or created[-1]
+            ),
         ),
         patch("superset.subjects.utils.get_user_subject", return_value=None),
         patch(