feat: backend read api for all entities (messages/groups/calls/sms/org/sync)

Adds the read-only API surface the upcoming Vue frontend needs to browse all
mirrored entities. Follows the existing customer-router pattern: Annotated
deps, Page[T] envelope, select+where+order_by, count() for total.

Endpoints (all GET):
* /api/departments          -> list[DepartmentOut] (path-ordered, plain list)
* /api/staff                -> Page[StaffOut] (department_id, is_on_job filters)
* /api/accounts             -> Page[AccountOut] (channel filter; unified
                             wechat+whatsapp projection built in memory)
* /api/messages             -> Page[MessageOut] (channel/owner/talker/room/
                             [start,end] filters; ordered timestamp asc)
* /api/groups               -> Page[GroupOut] (channel/owner filters)
* /api/groups/{id}/members  -> list[GroupMemberOut] (404 on unknown room)
* /api/calls                -> Page[PhoneCallOut] (channel/user/time window;
                             ordered start_call_time desc)
* /api/sms                  -> Page[SmsOut] (user/time window; create_time desc)
* /api/sync/status          -> {states, recent_runs} monitor payload

Schemas (Pydantic v2, from_attributes=True): MessageOut, GroupOut,
GroupMemberOut, PhoneCallOut, SmsOut, DepartmentOut, StaffOut, AccountOut
(unified across two tables), SyncStateOut, SyncRunOut, SyncStatusOut.
Only human-relevant fields per entity are exposed.

Tests: per-router TDD via httpx ASGITransport against an in-memory SQLite
override of get_session. A shared make_client factory in conftest.py builds
the seeded client, deduping the ~40-line fixture across the six new files.
41 new tests cover shape + every documented filter + pagination + ordering
(nulls-last verified on all desc/asc time columns).

Suite: 226 -> 267 passing. ruff check clean.

Co-Authored-By: Claude <noreply@anthropic.com>

yunke-server/app/api/routers/organization.py

@@ -0,0 +1,137 @@
+"""GET /api/departments, /api/staff, /api/accounts — organization browse endpoints.
+
+Read-only queries over the mirrored ``department``, ``staff``,
+``wechat_account`` and ``whatsapp_account`` tables.
+
+* ``GET /api/departments`` -> ``list[DepartmentOut]`` ordered by ``path`` so
+  the frontend can assemble the tree with a stable traversal order.
+* ``GET /api/staff`` -> ``Page[StaffOut]`` with optional ``department_id``
+  and ``is_on_job`` filters.
+* ``GET /api/accounts`` -> ``Page[AccountOut]`` projecting both staff-messaging
+  account tables onto a unified shape (see :class:`AccountOut`). The optional
+  ``channel`` filter restricts to one of ``wechat`` / ``whatsapp``; when
+  omitted, both tables are unioned in memory. Staff-account volumes are modest
+  (tens to low hundreds of rows), so the in-memory merge is cheap and keeps
+  the API contract simple.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import sqlalchemy as sa
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import get_session
+from app.api.schemas import AccountOut, DepartmentOut, Page, StaffOut
+from app.db.models import Department, Staff, WechatAccount, WhatsappAccount
+
+router = APIRouter(prefix="/api", tags=["organization"])
+
+SessionDep = Annotated[AsyncSession, Depends(get_session)]
+PageParam = Annotated[int, Query(ge=1)]
+PageSizeParam = Annotated[int, Query(ge=1, le=100)]
+
+
+@router.get("/departments")
+async def list_departments(session: SessionDep) -> list[DepartmentOut]:
+    """Return every department ordered by ``path`` (nulls last).
+
+    A plain list — not paginated — because the frontend rebuilds the tree from
+    ``parent_id``/``path`` and pagination would split the topology awkwardly.
+    """
+    stmt = sa.select(Department).order_by(
+        sa.nullslast(Department.path.asc()), Department.dept_id.asc()
+    )
+    rows = (await session.execute(stmt)).scalars().all()
+    return [DepartmentOut.model_validate(row) for row in rows]
+
+
+@router.get("/staff")
+async def list_staff(
+    session: SessionDep,
+    page: PageParam = 1,
+    page_size: PageSizeParam = 20,
+    department_id: Annotated[str | None, Query()] = None,
+    is_on_job: Annotated[bool | None, Query()] = None,
+) -> Page[StaffOut]:
+    """List staff with optional ``department_id`` / ``is_on_job`` filters."""
+    conditions = []
+    if department_id is not None:
+        conditions.append(Staff.dept_id == department_id)
+    if is_on_job is not None:
+        conditions.append(Staff.is_on_job.is_(is_on_job))
+
+    total_stmt = sa.select(sa.func.count()).select_from(Staff)
+    if conditions:
+        total_stmt = total_stmt.where(*conditions)
+    total = (await session.execute(total_stmt)).scalar_one()
+
+    list_stmt = sa.select(Staff)
+    if conditions:
+        list_stmt = list_stmt.where(*conditions)
+    list_stmt = (
+        list_stmt.order_by(Staff.user_id.asc())
+        .limit(page_size)
+        .offset((page - 1) * page_size)
+    )
+    rows = (await session.execute(list_stmt)).scalars().all()
+    items = [StaffOut.model_validate(row) for row in rows]
+    return Page(items=items, total=total, page=page, page_size=page_size)
+
+
+@router.get("/accounts")
+async def list_accounts(
+    session: SessionDep,
+    page: PageParam = 1,
+    page_size: PageSizeParam = 20,
+    channel: Annotated[str | None, Query()] = None,
+) -> Page[AccountOut]:
+    """List staff messaging accounts (WeChat / WhatsApp) in a unified shape.
+
+    ``channel`` optional; one of ``wechat`` / ``whatsapp``. When omitted, both
+    tables are merged in memory. Pagination is applied after the merge using a
+    stable ``(channel, account_id)`` ordering.
+    """
+    selected_channels = [channel] if channel else ["wechat", "whatsapp"]
+
+    rows: list[AccountOut] = []
+    if "wechat" in selected_channels:
+        result = (await session.execute(sa.select(WechatAccount))).scalars().all()
+        for r in result:
+            rows.append(
+                AccountOut(
+                    channel="wechat",
+                    account_id=r.wx_id,
+                    nickname=r.nick_name,
+                    user_id=r.user_id,
+                    user_name=r.user_name,
+                    phone=r.phone,
+                    contacts_num=r.contacts_num,
+                    group_num=r.group_num,
+                    is_on_job=r.is_on_job,
+                )
+            )
+    if "whatsapp" in selected_channels:
+        result = (await session.execute(sa.select(WhatsappAccount))).scalars().all()
+        for r in result:
+            rows.append(
+                AccountOut(
+                    channel="whatsapp",
+                    account_id=r.uid,
+                    nickname=r.nick_name,
+                    user_id=r.user_id,
+                    user_name=r.user_name,
+                    phone=r.phone,
+                    contacts_num=r.contacts_num,
+                    group_num=r.group_num,
+                    is_on_job=r.is_on_job,
+                )
+            )
+
+    rows.sort(key=lambda a: (a.channel, a.account_id))
+    total = len(rows)
+    start = (page - 1) * page_size
+    items = rows[start : start + page_size]
+    return Page(items=items, total=total, page=page, page_size=page_size)