345 lines
11 KiB
Python
345 lines
11 KiB
Python
from uuid import UUID
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException
|
|
from loguru import logger as l
|
|
|
|
from middleware.auth import admin_required
|
|
from middleware.dependencies import SessionDep
|
|
from models import (
|
|
User, ResponseBase,
|
|
Group, GroupOptions, )
|
|
from models.group import (
|
|
GroupCreateRequest, GroupUpdateRequest, GroupDetailResponse, )
|
|
from models.policy import GroupPolicyLink
|
|
|
|
admin_group_router = APIRouter(
|
|
prefix="/group",
|
|
tags=["admin", "admin_group"],
|
|
)
|
|
|
|
@admin_group_router.get(
|
|
path='/',
|
|
summary='获取用户组列表',
|
|
description='Get user group list',
|
|
dependencies=[Depends(admin_required)],
|
|
)
|
|
async def router_admin_get_groups(
|
|
session: SessionDep,
|
|
page: int = 1,
|
|
page_size: int = 20,
|
|
) -> ResponseBase:
|
|
"""
|
|
获取用户组列表，支持分页。
|
|
|
|
:param session: 数据库会话
|
|
:param page: 页码
|
|
:param page_size: 每页数量
|
|
:return: 用户组列表
|
|
"""
|
|
offset = (page - 1) * page_size
|
|
|
|
groups = await Group.get(
|
|
session,
|
|
None,
|
|
fetch_mode="all",
|
|
offset=offset,
|
|
limit=page_size,
|
|
load=Group.options,
|
|
)
|
|
|
|
total = await Group.count(session, None)
|
|
|
|
# 构建响应
|
|
group_list = []
|
|
for g in groups:
|
|
opts = g.options
|
|
policies = await g.awaitable_attrs.policies
|
|
user_count = await User.count(session, User.group_id == g.id)
|
|
|
|
group_list.append(GroupDetailResponse(
|
|
id=g.id,
|
|
name=g.name,
|
|
max_storage=g.max_storage,
|
|
share_enabled=g.share_enabled,
|
|
web_dav_enabled=g.web_dav_enabled,
|
|
admin=g.admin,
|
|
speed_limit=g.speed_limit,
|
|
user_count=user_count,
|
|
policy_ids=[p.id for p in policies],
|
|
share_download=opts.share_download if opts else False,
|
|
share_free=opts.share_free if opts else False,
|
|
relocate=opts.relocate if opts else False,
|
|
source_batch=opts.source_batch if opts else 0,
|
|
select_node=opts.select_node if opts else False,
|
|
advance_delete=opts.advance_delete if opts else False,
|
|
archive_download=opts.archive_download if opts else False,
|
|
archive_task=opts.archive_task if opts else False,
|
|
webdav_proxy=opts.webdav_proxy if opts else False,
|
|
aria2=opts.aria2 if opts else False,
|
|
redirected_source=opts.redirected_source if opts else False,
|
|
).model_dump())
|
|
|
|
return ResponseBase(data={"groups": group_list, "total": total})
|
|
|
|
|
|
@admin_group_router.get(
|
|
path='/{group_id}',
|
|
summary='获取用户组信息',
|
|
description='Get user group information by ID',
|
|
dependencies=[Depends(admin_required)],
|
|
)
|
|
async def router_admin_get_group(
|
|
session: SessionDep,
|
|
group_id: UUID,
|
|
) -> ResponseBase:
|
|
"""
|
|
根据用户组ID获取用户组详细信息。
|
|
|
|
:param session: 数据库会话
|
|
:param group_id: 用户组UUID
|
|
:return: 用户组详情
|
|
"""
|
|
group = await Group.get(session, Group.id == group_id, load=Group.options)
|
|
|
|
if not group:
|
|
raise HTTPException(status_code=404, detail="用户组不存在")
|
|
|
|
opts = group.options
|
|
policies = await group.awaitable_attrs.policies
|
|
user_count = await User.count(session, User.group_id == group_id)
|
|
|
|
response = GroupDetailResponse(
|
|
id=group.id,
|
|
name=group.name,
|
|
max_storage=group.max_storage,
|
|
share_enabled=group.share_enabled,
|
|
web_dav_enabled=group.web_dav_enabled,
|
|
admin=group.admin,
|
|
speed_limit=group.speed_limit,
|
|
user_count=user_count,
|
|
policy_ids=[p.id for p in policies],
|
|
share_download=opts.share_download if opts else False,
|
|
share_free=opts.share_free if opts else False,
|
|
relocate=opts.relocate if opts else False,
|
|
source_batch=opts.source_batch if opts else 0,
|
|
select_node=opts.select_node if opts else False,
|
|
advance_delete=opts.advance_delete if opts else False,
|
|
archive_download=opts.archive_download if opts else False,
|
|
archive_task=opts.archive_task if opts else False,
|
|
webdav_proxy=opts.webdav_proxy if opts else False,
|
|
aria2=opts.aria2 if opts else False,
|
|
redirected_source=opts.redirected_source if opts else False,
|
|
)
|
|
|
|
return ResponseBase(data=response.model_dump())
|
|
|
|
|
|
@admin_group_router.get(
|
|
path='/list/{group_id}',
|
|
summary='获取用户组成员列表',
|
|
description='Get user group member list by group ID',
|
|
dependencies=[Depends(admin_required)],
|
|
)
|
|
async def router_admin_get_group_members(
|
|
session: SessionDep,
|
|
group_id: UUID,
|
|
page: int = 1,
|
|
page_size: int = 20,
|
|
) -> ResponseBase:
|
|
"""
|
|
根据用户组ID获取用户组成员列表。
|
|
|
|
:param session: 数据库会话
|
|
:param group_id: 用户组UUID
|
|
:param page: 页码
|
|
:param page_size: 每页数量
|
|
:return: 成员列表
|
|
"""
|
|
# 验证组存在
|
|
group = await Group.get(session, Group.id == group_id)
|
|
if not group:
|
|
raise HTTPException(status_code=404, detail="用户组不存在")
|
|
|
|
offset = (page - 1) * page_size
|
|
|
|
users = await User.get(
|
|
session,
|
|
User.group_id == group_id,
|
|
fetch_mode="all",
|
|
offset=offset,
|
|
limit=page_size,
|
|
)
|
|
|
|
total = await User.count(session, User.group_id == group_id)
|
|
|
|
return ResponseBase(data={
|
|
"members": [u.to_public().model_dump() for u in users],
|
|
"total": total,
|
|
})
|
|
|
|
|
|
@admin_group_router.post(
|
|
path='/',
|
|
summary='创建用户组',
|
|
description='Create a new user group',
|
|
dependencies=[Depends(admin_required)],
|
|
)
|
|
async def router_admin_create_group(
|
|
session: SessionDep,
|
|
request: GroupCreateRequest,
|
|
) -> ResponseBase:
|
|
"""
|
|
创建新的用户组。
|
|
|
|
:param session: 数据库会话
|
|
:param request: 创建请求
|
|
:return: 创建结果
|
|
"""
|
|
# 检查名称唯一性
|
|
existing = await Group.get(session, Group.name == request.name)
|
|
if existing:
|
|
raise HTTPException(status_code=409, detail="用户组名称已存在")
|
|
|
|
# 创建用户组
|
|
group = Group(
|
|
name=request.name,
|
|
max_storage=request.max_storage,
|
|
share_enabled=request.share_enabled,
|
|
web_dav_enabled=request.web_dav_enabled,
|
|
speed_limit=request.speed_limit,
|
|
)
|
|
group = await group.save(session)
|
|
|
|
# 创建选项
|
|
options = GroupOptions(
|
|
group_id=group.id,
|
|
share_download=request.share_download,
|
|
share_free=request.share_free,
|
|
relocate=request.relocate,
|
|
source_batch=request.source_batch,
|
|
select_node=request.select_node,
|
|
advance_delete=request.advance_delete,
|
|
archive_download=request.archive_download,
|
|
archive_task=request.archive_task,
|
|
webdav_proxy=request.webdav_proxy,
|
|
aria2=request.aria2,
|
|
redirected_source=request.redirected_source,
|
|
)
|
|
await options.save(session)
|
|
|
|
# 关联存储策略
|
|
for policy_id in request.policy_ids:
|
|
link = GroupPolicyLink(group_id=group.id, policy_id=policy_id)
|
|
session.add(link)
|
|
await session.commit()
|
|
|
|
l.info(f"管理员创建了用户组: {group.name}")
|
|
return ResponseBase(data={"id": str(group.id), "name": group.name})
|
|
|
|
|
|
@admin_group_router.patch(
|
|
path='/{group_id}',
|
|
summary='更新用户组信息',
|
|
description='Update user group information by ID',
|
|
dependencies=[Depends(admin_required)],
|
|
)
|
|
async def router_admin_update_group(
|
|
session: SessionDep,
|
|
group_id: UUID,
|
|
request: GroupUpdateRequest,
|
|
) -> ResponseBase:
|
|
"""
|
|
根据用户组ID更新用户组信息。
|
|
|
|
:param session: 数据库会话
|
|
:param group_id: 用户组UUID
|
|
:param request: 更新请求
|
|
:return: 更新结果
|
|
"""
|
|
group = await Group.get(session, Group.id == group_id, load=Group.options)
|
|
if not group:
|
|
raise HTTPException(status_code=404, detail="用户组不存在")
|
|
|
|
# 检查名称唯一性（如果要更新名称）
|
|
if request.name and request.name != group.name:
|
|
existing = await Group.get(session, Group.name == request.name)
|
|
if existing:
|
|
raise HTTPException(status_code=409, detail="用户组名称已存在")
|
|
|
|
# 更新组基础字段
|
|
update_data = request.model_dump(
|
|
exclude_unset=True,
|
|
exclude={'policy_ids', 'share_download', 'share_free', 'relocate',
|
|
'source_batch', 'select_node', 'advance_delete', 'archive_download',
|
|
'archive_task', 'webdav_proxy', 'aria2', 'redirected_source'}
|
|
)
|
|
if update_data:
|
|
for key, value in update_data.items():
|
|
setattr(group, key, value)
|
|
group = await group.save(session)
|
|
|
|
# 更新选项
|
|
if group.options:
|
|
options_fields = {'share_download', 'share_free', 'relocate', 'source_batch',
|
|
'select_node', 'advance_delete', 'archive_download',
|
|
'archive_task', 'webdav_proxy', 'aria2', 'redirected_source'}
|
|
options_data = {k: v for k, v in request.model_dump(exclude_unset=True).items()
|
|
if k in options_fields and v is not None}
|
|
if options_data:
|
|
for key, value in options_data.items():
|
|
setattr(group.options, key, value)
|
|
await group.options.save(session)
|
|
|
|
# 更新策略关联
|
|
if request.policy_ids is not None:
|
|
# 删除旧关联
|
|
from sqlmodel import delete
|
|
await session.execute(
|
|
delete(GroupPolicyLink).where(GroupPolicyLink.group_id == group_id)
|
|
)
|
|
# 添加新关联
|
|
for policy_id in request.policy_ids:
|
|
link = GroupPolicyLink(group_id=group_id, policy_id=policy_id)
|
|
session.add(link)
|
|
await session.commit()
|
|
|
|
l.info(f"管理员更新了用户组: {group.name}")
|
|
return ResponseBase(data={"id": str(group.id)})
|
|
|
|
|
|
@admin_group_router.delete(
|
|
path='/{group_id}',
|
|
summary='删除用户组',
|
|
description='Delete user group by ID',
|
|
dependencies=[Depends(admin_required)],
|
|
)
|
|
async def router_admin_delete_group(
|
|
session: SessionDep,
|
|
group_id: UUID,
|
|
) -> ResponseBase:
|
|
"""
|
|
根据用户组ID删除用户组。
|
|
|
|
注意: 如果有用户属于该组，需要先迁移用户或拒绝删除。
|
|
|
|
:param session: 数据库会话
|
|
:param group_id: 用户组UUID
|
|
:return: 删除结果
|
|
"""
|
|
group = await Group.get(session, Group.id == group_id)
|
|
if not group:
|
|
raise HTTPException(status_code=404, detail="用户组不存在")
|
|
|
|
# 检查是否有用户属于该组
|
|
user_count = await User.count(session, User.group_id == group_id)
|
|
if user_count > 0:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"无法删除，该组下还有 {user_count} 个用户"
|
|
)
|
|
|
|
group_name = group.name
|
|
await Group.delete(session, group)
|
|
|
|
l.info(f"管理员删除了用户组: {group_name}")
|
|
return ResponseBase(data={"deleted": True}) |