From f8eedae9fcbb9b25471887fdb12818c763d1cb57 Mon Sep 17 00:00:00 2001 From: YueGuobin Date: Sat, 7 Nov 2026 00:27:32 +0800 Subject: [PATCH] feat: add endpoint for the current user's privileges on a project GET /projects/{project_id}/me/privileges returns the effective privileges of the logged in user, evaluated on the project's resource path. Unlike /access/users/me/privileges, ACEs scoped to the project and resource pools containing it are reflected. This gives clients what they need to show or hide buttons inside a project view. --- gns3server/api/routes/controller/projects.py | 40 ++++ gns3server/schemas/__init__.py | 2 + gns3server/schemas/controller/projects.py | 15 ++ .../controller/test_project_privileges.py | 191 ++++++++++++++++++ 4 files changed, 248 insertions(+) create mode 100644 tests/api/routes/controller/test_project_privileges.py diff --git a/gns3server/api/routes/controller/projects.py b/gns3server/api/routes/controller/projects.py index 63fc1d87b..4330bb926 100644 --- a/gns3server/api/routes/controller/projects.py +++ b/gns3server/api/routes/controller/projects.py @@ -191,6 +191,46 @@ def get_project(response: Response, project: Project = Depends(dep_project)) -> return project_dict +@router.get( + "/{project_id}/me/privileges", + response_model=schemas.ProjectPrivileges, + responses=GET_RESPONSES, + dependencies=[Depends(has_privilege("Project.Audit"))], +) +async def get_logged_in_user_privileges_on_project( + current_user: schemas.User = Depends(get_current_active_user), + project: Project = Depends(dep_project), + rbac_repo: RbacRepository = Depends(get_repository(RbacRepository)), +) -> schemas.ProjectPrivileges: + """ + Get the effective privileges of the current user on this project. + + Unlike /access/users/me/privileges (flattened across all resource paths), + each privilege is evaluated on the project's resource path, so the result + reflects ACEs scoped to this project and resource pools containing it. + This is meant for rendering purposes (e.g. showing or hiding buttons in + the project view): the server remains the authority for permission checks. + + Required privilege: Project.Audit + + Example: curl -X GET http://host:port/v3/projects/{project_id}/me/privileges -H "Authorization: Bearer " + """ + + if current_user.is_superadmin: + privilege_names = sorted(privilege.name for privilege in await rbac_repo.get_privileges()) + return schemas.ProjectPrivileges(is_superadmin=True, privileges=privilege_names) + + path = f"/projects/{project.id}" + # the flat view is the superset: only privileges granted somewhere can be + # granted on this path, so only those need to be evaluated against it + candidates = await rbac_repo.get_user_privileges(current_user.user_id) + project_privileges = [] + for name in candidates: + if await rbac_repo.check_user_has_privilege(current_user.user_id, path, name): + project_privileges.append(name) + return schemas.ProjectPrivileges(is_superadmin=False, privileges=sorted(project_privileges)) + + @router.put( "/{project_id}", response_model=schemas.Project, diff --git a/gns3server/schemas/__init__.py b/gns3server/schemas/__init__.py index ead7bf324..14281e397 100644 --- a/gns3server/schemas/__init__.py +++ b/gns3server/schemas/__init__.py @@ -71,6 +71,7 @@ from .controller.projects import ( ProjectCreate, ProjectDuplicate, ProjectFile, + ProjectPrivileges, ProjectStats, ProjectUpdate, ) @@ -351,6 +352,7 @@ __all__ = [ "ProjectDuplicate", "ProjectFile", "ProjectMarker", + "ProjectPrivileges", "ProjectStats", "ProjectUpdate", "Qemu", diff --git a/gns3server/schemas/controller/projects.py b/gns3server/schemas/controller/projects.py index b0c20addc..64585ef9b 100644 --- a/gns3server/schemas/controller/projects.py +++ b/gns3server/schemas/controller/projects.py @@ -139,3 +139,18 @@ class ProjectStats(BaseModel): drawings: int snapshots: int markers: int + + +class ProjectPrivileges(BaseModel): + """ + Effective privileges of the logged in user on a single project, evaluated + on the project's resource path (so ACEs scoped to that project and + resource pools containing it are reflected). + + This is a hint for rendering purposes only (e.g. showing or hiding buttons + in the project view): the server remains the authority for permission + checks on each request. + """ + + is_superadmin: bool + privileges: List[str] diff --git a/tests/api/routes/controller/test_project_privileges.py b/tests/api/routes/controller/test_project_privileges.py new file mode 100644 index 000000000..6b29b5c04 --- /dev/null +++ b/tests/api/routes/controller/test_project_privileges.py @@ -0,0 +1,191 @@ +# +# Copyright (C) 2026 GNS3 Technologies Inc. +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# + +""" +Tests for GET /projects/{project_id}/me/privileges: the per-project view of +the current user's effective privileges (unlike /access/users/me/privileges, +evaluated on the project resource path). +""" + +import uuid + +import pytest +import pytest_asyncio +from fastapi import FastAPI, status +from httpx import AsyncClient +from sqlalchemy.ext.asyncio import AsyncSession + +from gns3server.controller import Controller +from gns3server.controller.project import Project +from gns3server.db.models import User +from gns3server.db.repositories.pools import ResourcePoolsRepository +from gns3server.db.repositories.rbac import RbacRepository +from gns3server.schemas.controller.pools import ResourceCreate, ResourcePoolCreate +from gns3server.schemas.controller.rbac import ACECreate +from gns3server.services import auth_service +from gns3server.services.authentication import DEFAULT_JWT_SECRET_KEY + +pytestmark = pytest.mark.asyncio + + +class TestProjectPrivilegesRoute: + """ + Every test creates its own project (unique id) and its own ACEs, so the + file is order-independent under --random-order. + """ + + @pytest_asyncio.fixture + async def project(self, app: FastAPI, client: AsyncClient, controller: Controller) -> Project: + + project_id = str(uuid.uuid4()) + params = {"name": f"privileges-{project_id[:8]}", "project_id": project_id} + response = await client.post(app.url_path_for("create_project"), json=params) + assert response.status_code == status.HTTP_201_CREATED + return controller.get_project(project_id) + + @staticmethod + def _user_headers(user: User) -> dict: + token = auth_service.create_access_token(user.username, secret_key=DEFAULT_JWT_SECRET_KEY) + return {"Authorization": f"Bearer {token}"} + + async def _create_user_ace(self, db_session: AsyncSession, path: str, user: User, role_name: str) -> None: + + rbac_repo = RbacRepository(db_session) + role = await rbac_repo.get_role_by_name(role_name) + await rbac_repo.create_ace( + ACECreate( + path=path, + ace_type="user", + propagate=True, + user_id=str(user.user_id), + role_id=str(role.role_id), + ) + ) + + async def test_superadmin_gets_all_privileges(self, app: FastAPI, client: AsyncClient, project: Project) -> None: + + response = await client.get(app.url_path_for("get_logged_in_user_privileges_on_project", project_id=project.id)) + assert response.status_code == status.HTTP_200_OK + data = response.json() + assert data["is_superadmin"] is True + assert "Project.Audit" in data["privileges"] + assert "Project.Modify" in data["privileges"] + assert "Node.PowerMgmt" in data["privileges"] + + async def test_unknown_project_returns_404(self, app: FastAPI, client: AsyncClient) -> None: + + response = await client.get( + app.url_path_for("get_logged_in_user_privileges_on_project", project_id=str(uuid.uuid4())) + ) + assert response.status_code == status.HTTP_404_NOT_FOUND + + async def test_user_without_access_gets_403( + self, app: FastAPI, client: AsyncClient, project: Project, test_user: User + ) -> None: + + response = await client.get( + app.url_path_for("get_logged_in_user_privileges_on_project", project_id=project.id), + headers=self._user_headers(test_user), + ) + assert response.status_code == status.HTTP_403_FORBIDDEN + + async def test_user_ace_grants_project_scoped_privileges( + self, + app: FastAPI, + client: AsyncClient, + project: Project, + test_user: User, + db_session: AsyncSession, + ) -> None: + + # the "User" role carries the whole project-subtree family + await self._create_user_ace(db_session, f"/projects/{project.id}", test_user, "User") + + response = await client.get( + app.url_path_for("get_logged_in_user_privileges_on_project", project_id=project.id), + headers=self._user_headers(test_user), + ) + assert response.status_code == status.HTTP_200_OK + data = response.json() + assert data["is_superadmin"] is False + for privilege in ( + "Project.Audit", + "Project.Modify", + "Node.Modify", + "Node.Console", + "Node.PowerMgmt", + "Link.Capture", + "Snapshot.Restore", + ): + assert privilege in data["privileges"] + # privileges outside the role must not appear, even path-scoped + assert "User.Audit" not in data["privileges"] + assert "Template.Modify" not in data["privileges"] + + async def test_auditor_role_gets_audit_only( + self, + app: FastAPI, + client: AsyncClient, + project: Project, + test_user: User, + db_session: AsyncSession, + ) -> None: + + await self._create_user_ace(db_session, f"/projects/{project.id}", test_user, "Auditor") + + response = await client.get( + app.url_path_for("get_logged_in_user_privileges_on_project", project_id=project.id), + headers=self._user_headers(test_user), + ) + assert response.status_code == status.HTTP_200_OK + privileges = response.json()["privileges"] + assert "Project.Audit" in privileges + assert "Node.Audit" in privileges + assert "Link.Audit" in privileges + # auditors can look but not touch + assert "Project.Modify" not in privileges + assert "Node.Modify" not in privileges + assert "Node.Console" not in privileges + assert "Snapshot.Restore" not in privileges + + async def test_pool_membership_grants_privileges( + self, + app: FastAPI, + client: AsyncClient, + controller: Controller, + project: Project, + test_user: User, + db_session: AsyncSession, + ) -> None: + + pools_repo = ResourcePoolsRepository(db_session) + pool = await pools_repo.create_resource_pool(ResourcePoolCreate(name=f"pool-{uuid.uuid4().hex[:8]}")) + resource = await pools_repo.create_resource( + ResourceCreate(resource_id=uuid.UUID(project.id), resource_type="project", name=project.name) + ) + await pools_repo.add_resource_to_pool(pool.resource_pool_id, resource) + + await self._create_user_ace(db_session, f"/pools/{pool.resource_pool_id}", test_user, "Auditor") + + response = await client.get( + app.url_path_for("get_logged_in_user_privileges_on_project", project_id=project.id), + headers=self._user_headers(test_user), + ) + assert response.status_code == status.HTTP_200_OK + privileges = response.json()["privileges"] + assert "Project.Audit" in privileges + assert "Project.Modify" not in privileges