UnisKB/apps/system_manage/platform_access.py

351 lines
19 KiB
Python

"""Additive authorization: public + enabled roles + individual grants.
The legacy permission table remains an independent source. New grants are never
materialized into it, so revocation cannot erase an owner's existing access.
"""
from django.core.exceptions import ValidationError as DjangoValidationError
import re
from django.db.models import Q
from django.db import transaction
from django.utils import timezone
from rest_framework.exceptions import PermissionDenied, ValidationError
from system_manage.models.platform_access import PlatformRole, PlatformRoleMember, PlatformGrant
MODULES = {'application': 'AI应用', 'mindmap': '思维导图', 'knowledge': '知识库', 'tool': '工具管理', 'model': '模型管理'}
FEATURES = {'document_parse': '文档解析'}
ACTIONS = {'VIEW': '查看', 'USE': '使用', 'EDIT': '编辑', 'AUTHORIZE': '授权'}
DEFAULT_ROLE_ID = '00000000-0000-0000-0000-000000000001'
ADMIN_ROLE_ID = '00000000-0000-0000-0000-000000000002'
BUILTIN_ADMIN_USER_ID = 'f0dd8f71-e4ee-11ee-8c84-a8a1595801ab'
def is_admin(user):
return PlatformRoleMember.objects.filter(user_id=user.id, role_id=ADMIN_ROLE_ID, role__enabled=True).exists()
@transaction.atomic
def reconcile_builtin_roles():
"""One-time upgrade: import existing administrators without changing grants.
Safe to repeat; only the initial creation imports legacy account types.
After that memberships are authoritative, including after demotion.
"""
from users.models import User
PlatformRole.objects.get_or_create(id=DEFAULT_ROLE_ID, defaults={
'name': '普通用户', 'description': '新激活用户自动关联', 'is_default': True,
'modules': ['knowledge', 'mindmap']})
admin_role, created = PlatformRole.objects.get_or_create(id=ADMIN_ROLE_ID, defaults={
'name': '系统管理员', 'description': '拥有全部平台管理权限', 'modules': list(MODULES)})
if created:
PlatformRoleMember.objects.bulk_create([
PlatformRoleMember(role=admin_role, user_id=pk)
for pk in User.objects.filter(role='ADMIN').values_list('id', flat=True)
], ignore_conflicts=True)
return {'admin_role_created': created,
'admin_members': PlatformRoleMember.objects.filter(role=admin_role).count()}
def _sync_legacy_role(user, operator_id=None):
"""Keep old integrations as projections of the unified memberships."""
from users.models import UserRoleAssignment
from users.serializers.user_manage_ext import invalidate_user_auth_cache
from users.serializers.user import update_user_role
role = 'ADMIN' if is_admin(user) else 'USER'
user.role = role
user.save(update_fields=['role', 'update_time'])
UserRoleAssignment.objects.filter(user_id=user.id, workspace_id='default', role_id__in=['ADMIN', 'USER']).delete()
UserRoleAssignment.objects.create(user_id=user.id, role_id=role, workspace_id='default', granted_by_id=operator_id)
if str(user.id) != BUILTIN_ADMIN_USER_ID:
update_user_role({'role_setting': [{'role_id': role, 'workspace_ids': ['None' if role == 'ADMIN' else 'default']}]}, user, operator_id)
# Clear immediately for callers in this transaction and again after commit
# to avoid another request repopulating caches with the previous state.
invalidate_user_auth_cache(user.id)
transaction.on_commit(lambda: invalidate_user_auth_cache(user.id))
@transaction.atomic
def assign_roles(user_id, role_ids, operator_id=None):
from users.models import User
# All membership writers lock this row first, including bulk role editing.
PlatformRole.objects.select_for_update().get(pk=ADMIN_ROLE_ID)
user = User.objects.select_for_update().get(pk=user_id)
ids = {str(pk) for pk in role_ids} | {DEFAULT_ROLE_ID}
roles = list(PlatformRole.objects.select_for_update().filter(pk__in=ids).order_by('id'))
if len(roles) != len(ids):
raise ValidationError('角色不存在')
if str(user.id) == BUILTIN_ADMIN_USER_ID and ADMIN_ROLE_ID not in ids:
raise ValidationError('不能移除内置管理员角色')
if is_admin(user) and ADMIN_ROLE_ID not in ids and not PlatformRoleMember.objects.filter(
role_id=ADMIN_ROLE_ID, user__is_active=True).exclude(user_id=user.id).exists():
raise ValidationError('至少保留一名启用的系统管理员')
PlatformRoleMember.objects.filter(user=user).exclude(role_id__in=ids).delete()
existing = {str(pk) for pk in user.platform_roles.values_list('role_id', flat=True)}
PlatformRoleMember.objects.bulk_create([PlatformRoleMember(user=user, role_id=pk) for pk in ids - existing])
_sync_legacy_role(user, operator_id)
return user
def assign_legacy_role(user, role_id, operator_id=None):
"""Adapter for registration and older clients; preserves custom roles."""
if role_id not in ('ADMIN', 'USER'):
raise ValidationError('角色不合法')
ids = {str(pk) for pk in user.platform_roles.values_list('role_id', flat=True)}
ids.discard(ADMIN_ROLE_ID)
if role_id == 'ADMIN':
ids.add(ADMIN_ROLE_ID)
return assign_roles(user.id, ids, operator_id)
def require_admin(user):
if not is_admin(user):
raise PermissionDenied('仅管理员可管理角色和授权')
def roles_for(user):
return PlatformRole.objects.filter(enabled=True).filter(Q(is_default=True) | Q(members__user_id=user.id)).distinct()
def grants_for(user):
if not user.is_active:
return PlatformGrant.objects.none()
role_ids = [str(pk) for pk in roles_for(user).values_list('id', flat=True)]
return PlatformGrant.objects.filter(workspace_id='default').exclude(resource_type='FEATURE').filter(
Q(expires_at__isnull=True) | Q(expires_at__gt=timezone.now())
).filter(Q(subject_type='ALL') | Q(subject_type='USER', subject_id=str(user.id)) |
Q(subject_type='ROLE', subject_id__in=role_ids))
def expand_actions(actions):
result = set(actions)
if 'EDIT' in result:
result |= {'VIEW', 'USE'}
if 'USE' in result or 'AUTHORIZE' in result:
result.add('VIEW')
return result
def resource_actions(user, resource_type, target, workspace='default'):
if not user.is_active or workspace != 'default':
return set()
if is_admin(user):
return set(ACTIONS)
actions = set()
for grant in grants_for(user).filter(resource_type=resource_type, target=str(target)):
actions.update(grant.actions)
return expand_actions(actions)
def module_list(user):
from system_manage.models import UserMenuSetting
if is_admin(user):
return list(MODULES)
result = set()
for role in roles_for(user):
result.update(role.modules)
# Preserve explicit legacy user menus; no implicit fallback grants once roles exist.
setting = UserMenuSetting.objects.filter(user_id=user.id).first()
if setting:
result.update(setting.menu_list or [])
for grant in grants_for(user).filter(resource_type='MODULE'):
if 'VIEW' in expand_actions(grant.actions):
result.add(grant.target)
return [key for key in MODULES if key in result]
def check_feature_request(request, user):
"""Backend counterpart to menu visibility for business write operations.
Read endpoints remain available for cross-module resource selectors; their
existing resource permission checks still apply.
"""
if is_admin(user) or request.method in ('GET', 'HEAD', 'OPTIONS'):
return
match = re.search(r'/workspace/default/(knowledge|application|tool|model)(?:/|$)', request.path)
if match and match.group(1) not in module_list(user):
from common.exception.app_exception import AppUnauthorizedFailed
raise AppUnauthorizedFailed(403, '未授权使用该功能')
def permission_strings(user):
"""Expand new grants to the original endpoint permission vocabulary.
Do not emit bare resource markers: legacy endpoints treat those as full
management. AUTHORIZE is separate from EDIT.
"""
from common.constants.permission_constants import (PermissionConstants, Resource,
ResourcePermission, ResourcePermissionGroup, get_permission_list_by_resource_group)
result = set()
for grant in grants_for(user).exclude(resource_type='MODULE'):
if grant.resource_type not in ('KNOWLEDGE', 'APPLICATION', 'TOOL', 'MODEL'):
continue
actions = expand_actions(grant.actions)
scope = f':/WORKSPACE/default/{grant.resource_type}/{grant.target}'
for level in ('VIEW', 'MANAGE'):
if level == 'VIEW' and 'VIEW' not in actions:
continue
if level == 'MANAGE' and 'EDIT' not in actions:
continue
group = ResourcePermissionGroup(Resource(grant.resource_type), ResourcePermission(level))
for permission in get_permission_list_by_resource_group(group):
name = str(permission)
# Member/grant management requires AUTHORIZE, even for editors.
if any(part in name for part in ('WORKSPACE_USER_RESOURCE_PERMISSION', '+AUTH', '+ADD_MEMBER', '+REMOVE_MEMBER')):
continue
result.add(name + scope)
if 'AUTHORIZE' in actions:
for permission in PermissionConstants:
name = str(permission.value)
if name.startswith(grant.resource_type + '_WORKSPACE_USER_RESOURCE_PERMISSION:') or name.startswith(grant.resource_type + ':READ+AUTH'):
result.add(name + scope)
return result
def resource_models():
from application.models import Application
from knowledge.models import Knowledge
from tools.models import Tool
from models_provider.models import Model
from system_manage.models.ai_hub import AIParserResource, AIService
return {'KNOWLEDGE': Knowledge, 'APPLICATION': Application, 'TOOL': Tool,
'MODEL': Model, 'PARSER': AIParserResource, 'SERVICE': AIService}
def catalog():
resources = []
for kind, model in resource_models().items():
fields = ['id', 'name'] + (['provider', 'model_type'] if kind == 'MODEL' else [])
for item in model.objects.filter(workspace_id='default').values(*fields).order_by('name'):
resources.append({**item, 'id': str(item['id']), 'resource_type': kind})
return resources
def validate_target(resource_type, target):
if resource_type == 'MODULE':
if target not in MODULES:
raise ValidationError('功能无效')
elif resource_type == 'FEATURE':
if target not in FEATURES:
raise ValidationError('功能无效')
else:
model = resource_models().get(resource_type)
try:
valid = model is not None and model.objects.filter(pk=target, workspace_id='default').exists()
except (ValueError, TypeError, DjangoValidationError):
valid = False
if not valid:
raise ValidationError('资源不存在')
def effective_detail(user):
"""Explain every source; legacy entries remain identifiable and revocable."""
from system_manage.models import WorkspaceUserResourcePermission, UserMenuSetting
role_names = {str(r.id): r.name for r in roles_for(user)}
rows = []
for grant in grants_for(user):
rows.append({'resource_type': grant.resource_type, 'target': grant.target,
'actions': sorted(expand_actions(grant.actions)),
'source': '所有用户' if grant.subject_type == 'ALL' else (
role_names.get(grant.subject_id, '角色') if grant.subject_type == 'ROLE' else '单独授权'),
'expires_at': grant.expires_at})
for role in roles_for(user):
rows.extend({'resource_type': 'MODULE', 'target': module, 'actions': ['VIEW'], 'source': role.name}
for module in role.modules)
legacy_menu = UserMenuSetting.objects.filter(user_id=user.id).first()
if legacy_menu:
rows.extend({'resource_type': 'MODULE', 'target': m, 'actions': ['VIEW'], 'source': '原用户菜单授权'} for m in legacy_menu.menu_list)
for grant in WorkspaceUserResourcePermission.objects.filter(user_id=user.id, workspace_id='default'):
actions = ['VIEW', 'USE'] if 'VIEW' in grant.permission_list else []
if 'MANAGE' in grant.permission_list or 'ROLE' in grant.permission_list:
actions = list(ACTIONS)
rows.append({'resource_type': grant.auth_target_type, 'target': grant.target, 'actions': actions, 'source': '原用户资源授权'})
for row in authorization_rows():
if row.get('readonly') and ((row['subject_type'] == 'ROLE' and row['subject_id'] in role_names) or (row['subject_type'] == 'USER' and row['subject_id'] == str(user.id))):
rows.append({**row, 'source': role_names.get(row['subject_id'], '原用户菜单授权') + '(菜单附带)'})
for kind in ('PARSER', 'SERVICE'):
model = resource_models()[kind]
for obj in model.objects.filter(workspace_id='default').filter(Q(owner_id=user.id) | Q(allowed_users__contains=[str(user.id)])):
owner = str(obj.owner_id) == str(user.id)
rows.append({'resource_type': kind, 'target': str(obj.id), 'actions': list(ACTIONS) if owner else ['VIEW', 'USE'],
'source': '资源所有者' if owner else '原用户资源授权'})
return {'modules': module_list(user), 'roles': [{'id': k, 'name': v} for k, v in role_names.items()],
'permissions': rows, 'is_admin': is_admin(user)}
def authorization_rows():
"""Expose compatibility grants in the same management list, without migration."""
from system_manage.models import UserMenuSetting, WorkspaceUserResourcePermission
rows = list(PlatformGrant.objects.values('id', 'subject_type', 'subject_id', 'resource_type', 'target', 'actions', 'expires_at'))
for role in PlatformRole.objects.exclude(id=ADMIN_ROLE_ID):
rows.extend({'id': f'role-menu:{role.id}:{m}', 'subject_type': 'ROLE', 'subject_id': str(role.id),
'resource_type': 'MODULE', 'target': m, 'actions': ['VIEW'], 'expires_at': None,
'origin': '角色菜单'} for m in role.modules)
for setting in UserMenuSetting.objects.all():
rows.extend({'id': f'user-menu:{setting.user_id}:{m}', 'subject_type': 'USER', 'subject_id': str(setting.user_id),
'resource_type': 'MODULE', 'target': m, 'actions': ['VIEW'], 'expires_at': None,
'origin': '原菜单授权'} for m in setting.menu_list or [])
for g in WorkspaceUserResourcePermission.objects.filter(workspace_id='default'):
# Owner/framework ROLE rows are not discretionary grants.
if 'ROLE' in g.permission_list:
continue
actions = list(ACTIONS) if 'MANAGE' in g.permission_list else (['VIEW', 'USE'] if 'VIEW' in g.permission_list else [])
rows.append({'id': f'legacy-resource:{g.id}', 'subject_type': 'USER', 'subject_id': str(g.user_id),
'resource_type': g.auth_target_type, 'target': g.target, 'actions': actions,
'expires_at': None, 'origin': '原资源授权'})
for kind in ('PARSER', 'SERVICE'):
for obj in resource_models()[kind].objects.filter(workspace_id='default'):
rows.extend({'id': f'legacy-share:{kind}:{obj.id}:{uid}', 'subject_type': 'USER', 'subject_id': uid,
'resource_type': kind, 'target': str(obj.id), 'actions': ['VIEW', 'USE'],
'expires_at': None, 'origin': '原资源授权'} for uid in obj.allowed_users)
for role in PlatformRole.objects.exclude(id=ADMIN_ROLE_ID):
if {'tool', 'mindmap'} & set(role.modules):
rows.append({'id': f'inherited-feature:{role.id}', 'subject_type': 'ROLE', 'subject_id': str(role.id),
'resource_type': 'FEATURE', 'target': 'document_parse', 'actions': ['VIEW', 'USE'],
'expires_at': None, 'origin': '菜单附带', 'readonly': True})
for setting in UserMenuSetting.objects.all():
if {'tool', 'mindmap'} & set(setting.menu_list or []):
rows.append({'id': f'inherited-user-feature:{setting.user_id}', 'subject_type': 'USER', 'subject_id': str(setting.user_id),
'resource_type': 'FEATURE', 'target': 'document_parse', 'actions': ['VIEW', 'USE'],
'expires_at': None, 'origin': '菜单附带', 'readonly': True})
return [row for row in rows if row['resource_type'] != 'FEATURE']
def remove_compatibility_grant(key, expected=None):
from system_manage.models import UserMenuSetting, WorkspaceUserResourcePermission
row = next((r for r in authorization_rows() if str(r['id']) == key and r.get('origin')), None)
if row is None:
raise ValidationError('授权已变更,请刷新')
if row.get('readonly'):
raise ValidationError('此权限随原菜单生效,请调整菜单授权')
if expected and any(str(expected.get(k)) != str(row[k]) for k in ('subject_type', 'subject_id', 'resource_type', 'target')):
raise ValidationError('授权对象不匹配')
parts = key.split(':')
if parts[0] == 'role-menu':
role = PlatformRole.objects.select_for_update().get(pk=row['subject_id'])
role.modules = [m for m in role.modules if m != row['target']]
role.save(update_fields=['modules', 'updated_at'])
elif parts[0] == 'user-menu':
setting = UserMenuSetting.objects.select_for_update().get(user_id=row['subject_id'])
setting.menu_list = [m for m in setting.menu_list if m != row['target']]
setting.save(update_fields=['menu_list'])
elif parts[0] == 'legacy-resource':
WorkspaceUserResourcePermission.objects.filter(pk=parts[1]).delete()
from users.serializers.user_manage_ext import invalidate_user_auth_cache
transaction.on_commit(lambda: invalidate_user_auth_cache(row['subject_id']))
elif parts[0] == 'legacy-share':
obj = resource_models()[row['resource_type']].objects.select_for_update().get(pk=row['target'])
obj.allowed_users = [uid for uid in obj.allowed_users if uid != row['subject_id']]
obj.save(update_fields=['allowed_users'])
def parser_feature_actions(user):
"""Old tool/mindmap menus include parsing; new feature grants are explicit."""
if not user.is_active:
return set()
if is_admin(user):
return {'VIEW', 'USE'}
from system_manage.models import UserMenuSetting
inherited = any({'tool', 'mindmap'} & set(role.modules) for role in roles_for(user))
setting = UserMenuSetting.objects.filter(user_id=user.id).first()
inherited = inherited or bool(setting and {'tool', 'mindmap'} & set(setting.menu_list or []))
return ({'VIEW', 'USE'} if inherited else set()) | resource_actions(user, 'FEATURE', 'document_parse')