chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动

演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
wuzilongandCursor committed 2026-11-18 13:59:25 +08:00
1 parent 60158935f4
commit 6519682885
15831 files changed
+3063428

No files matched your search

@@ -0,0 +1,5 @@
"""Register workspace RBAC endpoints by use case."""
from controllers.console.workspace.rbac import members, policies, resources, roles
__all__ = ["members", "policies", "resources", "roles"]
@@ -0,0 +1,79 @@
"""Console RBAC members endpoints."""
from flask import request
from flask_restx import Resource
from werkzeug.exceptions import Forbidden
from controllers.common.errors import InvalidArgumentError
from controllers.common.rbac import rbac_language
from controllers.common.schema import query_params_from_model
from controllers.console import console_ns
from controllers.console.flask_admission import console_account_admission
from controllers.console.workspace.rbac.schemas import (
_AccessControlLanguageQuery,
_ReplaceMemberRolesRequest,
)
from extensions.ext_application_services import application_services
from libs.helper import dump_response
from machinery.context import RequestContext
from services.account_errors import AccountNotFoundError
from services.errors.base import NoPermissionError
from services.errors.workspace import (
CannotOperateSelfError,
InvalidWorkspaceMemberRoleError,
MemberNotInTenantError,
RoleAlreadyAssignedError,
)
from services.rbac import contracts as dto
@console_ns.route("/workspaces/current/rbac/my-permissions")
class RBACMyPermissionsApi(Resource):
@console_account_admission()
@console_ns.response(200, "Success", console_ns.models[dto.MyPermissionsResponse.__name__])
def get(self, context: RequestContext):
return dump_response(
dto.MyPermissionsResponse,
application_services().rbac.members.permissions(
context.active_workspace_id,
context.account_id,
app_id=request.args.get("app_id") or None,
dataset_id=request.args.get("dataset_id") or None,
agent_id=request.args.get("agent_id") or None,
language=rbac_language(),
),
)
@console_ns.route("/workspaces/current/rbac/members/<uuid:member_id>/rbac-roles")
class RBACMemberRolesApi(Resource):
@console_account_admission()
@console_ns.doc(params=query_params_from_model(_AccessControlLanguageQuery))
@console_ns.response(200, "Success", console_ns.models[dto.MemberRolesResponse.__name__])
def get(self, context: RequestContext, member_id):
return dump_response(
dto.MemberRolesResponse,
application_services().rbac.members.get(context, str(member_id), language=rbac_language()),
)
@console_account_admission()
@console_ns.expect(console_ns.models[_ReplaceMemberRolesRequest.__name__])
@console_ns.response(200, "Success", console_ns.models[dto.MemberRolesResponse.__name__])
def put(self, context: RequestContext, member_id):
request = _ReplaceMemberRolesRequest.model_validate(console_ns.payload or {})
try:
result = application_services().rbac.members.replace(
context, str(member_id), role_ids=list(request.role_ids), language=rbac_language()
)
except NoPermissionError as error:
raise Forbidden(str(error)) from error
except AccountNotFoundError as error:
raise InvalidArgumentError(description="Member not in tenant.") from error
except (
CannotOperateSelfError,
InvalidWorkspaceMemberRoleError,
MemberNotInTenantError,
RoleAlreadyAssignedError,
) as error:
raise InvalidArgumentError(description=str(error)) from error
return dump_response(dto.MemberRolesResponse, result)
@@ -0,0 +1,114 @@
"""Console RBAC policies endpoints."""
from flask import request
from flask_restx import Resource
from controllers.common.fields import SimpleResultResponse
from controllers.common.rbac import RBACCheck, Workspace, rbac_language
from controllers.console import console_ns
from controllers.console.flask_admission import console_account_admission
from controllers.console.workspace.rbac.schemas import (
_AccessPolicyCreateRequest,
_AccessPolicyList,
_AccessPolicyUpdateRequest,
pagination_options,
)
from controllers.console.wraps import RBACPermission
from extensions.ext_application_services import application_services
from libs.helper import dump_response
from machinery.context import RequestContext
from services.rbac import contracts as dto
@console_ns.route("/workspaces/current/rbac/access-policies")
class RBACAccessPoliciesApi(Resource):
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.response(200, "Success", console_ns.models[_AccessPolicyList.__name__])
def get(self, context: RequestContext):
resource_type = request.args.get("resource_type") or None
return dump_response(
_AccessPolicyList,
application_services().rbac.policies.list(
context, resource_type=resource_type, options=pagination_options(), language=rbac_language()
),
)
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.expect(console_ns.models[_AccessPolicyCreateRequest.__name__])
@console_ns.response(201, "Policy created", console_ns.models[dto.AccessPolicy.__name__])
def post(self, context: RequestContext):
request = _AccessPolicyCreateRequest.model_validate(console_ns.payload or {})
policy = application_services().rbac.policies.create(
context,
dto.AccessPolicyCreate(
name=request.name,
resource_type=request.resource_type,
description=request.description,
permission_keys=list(request.permission_keys),
),
language=rbac_language(),
)
return (dump_response(dto.AccessPolicy, policy), 201)
@console_ns.route("/workspaces/current/rbac/access-policies/<uuid:policy_id>")
class RBACAccessPolicyItemApi(Resource):
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.response(200, "Success", console_ns.models[dto.AccessPolicy.__name__])
def get(self, context: RequestContext, policy_id):
return dump_response(
dto.AccessPolicy,
application_services().rbac.policies.get(context, str(policy_id), language=rbac_language()),
)
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.expect(console_ns.models[_AccessPolicyUpdateRequest.__name__])
@console_ns.response(200, "Success", console_ns.models[dto.AccessPolicy.__name__])
def put(self, context: RequestContext, policy_id):
request = _AccessPolicyUpdateRequest.model_validate(console_ns.payload or {})
policy = application_services().rbac.policies.update(
context,
str(policy_id),
dto.AccessPolicyUpdate(
name=request.name, description=request.description, permission_keys=list(request.permission_keys)
),
language=rbac_language(),
)
return dump_response(dto.AccessPolicy, policy)
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.response(200, "Success", console_ns.models[SimpleResultResponse.__name__])
def delete(self, context: RequestContext, policy_id):
application_services().rbac.policies.delete(context, str(policy_id), language=rbac_language())
return dump_response(SimpleResultResponse, {"result": "success"})
@console_ns.route("/workspaces/current/rbac/access-policies/<uuid:policy_id>/copy")
class RBACAccessPolicyCopyApi(Resource):
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.response(201, "Policy copied", console_ns.models[dto.AccessPolicy.__name__])
def post(self, context: RequestContext, policy_id):
policy = application_services().rbac.policies.copy(context, str(policy_id), language=rbac_language())
return (dump_response(dto.AccessPolicy, policy), 201)
@console_ns.route("/workspaces/current/rbac/access-policy-bindings/<uuid:binding_id>/lock")
class RBACAccessPolicyBindingLockApi(Resource):
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.response(200, "Success", console_ns.models[dto.AccessPolicyBindingState.__name__])
def put(self, context: RequestContext, binding_id):
return dump_response(
dto.AccessPolicyBindingState,
application_services().rbac.policies.lock(context, str(binding_id), language=rbac_language()),
)
@console_ns.route("/workspaces/current/rbac/access-policy-bindings/<uuid:binding_id>/unlock")
class RBACAccessPolicyBindingUnlockApi(Resource):
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.response(200, "Success", console_ns.models[dto.AccessPolicyBindingState.__name__])
def put(self, context: RequestContext, binding_id):
return dump_response(
dto.AccessPolicyBindingState,
application_services().rbac.policies.unlock(context, str(binding_id), language=rbac_language()),
)
@@ -0,0 +1,306 @@
"""Console RBAC resources endpoints."""
from collections.abc import Mapping
from dataclasses import dataclass
from flask_restx import Resource
from pydantic import BaseModel
from controllers.common.fields import SimpleResultResponse
from controllers.common.rbac import rbac_language
from controllers.common.schema import query_params_from_model
from controllers.console import console_ns
from controllers.console.flask_admission import console_account_admission
from controllers.console.workspace.rbac.schemas import (
_AccessControlLanguageQuery,
_DeleteMemberBindingsRequest,
_ReplaceBindingsRequest,
_ResourceAccessScopeRequest,
_ResourceUserAccessPoliciesQuery,
_WorkspaceMatrixQuery,
pagination_options,
)
from extensions.ext_application_services import application_services
from libs.helper import dump_response
from machinery.context import RequestContext
from services.rbac import contracts as dto
@dataclass(frozen=True)
class _ResourceAccessRoutes:
resource_type: dto.RBACResourceType
class_prefix: str
matrix_model: type[BaseModel]
@property
def url_segment(self) -> str:
return self.resource_type.route.segment
@property
def id_param(self) -> str:
return self.resource_type.route.id_param
@dataclass(frozen=True)
class _ResourceAccessApis:
catalog: type[Resource]
matrix: type[Resource]
whitelist: type[Resource]
whitelist_config: type[Resource]
user_access_policies: type[Resource]
user_access_policy_assignment: type[Resource]
role_bindings: type[Resource]
member_bindings: type[Resource]
workspace_matrix: type[Resource]
workspace_role_bindings: type[Resource]
workspace_bindings: type[Resource]
workspace_member_bindings: type[Resource]
_RESOURCE_ACCESS_ROUTES = (
_ResourceAccessRoutes(dto.RBACResourceType.APP, "App", dto.AppAccessMatrix),
_ResourceAccessRoutes(dto.RBACResourceType.DATASET, "Dataset", dto.DatasetAccessMatrix),
_ResourceAccessRoutes(dto.RBACResourceType.AGENT, "Agent", dto.AgentAccessMatrix),
)
def _build_resource_access_apis(spec: _ResourceAccessRoutes) -> _ResourceAccessApis:
id_param = spec.id_param
resource_prefix = f"/workspaces/current/rbac/{spec.url_segment}/<uuid:{id_param}>"
workspace_prefix = f"/workspaces/current/rbac/workspace/{spec.url_segment}"
def resource_id(path_params: Mapping[str, object]) -> str:
return str(path_params[id_param])
def register(resource: type[Resource], name: str, url: str) -> type[Resource]:
resource.__name__ = name
resource.__qualname__ = name
console_ns.route(url)(resource)
return resource
class CatalogApi(Resource):
@console_account_admission()
@console_ns.response(200, "Success", console_ns.models[dto.PermissionCatalogResponse.__name__])
def get(self, context: RequestContext):
return dump_response(
dto.PermissionCatalogResponse,
application_services().rbac.resources.catalog(context, spec.resource_type, language=rbac_language()),
)
class MatrixApi(Resource):
@console_account_admission()
@console_ns.doc(params=query_params_from_model(_AccessControlLanguageQuery))
@console_ns.response(200, "Success", console_ns.models[spec.matrix_model.__name__])
def get(self, context: RequestContext, **path_params):
result = application_services().rbac.resources.matrix(
context, spec.resource_type, resource_id(path_params), language=rbac_language()
)
return dump_response(spec.matrix_model, result)
class WhitelistApi(Resource):
@console_account_admission()
@console_ns.response(200, "Success", console_ns.models[dto.ResourceWhitelist.__name__])
def get(self, context: RequestContext, **path_params):
return dump_response(
dto.ResourceWhitelist,
application_services().rbac.resources.whitelist(
context, spec.resource_type, resource_id(path_params), language=rbac_language()
),
)
@console_account_admission()
@console_ns.expect(console_ns.models[_ResourceAccessScopeRequest.__name__])
@console_ns.response(200, "Success", console_ns.models[dto.ResourceWhitelist.__name__])
def put(self, context: RequestContext, **path_params):
target_id = resource_id(path_params)
scope = _ResourceAccessScopeRequest.model_validate(console_ns.payload or {})
result = application_services().rbac.resources.replace_whitelist(
context,
spec.resource_type,
target_id,
dto.ReplaceMemberBindings(
automatic_include_workspace_members=scope.automatic_include_workspace_members
),
language=rbac_language(),
)
return dump_response(dto.ResourceWhitelist, result)
class WhitelistConfigApi(Resource):
@console_account_admission()
@console_ns.response(200, "Success", console_ns.models[dto.ResourceWhitelistConfig.__name__])
def get(self, context: RequestContext, **path_params):
return dump_response(
dto.ResourceWhitelistConfig,
application_services().rbac.resources.whitelist_config(
context, spec.resource_type, resource_id(path_params), language=rbac_language()
),
)
class UserAccessPoliciesApi(Resource):
@console_account_admission()
@console_ns.doc(params=query_params_from_model(_ResourceUserAccessPoliciesQuery))
@console_ns.response(200, "Success", console_ns.models[dto.ResourceUserAccessPoliciesResponse.__name__])
def get(self, context: RequestContext, **path_params):
target_id = resource_id(path_params)
options = pagination_options()
result = application_services().rbac.resources.user_access_policies(
context, spec.resource_type, target_id, options=options, language=rbac_language()
)
return dump_response(dto.ResourceUserAccessPoliciesResponse, result)
class UserAccessPolicyAssignmentApi(Resource):
@console_account_admission()
@console_ns.expect(console_ns.models[dto.ReplaceUserAccessPolicies.__name__])
@console_ns.response(200, "Success", console_ns.models[dto.ReplaceUserAccessPoliciesResponse.__name__])
def put(self, context: RequestContext, target_account_id, **path_params):
payload = dto.ReplaceUserAccessPolicies.model_validate(console_ns.payload or {})
return dump_response(
dto.ReplaceUserAccessPoliciesResponse,
application_services().rbac.resources.replace_user_access_policies(
context,
spec.resource_type,
resource_id(path_params),
str(target_account_id),
payload,
language=rbac_language(),
),
)
class RoleBindingsApi(Resource):
@console_account_admission()
@console_ns.response(200, "Success", console_ns.models[dto.RoleBindingsResponse.__name__])
def get(self, context: RequestContext, policy_id, **path_params):
return dump_response(
dto.RoleBindingsResponse,
application_services().rbac.resources.list_role_bindings(
context, spec.resource_type, resource_id(path_params), str(policy_id), language=rbac_language()
),
)
class MemberBindingsApi(Resource):
@console_account_admission()
@console_ns.response(200, "Success", console_ns.models[dto.MemberBindingsResponse.__name__])
def get(self, context: RequestContext, policy_id, **path_params):
return dump_response(
dto.MemberBindingsResponse,
application_services().rbac.resources.list_member_bindings(
context, spec.resource_type, resource_id(path_params), str(policy_id), language=rbac_language()
),
)
@console_account_admission()
@console_ns.expect(console_ns.models[_DeleteMemberBindingsRequest.__name__])
@console_ns.response(200, "Success", console_ns.models[SimpleResultResponse.__name__])
def delete(self, context: RequestContext, policy_id, **path_params):
body = _DeleteMemberBindingsRequest.model_validate(console_ns.payload or {})
application_services().rbac.resources.delete_member_bindings(
context,
spec.resource_type,
resource_id(path_params),
str(policy_id),
dto.DeleteMemberBindings(account_ids=body.account_ids),
language=rbac_language(),
)
return dump_response(SimpleResultResponse, {"result": "success"})
class WorkspaceMatrixApi(Resource):
@console_ns.doc(params=query_params_from_model(_WorkspaceMatrixQuery))
@console_account_admission()
@console_ns.response(200, "Success", console_ns.models[dto.WorkspaceAccessMatrix.__name__])
def get(self, context: RequestContext):
result = application_services().rbac.resources.workspace_matrix(
context, spec.resource_type, pagination_options(), language=rbac_language()
)
return dump_response(dto.WorkspaceAccessMatrix, result)
class WorkspaceRoleBindingsApi(Resource):
@console_account_admission()
@console_ns.response(200, "Success", console_ns.models[dto.RoleBindingsResponse.__name__])
def get(self, context: RequestContext, policy_id):
return dump_response(
dto.RoleBindingsResponse,
application_services().rbac.resources.workspace_role_bindings(
context, spec.resource_type, str(policy_id), language=rbac_language()
),
)
class WorkspaceBindingsApi(Resource):
@console_account_admission()
@console_ns.expect(console_ns.models[_ReplaceBindingsRequest.__name__])
@console_ns.response(200, "Success", console_ns.models[dto.AccessMatrixItem.__name__])
def put(self, context: RequestContext, policy_id):
body = _ReplaceBindingsRequest.model_validate(console_ns.payload or {})
return dump_response(
dto.AccessMatrixItem,
application_services().rbac.resources.replace_workspace_bindings(
context,
spec.resource_type,
str(policy_id),
dto.ReplaceBindings(role_ids=list(body.role_ids), account_ids=list(body.account_ids)),
language=rbac_language(),
),
)
class WorkspaceMemberBindingsApi(Resource):
@console_account_admission()
@console_ns.response(200, "Success", console_ns.models[dto.MemberBindingsResponse.__name__])
def get(self, context: RequestContext, policy_id):
return dump_response(
dto.MemberBindingsResponse,
application_services().rbac.resources.workspace_member_bindings(
context, spec.resource_type, str(policy_id), language=rbac_language()
),
)
prefix = spec.class_prefix
return _ResourceAccessApis(
catalog=register(
CatalogApi,
f"RBAC{prefix}CatalogApi",
f"/workspaces/current/rbac/role-permissions/catalog/{spec.resource_type.value}",
),
matrix=register(MatrixApi, f"RBAC{prefix}MatrixApi", f"{resource_prefix}/access-policy"),
whitelist=register(WhitelistApi, f"RBAC{prefix}WhitelistApi", f"{resource_prefix}/whitelist"),
whitelist_config=register(
WhitelistConfigApi, f"RBAC{prefix}WhitelistConfigApi", f"{resource_prefix}/whitelist_config"
),
user_access_policies=register(
UserAccessPoliciesApi, f"RBAC{prefix}UserAccessPoliciesApi", f"{resource_prefix}/user-access-policies"
),
user_access_policy_assignment=register(
UserAccessPolicyAssignmentApi,
f"RBAC{prefix}UserAccessPolicyAssignmentApi",
f"{resource_prefix}/users/<uuid:target_account_id>/access-policies",
),
role_bindings=register(
RoleBindingsApi,
f"RBAC{prefix}RoleBindingsApi",
f"{resource_prefix}/access-policies/<uuid:policy_id>/role-bindings",
),
member_bindings=register(
MemberBindingsApi,
f"RBAC{prefix}MemberBindingsApi",
f"{resource_prefix}/access-policies/<string:policy_id>/member-bindings",
),
workspace_matrix=register(
WorkspaceMatrixApi, f"RBACWorkspace{prefix}MatrixApi", f"{workspace_prefix}/access-policy"
),
workspace_role_bindings=register(
WorkspaceRoleBindingsApi,
f"RBACWorkspace{prefix}RoleBindingsApi",
f"{workspace_prefix}/access-policies/<uuid:policy_id>/role-bindings",
),
workspace_bindings=register(
WorkspaceBindingsApi,
f"RBACWorkspace{prefix}BindingsApi",
f"{workspace_prefix}/access-policies/<uuid:policy_id>/bindings",
),
workspace_member_bindings=register(
WorkspaceMemberBindingsApi,
f"RBACWorkspace{prefix}MemberBindingsApi",
f"{workspace_prefix}/access-policies/<uuid:policy_id>/member-bindings",
),
)
_RESOURCE_ACCESS_APIS = {spec.resource_type: _build_resource_access_apis(spec) for spec in _RESOURCE_ACCESS_ROUTES}
@@ -0,0 +1,123 @@
"""Console RBAC roles endpoints."""
from flask import request
from flask_restx import Resource
from controllers.common.fields import SimpleResultResponse
from controllers.common.rbac import RBACCheck, Workspace, rbac_language
from controllers.common.schema import query_params_from_model
from controllers.console import console_ns
from controllers.console.flask_admission import console_account_admission
from controllers.console.workspace.rbac.schemas import (
CopyRoleParam,
_AccessControlLanguageQuery,
_MembersInRoleList,
_PaginationQuery,
_RBACRoleList,
_RolesListQuery,
_RoleUpsertRequest,
pagination_options,
)
from controllers.console.wraps import RBACPermission
from extensions.ext_application_services import application_services
from libs.helper import dump_response
from machinery.context import RequestContext
from services.rbac import contracts as dto
@console_ns.route("/workspaces/current/rbac/role-permissions/catalog")
class RBACWorkspaceCatalogApi(Resource):
@console_account_admission()
@console_ns.response(200, "Success", console_ns.models[dto.PermissionCatalogResponse.__name__])
def get(self, context: RequestContext):
return dump_response(
dto.PermissionCatalogResponse, application_services().rbac.roles.catalog(context, language=rbac_language())
)
@console_ns.route("/workspaces/current/rbac/roles")
class RBACRolesApi(Resource):
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.doc(
params={
**query_params_from_model(_RolesListQuery),
**query_params_from_model(_AccessControlLanguageQuery),
}
)
@console_ns.response(200, "Success", console_ns.models[_RBACRoleList.__name__])
def get(self, context: RequestContext):
req_data = _RolesListQuery.model_validate(request.args.to_dict(flat=True))
result = application_services().rbac.roles.list(
context, options=req_data.to_inner_options(), include_owner=req_data.include_owner, language=rbac_language()
)
return dump_response(_RBACRoleList, result)
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.doc(params=query_params_from_model(_AccessControlLanguageQuery))
@console_ns.expect(console_ns.models[_RoleUpsertRequest.__name__])
@console_ns.response(201, "Role created", console_ns.models[dto.RBACRole.__name__])
def post(self, context: RequestContext):
request = _RoleUpsertRequest.model_validate(console_ns.payload or {})
role = application_services().rbac.roles.create(context, request.to_mutation(), language=rbac_language())
return (dump_response(dto.RBACRole, role), 201)
@console_ns.route("/workspaces/current/rbac/roles/<uuid:role_id>")
class RBACRoleItemApi(Resource):
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.doc(params=query_params_from_model(_AccessControlLanguageQuery))
@console_ns.response(200, "Success", console_ns.models[dto.RBACRole.__name__])
def get(self, context: RequestContext, role_id):
return dump_response(
dto.RBACRole, application_services().rbac.roles.get(context, str(role_id), language=rbac_language())
)
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.doc(params=query_params_from_model(_AccessControlLanguageQuery))
@console_ns.expect(console_ns.models[_RoleUpsertRequest.__name__])
@console_ns.response(200, "Success", console_ns.models[dto.RBACRole.__name__])
def put(self, context: RequestContext, role_id):
request = _RoleUpsertRequest.model_validate(console_ns.payload or {})
role = application_services().rbac.roles.update(
context, str(role_id), request.to_mutation(), language=rbac_language()
)
return dump_response(dto.RBACRole, role)
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.response(200, "Success", console_ns.models[SimpleResultResponse.__name__])
def delete(self, context: RequestContext, role_id):
application_services().rbac.roles.delete(context, str(role_id), language=rbac_language())
return dump_response(SimpleResultResponse, {"result": "success"})
@console_ns.route("/workspaces/current/rbac/roles/<uuid:role_id>/copy")
class RBACRoleCopyApi(Resource):
@console_account_admission(rbac_checks=[RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())])
@console_ns.doc(params=query_params_from_model(_AccessControlLanguageQuery))
@console_ns.expect(console_ns.models[CopyRoleParam.__name__])
@console_ns.response(201, "Role copied", console_ns.models[dto.RBACRole.__name__])
def post(self, context: RequestContext, role_id):
request = CopyRoleParam.model_validate(console_ns.payload or {})
role = application_services().rbac.roles.copy(
context, str(role_id), copy_member=request.copy_member, language=rbac_language()
)
return (dump_response(dto.RBACRole, role), 201)
@console_ns.route("/workspaces/current/rbac/roles/<uuid:role_id>/members")
class ListMembersByRole(Resource):
@console_account_admission()
@console_ns.doc(
params={
**query_params_from_model(_PaginationQuery),
**query_params_from_model(_AccessControlLanguageQuery),
}
)
@console_ns.response(200, "Success", console_ns.models[_MembersInRoleList.__name__])
def get(self, context: RequestContext, role_id):
return dump_response(
_MembersInRoleList,
application_services().rbac.roles.list_members_by_role(
context, role_id=str(role_id), options=pagination_options(), language=rbac_language()
),
)
@@ -0,0 +1,167 @@
"""HTTP payloads, pagination aliases and response schemas for workspace RBAC."""
from typing import Any, Literal
from flask import request
from pydantic import AliasChoices, BaseModel, ConfigDict, Field, field_validator
from controllers.common.schema import register_response_schema_models, register_schema_models
from controllers.console import console_ns
from services.rbac import contracts as dto
class _RBACRoleList(dto.Paginated[dto.RBACRole]):
pass
class _AccessPolicyList(dto.Paginated[dto.AccessPolicy]):
pass
class _MembersInRoleList(dto.Paginated[dto.MembersInRole]):
pass
register_response_schema_models(
console_ns,
dto.PermissionCatalogResponse,
dto.RBACRole,
_RBACRoleList,
_MembersInRoleList,
dto.AccessPolicy,
_AccessPolicyList,
dto.AccessPolicyBindingState,
dto.MyPermissionsResponse,
dto.AppAccessMatrix,
dto.DatasetAccessMatrix,
dto.AgentAccessMatrix,
dto.WorkspaceAccessMatrix,
dto.ResourceWhitelist,
dto.ResourceWhitelistConfig,
dto.ResourceUserAccessPoliciesResponse,
dto.ReplaceUserAccessPoliciesResponse,
dto.RoleBindingsResponse,
dto.MemberBindingsResponse,
dto.MemberRolesResponse,
dto.AccessMatrixItem,
)
class _PaginationQuery(BaseModel):
model_config = ConfigDict(extra="ignore")
page_number: int | None = Field(default=None, ge=1, validation_alias=AliasChoices("page", "page_number"))
results_per_page: int | None = Field(
default=None, ge=1, le=99999, validation_alias=AliasChoices("limit", "results_per_page")
)
reverse: bool | None = None
def to_inner_options(self) -> dto.ListOption:
return dto.ListOption.model_validate(self.model_dump())
class _RolesListQuery(_PaginationQuery):
include_owner: int = Field(default=0, ge=0, le=1)
class CopyRoleParam(BaseModel):
copy_member: bool = True
class _RoleUpsertRequest(BaseModel):
"""Accepts the payload sent by the Create/Edit Role dialog."""
name: str
description: str = ""
permission_keys: list[str] = []
def to_mutation(self) -> dto.RoleMutation:
return dto.RoleMutation(
name=self.name,
description=self.description,
permission_keys=list(self.permission_keys),
)
class _AccessPolicyCreateRequest(BaseModel):
name: str
resource_type: dto.RBACResourceType
description: str = ""
permission_keys: list[str] = []
class _AccessPolicyUpdateRequest(BaseModel):
name: str
description: str = ""
permission_keys: list[str] = []
register_schema_models(console_ns, _AccessPolicyCreateRequest, _AccessPolicyUpdateRequest)
class _ResourceAccessScopeRequest(BaseModel):
automatic_include_workspace_members: bool
class _ReplaceBindingsRequest(BaseModel):
role_ids: list[str] = Field(default_factory=list)
account_ids: list[str] = Field(default_factory=list)
@field_validator("role_ids", "account_ids", mode="before")
@classmethod
def _coerce_bindings(cls, value: Any) -> list[str]:
if value is None:
return []
return value
class _DeleteMemberBindingsRequest(BaseModel):
account_ids: list[str] = Field(default_factory=list)
@field_validator("account_ids", mode="before")
@classmethod
def _coerce_account_ids(cls, value: Any) -> list[str]:
if value is None:
return []
return value
class _AccessControlLanguageQuery(BaseModel):
language: Literal["en", "ja", "zh"] | None = Field(default=None, description="Localized policy label language")
class _WorkspaceMatrixQuery(_PaginationQuery, _AccessControlLanguageQuery):
pass
class _ResourceUserAccessPoliciesQuery(_PaginationQuery):
language: Literal["en", "ja", "zh"] | None = Field(default=None, description="Localized policy label language")
register_schema_models(
console_ns,
_ResourceAccessScopeRequest,
_ReplaceBindingsRequest,
_DeleteMemberBindingsRequest,
_AccessControlLanguageQuery,
_ResourceUserAccessPoliciesQuery,
dto.ReplaceUserAccessPolicies,
)
class _ReplaceMemberRolesRequest(BaseModel):
role_ids: list[str] = []
@field_validator("role_ids", mode="before")
@classmethod
def _coerce_role_ids(cls, value: Any) -> list[str]:
if value is None:
return []
return value
register_schema_models(console_ns, _ReplaceMemberRolesRequest, _RoleUpsertRequest, CopyRoleParam)
def pagination_options() -> dto.ListOption:
return _PaginationQuery.model_validate(request.args.to_dict(flat=True)).to_inner_options()