@kernel-sig/console 0.1.0

package/backend/app/api/v1/sig.py

@@ -0,0 +1,565 @@
+"""版本/分支、例会、成员的 API。
+
+三组资源的共同点是：数据来自平台之外（上游文档与纪要），平台只做结构化与
+统计，因此都是只读端点 —— 写入口是定时同步，不是人工编辑。
+"""
+
+import uuid
+from typing import Annotated, Literal
+
+import structlog
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy import func, select
+from sqlalchemy.orm import selectinload
+
+from app.api.deps import CurrentUserDep, SessionDep, require_permission
+from app.core.exceptions import NotFoundError
+from app.core.permissions import Permission
+from app.domain.attention import RULE_INFO_BY_KEY
+from app.domain.review import is_bot
+from app.models.classification import Classification, SubjectType
+from app.models.meeting import Meeting, MeetingAgenda, ReleaseReport, ReleaseReportPatch
+from app.models.pull_request import PullRequest, ReviewEvent
+from app.models.sig import SIGMember, SubsystemOwner
+from app.schemas.common import MessageResponse
+from app.schemas.sig import (
+    AttentionGroupRead,
+    AttentionSampleRead,
+    AttentionSettingRead,
+    AttentionSettingUpdate,
+    AttentionSummaryRead,
+    AttentionThemeRead,
+    BranchSummary,
+    MeetingAgendaRead,
+    MeetingDetail,
+    MeetingSummary,
+    MemberRead,
+    MemberStats,
+    MergeBucketRead,
+    PeriodSummaryRead,
+    PullRef,
+    ReleaseReportRead,
+    SubsystemOwnerRead,
+)
+from app.services import attention_queue as attention_queue_service
+from app.services import release_service, repository_service
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(tags=["sig"])
+
+Manage = Annotated[None, Depends(require_permission(Permission.MANAGE_REPOSITORY))]
+
+
+async def _repository_id(session: SessionDep, repository_id: uuid.UUID) -> uuid.UUID:
+    await repository_service.require_repository(session, repository_id)
+    return repository_id
+
+
+# ---------------------------------------------------------------------------
+# 版本与分支
+# ---------------------------------------------------------------------------
+
+
+@router.get("/repositories/{repository_id}/branches", response_model=list[BranchSummary])
+async def list_branches(
+    repository_id: uuid.UUID, session: SessionDep, _: CurrentUserDep
+) -> list[BranchSummary]:
+    """全部版本/分支及其合入概览。
+
+    分支名做了归一化：``openEuler-24.03-LTS_SP1`` 与 ``-SP1`` 是同一个交付，
+    不合并会让同一个版本的合入数被拆到两行。
+    """
+    await _repository_id(session, repository_id)
+    rows = await release_service.list_branches(session, repository_id)
+    return [BranchSummary(**vars(row)) for row in rows]
+
+
+@router.get(
+    "/repositories/{repository_id}/branches/{branch}/timeline",
+    response_model=list[MergeBucketRead],
+)
+async def branch_timeline(
+    repository_id: uuid.UUID,
+    branch: str,
+    session: SessionDep,
+    _: CurrentUserDep,
+    granularity: Annotated[Literal["month", "biweek"], Query()] = "month",
+    buckets: Annotated[int, Query(ge=2, le=36)] = 12,
+) -> list[MergeBucketRead]:
+    """该分支的合入趋势。双周粒度与例会节奏对齐。"""
+    await _repository_id(session, repository_id)
+    raw = await _raw_names_for(session, repository_id, branch)
+    rows = await release_service.merge_timeline(
+        session, repository_id, raw_branches=raw, buckets=buckets, granularity=granularity
+    )
+    return [MergeBucketRead(**vars(row)) for row in rows]
+
+
+@router.get(
+    "/repositories/{repository_id}/branches/{branch}/periods",
+    response_model=list[PeriodSummaryRead],
+)
+async def branch_periods(
+    repository_id: uuid.UUID,
+    branch: str,
+    session: SessionDep,
+    _: CurrentUserDep,
+    granularity: Annotated[Literal["month", "biweek"], Query()] = "month",
+    count: Annotated[int, Query(ge=1, le=26)] = 6,
+) -> list[PeriodSummaryRead]:
+    """该版本最近若干期的合入总结，新的在前。
+
+    只取**已结束**的周期：当前周期还没过完，拿它做总结会得到一个
+    每刷新一次就变大、且永远与上一期不可比的数字。
+    一次返回多期而不是只给上一期 —— "这个版本最近几期稳步在合什么"
+    才是维护者要看的形状，单期看不出趋势。
+    """
+    await _repository_id(session, repository_id)
+    raw = await _raw_names_for(session, repository_id, branch)
+    # 末位是当前周期，去掉；剩下的按新到旧返回
+    windows = release_service.recent_windows(count + 1, granularity)[:-1]
+    summaries = await release_service.period_summaries(
+        session, repository_id, windows=windows, raw_branches=raw
+    )
+    return [PeriodSummaryRead(**vars(summary)) for summary in reversed(summaries)]
+
+
+@router.get(
+    "/repositories/{repository_id}/releases/notes",
+    response_model=list[ReleaseReportRead],
+)
+async def release_notes(
+    repository_id: uuid.UUID,
+    session: SessionDep,
+    _: CurrentUserDep,
+    branch: str | None = None,
+    limit: Annotated[int, Query(ge=1, le=100)] = 20,
+) -> list[ReleaseReportRead]:
+    """各版本的 release notes。
+
+    来源是例会纪要里的版本进展报告：tag 区间、合入补丁数、CVE 清单、
+    按类别归好的补丁列表。这是维护者本来就在写的版本说明，
+    平台只是把它结构化了。
+    """
+    stmt = (
+        select(ReleaseReport, Meeting.held_on)
+        .join(Meeting, Meeting.id == ReleaseReport.meeting_id)
+        .order_by(Meeting.held_on.desc(), ReleaseReport.branch)
+        .limit(limit)
+    )
+    if branch:
+        stmt = stmt.where(ReleaseReport.branch == branch)
+
+    rows = (await session.execute(stmt)).all()
+    return [
+        ReleaseReportRead(
+            id=report.id,
+            branch=report.branch,
+            from_tag=report.from_tag,
+            to_tag=report.to_tag,
+            patch_count=report.patch_count,
+            listed_count=report.listed_count,
+            iso_urls=report.iso_urls,
+            cve_ids=report.cve_ids,
+            groups=report.groups,
+            meeting_held_on=held_on,
+        )
+        for report, held_on in rows
+    ]
+
+
+@router.get(
+    "/releases/reports/{report_id}/patches",
+    response_model=list[dict],
+)
+async def report_patches(
+    report_id: uuid.UUID, session: SessionDep, _: CurrentUserDep
+) -> list[dict]:
+    """一份进展报告里列出的补丁条目。"""
+    stmt = (
+        select(ReleaseReportPatch)
+        .where(ReleaseReportPatch.report_id == report_id)
+        .order_by(ReleaseReportPatch.sequence)
+    )
+    rows = (await session.scalars(stmt)).all()
+    return [
+        {
+            "sequence": row.sequence,
+            "group_name": row.group_name,
+            "title": row.title,
+            "pull_number": row.pull_number,
+            "url": row.url,
+        }
+        for row in rows
+    ]
+
+
+async def _raw_names_for(session: SessionDep, repository_id: uuid.UUID, branch: str) -> list[str]:
+    """把一个规范化分支名展开成库里实际存在的全部写法。"""
+    rows = await release_service.list_branches(session, repository_id)
+    for item in rows:
+        if item.name == branch:
+            return item.raw_names
+    return [branch]
+
+
+async def _resolve_pull_refs(session: SessionDep, numbers: set[int]) -> dict[int, PullRef]:
+    """把 PR 编号批量解析成可跳转的引用。
+
+    按编号全局解析而不限定仓库：纪要里的编号指的是 ``openeuler/kernel``，
+    而平台当前只纳管这一个仓库。若将来纳管多个仓库且编号相撞，
+    这里会记录告警并保留先出现的一条 —— 静默取一条会让人以为链接是对的。
+    """
+    if not numbers:
+        return {}
+    stmt = (
+        select(
+            PullRequest.repository_id,
+            PullRequest.number,
+            PullRequest.id,
+            PullRequest.title,
+            PullRequest.state,
+            Classification.kind,
+        )
+        .outerjoin(
+            Classification,
+            (Classification.subject_id == PullRequest.id)
+            & (Classification.subject_type == SubjectType.PULL_REQUEST),
+        )
+        .where(PullRequest.number.in_(numbers))
+    )
+    refs: dict[int, PullRef] = {}
+    collisions: set[int] = set()
+    for row in (await session.execute(stmt)).all():
+        if row.number in refs:
+            collisions.add(row.number)
+            continue
+        refs[row.number] = PullRef(
+            number=row.number, id=row.id, title=row.title, state=row.state, kind=row.kind
+        )
+    if collisions:
+        logger.warning("pull_number_collision_across_repositories", numbers=sorted(collisions))
+    return refs
+
+
+# ---------------------------------------------------------------------------
+# 例会
+# ---------------------------------------------------------------------------
+
+
+@router.get("/meetings", response_model=list[MeetingSummary])
+async def list_meetings(
+    session: SessionDep,
+    _: CurrentUserDep,
+    status: str | None = None,
+    limit: Annotated[int, Query(ge=1, le=200)] = 50,
+) -> list[MeetingSummary]:
+    """SIG 例会列表，最近的在最前。"""
+    stmt = select(Meeting).order_by(Meeting.held_on.desc()).limit(limit)
+    if status:
+        stmt = stmt.where(Meeting.status == status)
+    meetings = list((await session.scalars(stmt)).all())
+    if not meetings:
+        return []
+
+    ids = [row.id for row in meetings]
+    agenda_counts = dict(
+        (
+            await session.execute(
+                select(MeetingAgenda.meeting_id, func.count())
+                .where(MeetingAgenda.meeting_id.in_(ids))
+                .group_by(MeetingAgenda.meeting_id)
+            )
+        ).all()
+    )
+    report_counts = dict(
+        (
+            await session.execute(
+                select(ReleaseReport.meeting_id, func.count())
+                .where(ReleaseReport.meeting_id.in_(ids))
+                .group_by(ReleaseReport.meeting_id)
+            )
+        ).all()
+    )
+    return [
+        _meeting_summary(row, agenda_counts.get(row.id, 0), report_counts.get(row.id, 0))
+        for row in meetings
+    ]
+
+
+@router.get("/meetings/{meeting_id}", response_model=MeetingDetail)
+async def get_meeting(
+    meeting_id: uuid.UUID, session: SessionDep, _: CurrentUserDep
+) -> MeetingDetail:
+    stmt = (
+        select(Meeting)
+        .where(Meeting.id == meeting_id)
+        .options(selectinload(Meeting.agendas), selectinload(Meeting.reports))
+    )
+    meeting = await session.scalar(stmt)
+    if meeting is None:
+        raise NotFoundError("例会不存在", resource="meeting", identifier=str(meeting_id))
+
+    numbers = {n for row in meeting.agendas for n in (row.pull_numbers or [])}
+    refs = await _resolve_pull_refs(session, numbers)
+
+    base = _meeting_summary(meeting, len(meeting.agendas), len(meeting.reports))
+    agendas = []
+    for row in meeting.agendas:
+        agenda = MeetingAgendaRead.model_validate(row)
+        agenda.pull_refs = [refs[n] for n in (row.pull_numbers or []) if n in refs]
+        agendas.append(agenda)
+    return MeetingDetail(
+        **base.model_dump(),
+        legacy=meeting.legacy,
+        agendas=agendas,
+        reports=[
+            ReleaseReportRead(
+                id=report.id,
+                branch=report.branch,
+                from_tag=report.from_tag,
+                to_tag=report.to_tag,
+                patch_count=report.patch_count,
+                listed_count=report.listed_count,
+                iso_urls=report.iso_urls,
+                cve_ids=report.cve_ids,
+                groups=report.groups,
+                meeting_held_on=meeting.held_on,
+            )
+            for report in meeting.reports
+        ],
+    )
+
+
+def _meeting_summary(row: Meeting, agendas: int, reports: int) -> MeetingSummary:
+    return MeetingSummary(
+        id=row.id,
+        held_on=row.held_on,
+        start_time=row.start_time,
+        title=row.title,
+        host=row.host,
+        next_host=row.next_host,
+        host_order=row.host_order,
+        meeting_url=row.meeting_url,
+        minutes_url=row.minutes_url,
+        status=row.status,
+        agenda_count=agendas,
+        report_count=reports,
+    )
+
+
+@router.post("/meetings/sync", response_model=MessageResponse)
+async def sync_meetings_now(session: SessionDep, _: Manage) -> MessageResponse:
+    """立即同步一次纪要。手动入口，定时任务在 worker 里。"""
+    from app.services import sig_service
+
+    text = await sig_service.fetch_etherpad()
+    result = await sig_service.sync_meetings(session, text)
+    await session.commit()
+    return MessageResponse(
+        message=(
+            f"解析 {result['meetings']} 场：新增 {result['created']}，"
+            f"更新 {result['updated']}，未变 {result['unchanged']}"
+        )
+    )
+
+
+# ---------------------------------------------------------------------------
+# 成员与模块归属
+# ---------------------------------------------------------------------------
+
+
+@router.get("/members", response_model=list[MemberRead])
+async def list_members(
+    session: SessionDep, _: CurrentUserDep, role: str | None = None
+) -> list[MemberRead]:
+    """SIG 成员名单。权威来源是 community 仓库的 SIG 文档，不由平台推断。"""
+    stmt = select(SIGMember).order_by(SIGMember.role, SIGMember.name)
+    if role:
+        stmt = stmt.where(SIGMember.role == role)
+    return [MemberRead.model_validate(row) for row in (await session.scalars(stmt)).all()]
+
+
+@router.get("/members/stats", response_model=list[MemberStats])
+async def member_stats(
+    session: SessionDep,
+    _: CurrentUserDep,
+    repository_id: uuid.UUID | None = None,
+    limit: Annotated[int, Query(ge=1, le=200)] = 50,
+) -> list[MemberStats]:
+    """成员贡献统计。
+
+    现算而非落库：这个数字每天都在变，存下来就得维护失效，
+    而名单本身是低频变化的，两者寿命不同。
+    """
+    authored_stmt = (
+        select(
+            PullRequest.author_login,
+            func.count(),
+            func.count().filter(PullRequest.state == "merged"),
+        )
+        .where(PullRequest.author_login.is_not(None))
+        .group_by(PullRequest.author_login)
+    )
+    review_stmt = select(ReviewEvent.actor_login, func.count()).group_by(ReviewEvent.actor_login)
+    if repository_id is not None:
+        authored_stmt = authored_stmt.where(PullRequest.repository_id == repository_id)
+
+    authored = {row[0]: (row[1], row[2]) for row in (await session.execute(authored_stmt)).all()}
+    reviewed = {row[0]: row[1] for row in (await session.execute(review_stmt)).all()}
+
+    members = {
+        row.atomgit_id or row.gitee_id: row
+        for row in (await session.scalars(select(SIGMember))).all()
+    }
+    owners = (await session.scalars(select(SubsystemOwner))).all()
+    modules: dict[str, list[str]] = {}
+    for row in owners:
+        for login in row.committer_logins or []:
+            modules.setdefault(login, []).append(row.module)
+
+    logins = set(authored) | set(reviewed) | set(members)
+    stats: list[MemberStats] = []
+    for login in logins:
+        if not login or is_bot(login):
+            continue
+        member = members.get(login)
+        counts = authored.get(login, (0, 0))
+        stats.append(
+            MemberStats(
+                login=login,
+                name=member.name if member else None,
+                role=member.role if member else None,
+                authored=counts[0],
+                merged=counts[1],
+                reviews=reviewed.get(login, 0),
+                subsystems=sorted(set(modules.get(login, [])))[:12],
+            )
+        )
+
+    stats.sort(key=lambda item: (-item.merged, -item.reviews, item.login))
+    return stats[:limit]
+
+
+@router.get("/subsystem-owners", response_model=list[SubsystemOwnerRead])
+async def list_subsystem_owners(session: SessionDep, _: CurrentUserDep) -> list[SubsystemOwnerRead]:
+    """模块 → Committer 的归属表，来自 committers.md。"""
+    stmt = select(SubsystemOwner).order_by(SubsystemOwner.sequence)
+    return [SubsystemOwnerRead.model_validate(row) for row in (await session.scalars(stmt)).all()]
+
+
+# ---------------------------------------------------------------------------
+# 关注队列的订阅设置与分组
+# ---------------------------------------------------------------------------
+
+
+@router.get(
+    "/repositories/{repository_id}/attention/queue",
+    response_model=list[AttentionGroupRead],
+)
+async def attention_queue(
+    repository_id: uuid.UUID,
+    session: SessionDep,
+    _: CurrentUserDep,
+    scope: Annotated[Literal["pull_request", "issue"] | None, Query()] = None,
+) -> list[AttentionGroupRead]:
+    """按订阅设置分组的关注队列。
+
+    返回的是**分组**而非逐条：一条规则一行，给出条数、最久等待与少量样本。
+    实测未收敛时有 4780 条，其中 63% 是陈旧 Issue —— 逐条罗列等于
+    把"需要关注"变成"全部清单"，翻两页就会被放弃。
+    """
+    await _repository_id(session, repository_id)
+    groups = await attention_queue_service.build_queue(session, repository_id, scope=scope)
+    return [_group_read(group) for group in groups]
+
+
+@router.get(
+    "/repositories/{repository_id}/attention/summary",
+    response_model=AttentionSummaryRead,
+)
+async def attention_summary(
+    repository_id: uuid.UUID, session: SessionDep, _: CurrentUserDep
+) -> AttentionSummaryRead:
+    """首页摘要。
+
+    与队列同源，不是另算一遍：分别统计的话，关掉一条规则后首页与队列页
+    会显示两个不同的数字，而这种不一致从任一页面上都看不出来。
+    """
+    await _repository_id(session, repository_id)
+    summary = await attention_queue_service.queue_summary(session, repository_id)
+    return AttentionSummaryRead(
+        total=summary.total,
+        group_count=summary.group_count,
+        by_severity=summary.by_severity,
+        blocking=summary.blocking,
+        top=[_group_read(group) for group in summary.top],
+    )
+
+
+@router.get("/attention/rule-settings", response_model=list[AttentionSettingRead])
+async def list_rule_settings(session: SessionDep, _: CurrentUserDep) -> list[AttentionSettingRead]:
+    """各关注规则的订阅设置。
+
+    带上当前未解决的条数：关掉一条规则之前，应该先看到它拦下了多少东西。
+    """
+    views = await attention_queue_service.load_settings(session)
+    return [AttentionSettingRead(**vars(view)) for view in views]
+
+
+@router.put("/attention/rule-settings/{rule}", response_model=AttentionSettingRead)
+async def update_rule_setting(
+    rule: str,
+    payload: AttentionSettingUpdate,
+    session: SessionDep,
+    user: CurrentUserDep,
+    _: Manage,
+) -> AttentionSettingRead:
+    """调整一条规则的订阅：开关、阈值、适用对象。
+
+    阈值写死在代码里的结果是没人用这个功能 —— 第一条不符合自己节奏的
+    提醒就会让人关掉整个队列。
+    """
+    if rule not in RULE_INFO_BY_KEY:
+        raise NotFoundError("关注规则不存在", resource="attention_rule", identifier=rule)
+
+    await attention_queue_service.save_setting(
+        session,
+        rule=rule,
+        enabled=payload.enabled,
+        days=payload.days,
+        subject_scope=payload.subject_scope,
+        user_id=user.id,
+    )
+    await session.commit()
+
+    views = await attention_queue_service.load_settings(session)
+    view = next((item for item in views if item.rule == rule), None)
+    if view is None:
+        raise NotFoundError("关注规则不存在", resource="attention_rule", identifier=rule)
+    return AttentionSettingRead(**vars(view))
+
+
+def _group_read(group) -> AttentionGroupRead:
+    return AttentionGroupRead(
+        rule=group.rule,
+        label=group.label,
+        meaning=group.meaning,
+        action=group.action,
+        subject=group.subject,
+        count=group.count,
+        severity=group.severity,
+        oldest_days=group.oldest_days,
+        high_volume=group.high_volume,
+        acknowledged_count=group.acknowledged_count,
+        samples=[AttentionSampleRead(**vars(item)) for item in group.samples],
+        themes=[
+            AttentionThemeRead(
+                name=theme.name,
+                count=theme.count,
+                samples=[AttentionSampleRead(**vars(item)) for item in theme.samples],
+            )
+            for theme in group.themes
+        ],
+    )

package/backend/app/api/v1/users.py

@@ -0,0 +1,87 @@
+"""用户管理端点。"""
+
+import uuid
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Query, status
+
+from app.api.deps import SessionDep, require_permission
+from app.core.exceptions import ConflictError, NotFoundError, UnauthorizedError
+from app.core.permissions import Permission
+from app.core.security import verify_password
+from app.models.user import User
+from app.schemas.common import Page
+from app.schemas.user import PasswordChange, UserCreate, UserRead, UserUpdate
+from app.services import user_service
+
+router = APIRouter(prefix="/users", tags=["users"])
+
+AdminDep = Annotated[User, Depends(require_permission(Permission.MANAGE_USERS))]
+CurrentUserDep = Annotated[User, Depends(require_permission(Permission.VIEW))]
+
+
+@router.get("", response_model=Page[UserRead])
+async def list_users(
+    session: SessionDep,
+    _: AdminDep,
+    page: Annotated[int, Query(ge=1)] = 1,
+    per_page: Annotated[int, Query(ge=1, le=200)] = 50,
+) -> Page[UserRead]:
+    users, total = await user_service.list_users(
+        session, offset=(page - 1) * per_page, limit=per_page
+    )
+    return Page.create([UserRead.model_validate(u) for u in users], total, page, per_page)
+
+
+@router.post("", response_model=UserRead, status_code=status.HTTP_201_CREATED)
+async def create_user(
+    payload: UserCreate,
+    session: SessionDep,
+    _: AdminDep,
+) -> UserRead:
+    try:
+        user = await user_service.create_user(
+            session,
+            username=payload.username,
+            display_name=payload.display_name,
+            email=payload.email,
+            password=payload.password,
+            role=payload.role,
+            atomgit_login=payload.atomgit_login,
+        )
+    except ValueError as exc:
+        raise ConflictError(str(exc)) from exc
+    await session.commit()
+    return UserRead.model_validate(user)
+
+
+@router.get("/{user_id}", response_model=UserRead)
+async def get_user(user_id: uuid.UUID, session: SessionDep, _: CurrentUserDep) -> UserRead:
+    target = await user_service.get_user(session, user_id)
+    if target is None:
+        raise NotFoundError("用户不存在", resource="user", identifier=str(user_id))
+    return UserRead.model_validate(target)
+
+
+@router.patch("/{user_id}", response_model=UserRead)
+async def update_user(
+    user_id: uuid.UUID, payload: UserUpdate, session: SessionDep, _: AdminDep
+) -> UserRead:
+    target = await user_service.get_user(session, user_id)
+    if target is None:
+        raise NotFoundError("用户不存在", resource="user", identifier=str(user_id))
+
+    for field, value in payload.model_dump(exclude_unset=True).items():
+        setattr(target, field, value)
+    await session.commit()
+    return UserRead.model_validate(target)
+
+
+@router.post("/me/password", status_code=status.HTTP_204_NO_CONTENT)
+async def change_own_password(
+    payload: PasswordChange, session: SessionDep, user: CurrentUserDep
+) -> None:
+    if not verify_password(payload.current_password, user.password_hash):
+        raise UnauthorizedError("当前密码错误")
+    await user_service.set_password(session, user, payload.new_password)
+    await session.commit()