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(