浅念
ff7e9cb1d9
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>
82 lines
2.9 KiB
Python
82 lines
2.9 KiB
Python
"""GET /api/messages — chat timeline list (WeChat + WhatsApp).
|
|
|
|
Read-only query over the mirrored ``message`` table. Filters:
|
|
|
|
* ``channel`` — ``wechat`` / ``whatsapp``.
|
|
* ``owner_account_id`` — owning staff account (wxId / uid).
|
|
* ``talker_id`` (1:1) OR ``room_id`` (group) — the conversation anchor. Both
|
|
may be supplied (AND), but typically the frontend sends exactly one.
|
|
* ``start`` / ``end`` — ms-epoch window compared against ``timestamp``
|
|
(inclusive on both ends).
|
|
|
|
Ordered by ``timestamp asc`` so the timeline renders oldest-first. The index
|
|
``ix_message_channel_owner_talker_time`` covers the hot path
|
|
``(channel, owner_account_id, talker_id, timestamp)``.
|
|
"""
|
|
|
|
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 MessageOut, Page
|
|
from app.db.models import Message
|
|
|
|
router = APIRouter(prefix="/api", tags=["messages"])
|
|
|
|
SessionDep = Annotated[AsyncSession, Depends(get_session)]
|
|
PageParam = Annotated[int, Query(ge=1)]
|
|
PageSizeParam = Annotated[int, Query(ge=1, le=100)]
|
|
|
|
|
|
@router.get("/messages")
|
|
async def list_messages(
|
|
session: SessionDep,
|
|
page: PageParam = 1,
|
|
page_size: PageSizeParam = 50,
|
|
channel: Annotated[str | None, Query()] = None,
|
|
owner_account_id: Annotated[str | None, Query()] = None,
|
|
talker_id: Annotated[str | None, Query()] = None,
|
|
room_id: Annotated[str | None, Query()] = None,
|
|
start: Annotated[int | None, Query(ge=0)] = None,
|
|
end: Annotated[int | None, Query(ge=0)] = None,
|
|
) -> Page[MessageOut]:
|
|
"""List messages for a timeline (ordered by ``timestamp asc``)."""
|
|
conditions = []
|
|
if channel is not None:
|
|
conditions.append(Message.channel == channel)
|
|
if owner_account_id is not None:
|
|
conditions.append(Message.owner_account_id == owner_account_id)
|
|
if talker_id is not None:
|
|
conditions.append(Message.talker_id == talker_id)
|
|
if room_id is not None:
|
|
conditions.append(Message.room_id == room_id)
|
|
if start is not None:
|
|
conditions.append(Message.timestamp >= start)
|
|
if end is not None:
|
|
conditions.append(Message.timestamp <= end)
|
|
|
|
total_stmt = sa.select(sa.func.count()).select_from(Message)
|
|
if conditions:
|
|
total_stmt = total_stmt.where(*conditions)
|
|
total = (await session.execute(total_stmt)).scalar_one()
|
|
|
|
list_stmt = sa.select(Message)
|
|
if conditions:
|
|
list_stmt = list_stmt.where(*conditions)
|
|
list_stmt = (
|
|
list_stmt.order_by(
|
|
sa.nullslast(Message.timestamp.asc()),
|
|
Message.msg_id.asc(),
|
|
)
|
|
.limit(page_size)
|
|
.offset((page - 1) * page_size)
|
|
)
|
|
rows = (await session.execute(list_stmt)).scalars().all()
|
|
items = [MessageOut.model_validate(row) for row in rows]
|
|
return Page(items=items, total=total, page=page, page_size=page_size)
|