feat: Implement user profile preferences for start page, Git identity, and task drawer auto-open, alongside Git server default branch configuration.

2026-03-08 10:19:38 +03:00
parent 12d17ec35e
commit e864a9e08b
30 changed files with 2041 additions and 211 deletions
--- a/backend/src/api/routes/tests/test_git_status_route.py
+++ b/backend/src/api/routes/tests/test_git_status_route.py
@@ -8,6 +8,7 @@
 from fastapi import HTTPException
 import pytest
 import asyncio
+from unittest.mock import MagicMock

 from src.api.routes import git as git_routes

@@ -195,4 +196,121 @@ def test_get_repository_status_batch_deduplicates_and_truncates_ids(monkeypatch)
    assert "1" in response.statuses
 # [/DEF:test_get_repository_status_batch_deduplicates_and_truncates_ids:Function]

+
+# [DEF:test_commit_changes_applies_profile_identity_before_commit:Function]
+# @PURPOSE: Ensure commit route configures repository identity from profile preferences before commit call.
+# @PRE: Profile preference contains git_username/git_email for current user.
+# @POST: git_service.configure_identity receives resolved identity and commit proceeds.
+def test_commit_changes_applies_profile_identity_before_commit(monkeypatch):
+    class IdentityGitService:
+        def __init__(self):
+            self.configured_identity = None
+            self.commit_payload = None
+
+        def configure_identity(self, dashboard_id: int, git_username: str, git_email: str):
+            self.configured_identity = (dashboard_id, git_username, git_email)
+
+        def commit_changes(self, dashboard_id: int, message: str, files):
+            self.commit_payload = (dashboard_id, message, files)
+
+    class PreferenceRow:
+        git_username = "user_1"
+        git_email = "user1@mail.ru"
+
+    class PreferenceQuery:
+        def filter(self, *_args, **_kwargs):
+            return self
+
+        def first(self):
+            return PreferenceRow()
+
+    class DbStub:
+        def query(self, _model):
+            return PreferenceQuery()
+
+    class UserStub:
+        id = "u-1"
+
+    class CommitPayload:
+        message = "test"
+        files = ["dashboards/a.yaml"]
+
+    identity_service = IdentityGitService()
+    monkeypatch.setattr(git_routes, "git_service", identity_service)
+    monkeypatch.setattr(
+        git_routes,
+        "_resolve_dashboard_id_from_ref",
+        lambda *_args, **_kwargs: 12,
+    )
+
+    asyncio.run(
+        git_routes.commit_changes(
+            "dashboard-12",
+            CommitPayload(),
+            config_manager=MagicMock(),
+            db=DbStub(),
+            current_user=UserStub(),
+        )
+    )
+
+    assert identity_service.configured_identity == (12, "user_1", "user1@mail.ru")
+    assert identity_service.commit_payload == (12, "test", ["dashboards/a.yaml"])
+# [/DEF:test_commit_changes_applies_profile_identity_before_commit:Function]
+
+
+# [DEF:test_pull_changes_applies_profile_identity_before_pull:Function]
+# @PURPOSE: Ensure pull route configures repository identity from profile preferences before pull call.
+# @PRE: Profile preference contains git_username/git_email for current user.
+# @POST: git_service.configure_identity receives resolved identity and pull proceeds.
+def test_pull_changes_applies_profile_identity_before_pull(monkeypatch):
+    class IdentityGitService:
+        def __init__(self):
+            self.configured_identity = None
+            self.pulled_dashboard_id = None
+
+        def configure_identity(self, dashboard_id: int, git_username: str, git_email: str):
+            self.configured_identity = (dashboard_id, git_username, git_email)
+
+        def pull_changes(self, dashboard_id: int):
+            self.pulled_dashboard_id = dashboard_id
+
+    class PreferenceRow:
+        git_username = "user_1"
+        git_email = "user1@mail.ru"
+
+    class PreferenceQuery:
+        def filter(self, *_args, **_kwargs):
+            return self
+
+        def first(self):
+            return PreferenceRow()
+
+    class DbStub:
+        def query(self, _model):
+            return PreferenceQuery()
+
+    class UserStub:
+        id = "u-1"
+
+    identity_service = IdentityGitService()
+    monkeypatch.setattr(git_routes, "git_service", identity_service)
+    monkeypatch.setattr(
+        git_routes,
+        "_resolve_dashboard_id_from_ref",
+        lambda *_args, **_kwargs: 12,
+    )
+
+    asyncio.run(
+        git_routes.pull_changes(
+            "dashboard-12",
+            config_manager=MagicMock(),
+            db=DbStub(),
+            current_user=UserStub(),
+        )
+    )
+
+    assert identity_service.configured_identity == (12, "user_1", "user1@mail.ru")
+    assert identity_service.pulled_dashboard_id == 12
+# [/DEF:test_pull_changes_applies_profile_identity_before_pull:Function]
+
 # [/DEF:backend.src.api.routes.__tests__.test_git_status_route:Module]
--- a/backend/src/api/routes/tests/test_profile_api.py
+++ b/backend/src/api/routes/tests/test_profile_api.py
@@ -15,8 +15,10 @@ from src.app import app
 from src.core.database import get_db
 from src.dependencies import get_config_manager, get_current_user
 from src.schemas.profile import (
+    ProfilePermissionState,
    ProfilePreference,
    ProfilePreferenceResponse,
+    ProfileSecuritySummary,
    SupersetAccountCandidate,
    SupersetAccountLookupResponse,
 )
@@ -80,9 +82,27 @@ def _build_preference_response(user_id: str = "u-1") -> ProfilePreferenceRespons
            superset_username="John_Doe",
            superset_username_normalized="john_doe",
            show_only_my_dashboards=True,
+            git_username="ivan.ivanov",
+            git_email="ivan@company.local",
+            has_git_personal_access_token=True,
+            git_personal_access_token_masked="iv***al",
+            start_page="reports",
+            auto_open_task_drawer=False,
+            dashboards_table_density="compact",
            created_at=now,
            updated_at=now,
        ),
+        security=ProfileSecuritySummary(
+            read_only=True,
+            auth_source="adfs",
+            current_role="Data Engineer",
+            role_source="adfs",
+            roles=["Data Engineer"],
+            permissions=[
+                ProfilePermissionState(key="migration:run", allowed=True),
+                ProfilePermissionState(key="admin:users", allowed=False),
+            ],
+        ),
    )
 # [/DEF:_build_preference_response:Function]

@@ -104,6 +124,16 @@ def test_get_profile_preferences_returns_self_payload(profile_route_deps_fixture
    assert payload["status"] == "success"
    assert payload["preference"]["user_id"] == mock_user.id
    assert payload["preference"]["superset_username_normalized"] == "john_doe"
+    assert payload["preference"]["git_username"] == "ivan.ivanov"
+    assert payload["preference"]["git_email"] == "ivan@company.local"
+    assert payload["preference"]["has_git_personal_access_token"] is True
+    assert payload["preference"]["git_personal_access_token_masked"] == "iv***al"
+    assert payload["preference"]["start_page"] == "reports"
+    assert payload["preference"]["auto_open_task_drawer"] is False
+    assert payload["preference"]["dashboards_table_density"] == "compact"
+    assert payload["security"]["read_only"] is True
+    assert payload["security"]["current_role"] == "Data Engineer"
+    assert payload["security"]["permissions"][0]["key"] == "migration:run"
    service.get_my_preference.assert_called_once_with(mock_user)
 # [/DEF:test_get_profile_preferences_returns_self_payload:Function]

@@ -123,6 +153,12 @@ def test_patch_profile_preferences_success(profile_route_deps_fixture):
            json={
                "superset_username": "John_Doe",
                "show_only_my_dashboards": True,
+                "git_username": "ivan.ivanov",
+                "git_email": "ivan@company.local",
+                "git_personal_access_token": "ghp_1234567890",
+                "start_page": "reports-logs",
+                "auto_open_task_drawer": False,
+                "dashboards_table_density": "free",
            },
        )

@@ -131,7 +167,21 @@ def test_patch_profile_preferences_success(profile_route_deps_fixture):
    assert payload["status"] == "success"
    assert payload["preference"]["superset_username"] == "John_Doe"
    assert payload["preference"]["show_only_my_dashboards"] is True
+    assert payload["preference"]["git_username"] == "ivan.ivanov"
+    assert payload["preference"]["git_email"] == "ivan@company.local"
+    assert payload["preference"]["start_page"] == "reports"
+    assert payload["preference"]["auto_open_task_drawer"] is False
+    assert payload["preference"]["dashboards_table_density"] == "compact"
    service.update_my_preference.assert_called_once()
+
+    called_kwargs = service.update_my_preference.call_args.kwargs
+    assert called_kwargs["current_user"] == mock_user
+    assert called_kwargs["payload"].git_username == "ivan.ivanov"
+    assert called_kwargs["payload"].git_email == "ivan@company.local"
+    assert called_kwargs["payload"].git_personal_access_token == "ghp_1234567890"
+    assert called_kwargs["payload"].start_page == "reports-logs"
+    assert called_kwargs["payload"].auto_open_task_drawer is False
+    assert called_kwargs["payload"].dashboards_table_density == "free"
 # [/DEF:test_patch_profile_preferences_success:Function]


--- a/backend/src/api/routes/git.py
+++ b/backend/src/api/routes/git.py
@@ -15,11 +15,13 @@ from sqlalchemy.orm import Session
 from typing import List, Optional
 import typing
 import os
-from src.dependencies import get_config_manager, has_permission
+from src.dependencies import get_config_manager, get_current_user, has_permission
 from src.core.database import get_db
+from src.models.auth import User
 from src.models.git import GitServerConfig, GitRepository, GitProvider
+from src.models.profile import UserDashboardPreference
 from src.api.routes.git_schemas import (
-    GitServerConfigSchema, GitServerConfigCreate,
+    GitServerConfigSchema, GitServerConfigCreate, GitServerConfigUpdate,
    BranchSchema, BranchCreate,
    BranchCheckout, CommitSchema, CommitCreate,
    DeploymentEnvironmentSchema, DeployRequest, RepoInitRequest,
@@ -208,6 +210,84 @@ def _resolve_repo_key_from_ref(
    return f"dashboard-{dashboard_id}"
 # [/DEF:_resolve_repo_key_from_ref:Function]

+
+# [DEF:_sanitize_optional_identity_value:Function]
+# @PURPOSE: Normalize optional identity value into trimmed string or None.
+# @PRE: value may be None or blank.
+# @POST: Returns sanitized value suitable for git identity configuration.
+# @RETURN: Optional[str]
+def _sanitize_optional_identity_value(value: Optional[str]) -> Optional[str]:
+    normalized = str(value or "").strip()
+    if not normalized:
+        return None
+    return normalized
+# [/DEF:_sanitize_optional_identity_value:Function]
+
+
+# [DEF:_resolve_current_user_git_identity:Function]
+# @PURPOSE: Resolve configured Git username/email from current user's profile preferences.
+# @PRE: `db` may be stubbed in tests; `current_user` may be absent for direct handler invocations.
+# @POST: Returns tuple(username, email) only when both values are configured.
+# @RETURN: Optional[tuple[str, str]]
+def _resolve_current_user_git_identity(
+    db: Session,
+    current_user: Optional[User],
+) -> Optional[tuple[str, str]]:
+    if db is None or not hasattr(db, "query"):
+        return None
+
+    user_id = _sanitize_optional_identity_value(getattr(current_user, "id", None))
+    if not user_id:
+        return None
+
+    try:
+        preference = (
+            db.query(UserDashboardPreference)
+            .filter(UserDashboardPreference.user_id == user_id)
+            .first()
+        )
+    except Exception as resolve_error:
+        logger.warning(
+            "[_resolve_current_user_git_identity][Action] Failed to load profile preference for user %s: %s",
+            user_id,
+            resolve_error,
+        )
+        return None
+
+    if not preference:
+        return None
+
+    git_username = _sanitize_optional_identity_value(getattr(preference, "git_username", None))
+    git_email = _sanitize_optional_identity_value(getattr(preference, "git_email", None))
+    if not git_username or not git_email:
+        return None
+    return git_username, git_email
+# [/DEF:_resolve_current_user_git_identity:Function]
+
+
+# [DEF:_apply_git_identity_from_profile:Function]
+# @PURPOSE: Apply user-scoped Git identity to repository-local config before write/pull operations.
+# @PRE: dashboard_id is resolved; db/current_user may be missing in direct test invocation context.
+# @POST: git_service.configure_identity is called only when identity and method are available.
+# @RETURN: None
+def _apply_git_identity_from_profile(
+    dashboard_id: int,
+    db: Session,
+    current_user: Optional[User],
+) -> None:
+    identity = _resolve_current_user_git_identity(db, current_user)
+    if not identity:
+        return
+
+    configure_identity = getattr(git_service, "configure_identity", None)
+    if not callable(configure_identity):
+        return
+
+    git_username, git_email = identity
+    configure_identity(dashboard_id, git_username, git_email)
+# [/DEF:_apply_git_identity_from_profile:Function]
+
+
 # [DEF:get_git_configs:Function]
 # @PURPOSE: List all configured Git servers.
 # @PRE: Database session `db` is available.
@@ -219,7 +299,13 @@ async def get_git_configs(
    _ = Depends(has_permission("admin:settings", "READ"))
 ):
    with belief_scope("get_git_configs"):
-        return db.query(GitServerConfig).all()
+        configs = db.query(GitServerConfig).all()
+        result = []
+        for config in configs:
+            schema = GitServerConfigSchema.from_orm(config)
+            schema.pat = "********"
+            result.append(schema)
+        return result
 # [/DEF:get_git_configs:Function]

 # [DEF:create_git_config:Function]
@@ -242,6 +328,40 @@ async def create_git_config(
        return db_config
 # [/DEF:create_git_config:Function]

+# [DEF:update_git_config:Function]
+# @PURPOSE: Update an existing Git server configuration.
+# @PRE: `config_id` corresponds to an existing configuration.
+# @POST: The configuration record is updated in the database.
+# @PARAM: config_id (str)
+# @PARAM: config_update (GitServerConfigUpdate)
+# @RETURN: GitServerConfigSchema
+@router.put("/config/{config_id}", response_model=GitServerConfigSchema)
+async def update_git_config(
+    config_id: str,
+    config_update: GitServerConfigUpdate,
+    db: Session = Depends(get_db),
+    _ = Depends(has_permission("admin:settings", "WRITE"))
+):
+    with belief_scope("update_git_config"):
+        db_config = db.query(GitServerConfig).filter(GitServerConfig.id == config_id).first()
+        if not db_config:
+            raise HTTPException(status_code=404, detail="Configuration not found")
+        
+        update_data = config_update.dict(exclude_unset=True)
+        if update_data.get("pat") == "********":
+            update_data.pop("pat")
+            
+        for key, value in update_data.items():
+            setattr(db_config, key, value)
+            
+        db.commit()
+        db.refresh(db_config)
+        
+        result_schema = GitServerConfigSchema.from_orm(db_config)
+        result_schema.pat = "********"
+        return result_schema
+# [/DEF:update_git_config:Function]
+
 # [DEF:delete_git_config:Function]
 # @PURPOSE: Remove a Git server configuration.
 # @PRE: `config_id` corresponds to an existing configuration.
@@ -271,10 +391,22 @@ async def delete_git_config(
@router.post("/config/test")
 async def test_git_config(
    config: GitServerConfigCreate,
+    db: Session = Depends(get_db),
    _ = Depends(has_permission("admin:settings", "READ"))
 ):
    with belief_scope("test_git_config"):
-        success = await git_service.test_connection(config.provider, config.url, config.pat)
+        pat_to_use = config.pat
+        if pat_to_use == "********":
+            if config.config_id:
+                db_config = db.query(GitServerConfig).filter(GitServerConfig.id == config.config_id).first()
+                if db_config:
+                    pat_to_use = db_config.pat
+            else:
+                db_config = db.query(GitServerConfig).filter(GitServerConfig.url == config.url).first()
+                if db_config:
+                    pat_to_use = db_config.pat
+
+        success = await git_service.test_connection(config.provider, config.url, pat_to_use)
        if success:
            return {"status": "success", "message": "Connection successful"}
        else:
@@ -459,7 +591,7 @@ async def init_repository(
        try:
            # 2. Perform Git clone/init
            logger.info(f"[init_repository][Action] Initializing repo for dashboard {dashboard_id}")
-            git_service.init_repo(dashboard_id, init_data.remote_url, config.pat, repo_key=repo_key)
+            git_service.init_repo(dashboard_id, init_data.remote_url, config.pat, repo_key=repo_key, default_branch=config.default_branch)
            
            # 3. Save to DB
            repo_path = git_service._get_repo_path(dashboard_id, repo_key=repo_key)
@@ -583,11 +715,14 @@ async def create_branch(
    branch_data: BranchCreate,
    env_id: Optional[str] = None,
    config_manager=Depends(get_config_manager),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
    _ = Depends(has_permission("plugin:git", "EXECUTE"))
 ):
    with belief_scope("create_branch"):
        try:
            dashboard_id = _resolve_dashboard_id_from_ref(dashboard_ref, config_manager, env_id)
+            _apply_git_identity_from_profile(dashboard_id, db, current_user)
            git_service.create_branch(dashboard_id, branch_data.name, branch_data.from_branch)
            return {"status": "success"}
        except HTTPException:
@@ -633,11 +768,14 @@ async def commit_changes(
    commit_data: CommitCreate,
    env_id: Optional[str] = None,
    config_manager=Depends(get_config_manager),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
    _ = Depends(has_permission("plugin:git", "EXECUTE"))
 ):
    with belief_scope("commit_changes"):
        try:
            dashboard_id = _resolve_dashboard_id_from_ref(dashboard_ref, config_manager, env_id)
+            _apply_git_identity_from_profile(dashboard_id, db, current_user)
            git_service.commit_changes(dashboard_id, commit_data.message, commit_data.files)
            return {"status": "success"}
        except HTTPException:
@@ -679,11 +817,14 @@ async def pull_changes(
    dashboard_ref: str,
    env_id: Optional[str] = None,
    config_manager=Depends(get_config_manager),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
    _ = Depends(has_permission("plugin:git", "EXECUTE"))
 ):
    with belief_scope("pull_changes"):
        try:
            dashboard_id = _resolve_dashboard_id_from_ref(dashboard_ref, config_manager, env_id)
+            _apply_git_identity_from_profile(dashboard_id, db, current_user)
            git_service.pull_changes(dashboard_id)
            return {"status": "success"}
        except HTTPException:
@@ -734,6 +875,7 @@ async def promote_dashboard(
    env_id: Optional[str] = None,
    config_manager=Depends(get_config_manager),
    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
    _ = Depends(has_permission("plugin:git", "EXECUTE"))
 ):
    with belief_scope("promote_dashboard"):
@@ -762,6 +904,7 @@ async def promote_dashboard(
                to_branch,
                reason,
            )
+            _apply_git_identity_from_profile(dashboard_id, db, current_user)
            result = git_service.promote_direct_merge(
                dashboard_id=dashboard_id,
                from_branch=from_branch,
--- a/backend/src/api/routes/git_schemas.py
+++ b/backend/src/api/routes/git_schemas.py
@@ -21,14 +21,27 @@ class GitServerConfigBase(BaseModel):
    provider: GitProvider = Field(..., description="Git provider (GITHUB, GITLAB, GITEA)")
    url: str = Field(..., description="Server base URL")
    pat: str = Field(..., description="Personal Access Token")
+    pat: str = Field(..., description="Personal Access Token")
    default_repository: Optional[str] = Field(None, description="Default repository path (org/repo)")
+    default_branch: Optional[str] = Field("main", description="Default branch logic/name")
 # [/DEF:GitServerConfigBase:Class]

+# [DEF:GitServerConfigUpdate:Class]
+# @PURPOSE: Schema for updating an existing Git server configuration.
+class GitServerConfigUpdate(BaseModel):
+    name: Optional[str] = Field(None, description="Display name for the Git server")
+    provider: Optional[GitProvider] = Field(None, description="Git provider (GITHUB, GITLAB, GITEA)")
+    url: Optional[str] = Field(None, description="Server base URL")
+    pat: Optional[str] = Field(None, description="Personal Access Token")
+    default_repository: Optional[str] = Field(None, description="Default repository path (org/repo)")
+    default_branch: Optional[str] = Field(None, description="Default branch logic/name")
+# [/DEF:GitServerConfigUpdate:Class]
+
 # [DEF:GitServerConfigCreate:Class]
 # @PURPOSE: Schema for creating a new Git server configuration.
 class GitServerConfigCreate(GitServerConfigBase):
    """Schema for creating a new Git server configuration."""
-    pass
+    config_id: Optional[str] = Field(None, description="Optional config ID, useful for testing an existing config without sending its full PAT")
 # [/DEF:GitServerConfigCreate:Class]

 # [DEF:GitServerConfigSchema:Class]
--- a/backend/src/api/routes/profile.py
+++ b/backend/src/api/routes/profile.py
@@ -23,7 +23,11 @@ from sqlalchemy.orm import Session

 from ...core.database import get_db
 from ...core.logger import logger, belief_scope
-from ...dependencies import get_config_manager, get_current_user
+from ...dependencies import (
+    get_config_manager,
+    get_current_user,
+    get_plugin_loader,
+)
 from ...models.auth import User
 from ...schemas.profile import (
    ProfilePreferenceResponse,
@@ -46,8 +50,12 @@ router = APIRouter(prefix="/api/profile", tags=["profile"])
 # @PURPOSE: Build profile service for current request scope.
 # @PRE: db session and config manager are available.
 # @POST: Returns a ready ProfileService instance.
-def _get_profile_service(db: Session, config_manager) -> ProfileService:
-    return ProfileService(db=db, config_manager=config_manager)
+def _get_profile_service(db: Session, config_manager, plugin_loader=None) -> ProfileService:
+    return ProfileService(
+        db=db,
+        config_manager=config_manager,
+        plugin_loader=plugin_loader,
+    )
 # [/DEF:_get_profile_service:Function]


@@ -60,10 +68,11 @@ async def get_preferences(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
    config_manager=Depends(get_config_manager),
+    plugin_loader=Depends(get_plugin_loader),
 ):
    with belief_scope("profile.get_preferences", f"user_id={current_user.id}"):
        logger.reason("[REASON] Resolving current user preference")
-        service = _get_profile_service(db, config_manager)
+        service = _get_profile_service(db, config_manager, plugin_loader)
        return service.get_my_preference(current_user)
 # [/DEF:get_preferences:Function]

@@ -78,9 +87,10 @@ async def update_preferences(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
    config_manager=Depends(get_config_manager),
+    plugin_loader=Depends(get_plugin_loader),
 ):
    with belief_scope("profile.update_preferences", f"user_id={current_user.id}"):
-        service = _get_profile_service(db, config_manager)
+        service = _get_profile_service(db, config_manager, plugin_loader)
        try:
            logger.reason("[REASON] Attempting preference save")
            return service.update_my_preference(current_user=current_user, payload=payload)
@@ -108,12 +118,13 @@ async def lookup_superset_accounts(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
    config_manager=Depends(get_config_manager),
+    plugin_loader=Depends(get_plugin_loader),
 ):
    with belief_scope(
        "profile.lookup_superset_accounts",
        f"user_id={current_user.id}, environment_id={environment_id}",
    ):
-        service = _get_profile_service(db, config_manager)
+        service = _get_profile_service(db, config_manager, plugin_loader)
        lookup_request = SupersetAccountLookupRequest(
            environment_id=environment_id,
            search=search,