Skip to content

Open-source personal finance manager. Self-hosted, privacy-first.

10.7 KB
Raw Blame
import uuid
from typing import Literal

from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.database import get_async_session
from app.core.workspace_context import (
    WorkspaceContext,
    current_workspace,
    current_writable_workspace,
)
from app.schemas.group import (
    GroupBalances,
    GroupCreate,
    GroupMemberCreate,
    GroupMemberRead,
    GroupMemberUpdate,
    GroupRead,
    GroupSummary,
    GroupUpdate,
)
from app.schemas.group_settlement import (
    GroupSettlementCreate,
    GroupSettlementRead,
    GroupSettlementUpdate,
)
from app.schemas.transaction import TransactionRead
from app.services import (
    balance_service,
    group_service,
    group_summary_service,
    settlement_service,
)

router = APIRouter(prefix="/api/groups", tags=["groups"])


@router.get("", response_model=list[GroupRead])
async def list_groups(
    include_archived: bool = Query(False),
    q: str | None = Query(None),
    group_status: Literal['active', 'archived', 'all'] | None = Query(None, alias='status'),
    ctx: WorkspaceContext = Depends(current_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    return await group_service.list_groups(
        session, ctx.workspace.id, ctx.user_id, include_archived=include_archived,
        q=q, status=group_status,
    )


@router.post("", response_model=GroupRead, status_code=status.HTTP_201_CREATED)
async def create_group(
    data: GroupCreate,
    ctx: WorkspaceContext = Depends(current_writable_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    try:
        return await group_service.create_group(session, ctx.workspace.id, ctx.user_id, data)
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))


@router.get("/{group_id}", response_model=GroupRead)
async def get_group(
    group_id: uuid.UUID,
    ctx: WorkspaceContext = Depends(current_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    # Read endpoint — visible to workspace members and to cross-workspace
    # linked members (the Splitwise case where someone is added from
    # outside this workspace).
    group = await group_service.get_group_visible(
        session, group_id, ctx.workspace.id, ctx.user_id
    )
    if not group:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Group not found")
    return group


@router.patch("/{group_id}", response_model=GroupRead)
async def update_group(
    group_id: uuid.UUID,
    data: GroupUpdate,
    ctx: WorkspaceContext = Depends(current_writable_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    try:
        group = await group_service.update_group(
            session, group_id, ctx.workspace.id, ctx.user_id, data
        )
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
    if not group:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Group not found")
    return group


@router.delete("/{group_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_group(
    group_id: uuid.UUID,
    ctx: WorkspaceContext = Depends(current_writable_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    try:
        deleted = await group_service.delete_group(session, group_id, ctx.workspace.id)
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(e))
    if not deleted:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Group not found")


@router.get("/{group_id}/members", response_model=list[GroupMemberRead])
async def list_members(
    group_id: uuid.UUID,
    ctx: WorkspaceContext = Depends(current_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    members = await group_service.list_members(
        session, group_id, ctx.workspace.id, ctx.user_id
    )
    if members is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Group not found")
    return members


@router.post(
    "/{group_id}/members",
    response_model=GroupMemberRead,
    status_code=status.HTTP_201_CREATED,
)
async def create_member(
    group_id: uuid.UUID,
    data: GroupMemberCreate,
    ctx: WorkspaceContext = Depends(current_writable_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    try:
        member = await group_service.create_member(session, group_id, ctx.workspace.id, data)
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
    if member is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Group not found")
    return member


@router.patch("/{group_id}/members/{member_id}", response_model=GroupMemberRead)
async def update_member(
    group_id: uuid.UUID,
    member_id: uuid.UUID,
    data: GroupMemberUpdate,
    ctx: WorkspaceContext = Depends(current_writable_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    try:
        member = await group_service.update_member(
            session, group_id, member_id, ctx.workspace.id, data
        )
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
    if member is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Member not found")
    return member


@router.delete(
    "/{group_id}/members/{member_id}", status_code=status.HTTP_204_NO_CONTENT
)
async def delete_member(
    group_id: uuid.UUID,
    member_id: uuid.UUID,
    ctx: WorkspaceContext = Depends(current_writable_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    try:
        deleted = await group_service.delete_member(
            session, group_id, member_id, ctx.workspace.id
        )
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(e))
    if not deleted:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Member not found")


@router.get("/{group_id}/transactions", response_model=list[TransactionRead])
async def list_group_transactions(
    group_id: uuid.UUID,
    limit: int = 20,
    ctx: WorkspaceContext = Depends(current_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    txs = await group_service.list_transactions(
        session, group_id, ctx.workspace.id, ctx.user_id, limit=limit
    )
    if txs is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Group not found")
    return txs


@router.get("/{group_id}/summary", response_model=GroupSummary)
async def get_summary(
    group_id: uuid.UUID,
    ctx: WorkspaceContext = Depends(current_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    """Spending aggregates for the whole group.

    Separate from /transactions, which is a capped recent-activity list:
    totals have to see every split, not the last page of them.
    """
    summary = await group_summary_service.compute_summary(
        session, group_id, ctx.workspace.id, ctx.user_id
    )
    if summary is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Group not found")
    return summary


@router.get("/{group_id}/balances", response_model=GroupBalances)
async def get_balances(
    group_id: uuid.UUID,
    ctx: WorkspaceContext = Depends(current_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    balances = await balance_service.compute_balances(
        session, group_id, ctx.workspace.id, ctx.user_id
    )
    if balances is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Group not found")
    return balances


@router.get("/{group_id}/settlements", response_model=list[GroupSettlementRead])
async def list_settlements(
    group_id: uuid.UUID,
    ctx: WorkspaceContext = Depends(current_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    settlements = await settlement_service.list_settlements(
        session, group_id, ctx.workspace.id, ctx.user_id
    )
    if settlements is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Group not found")
    return settlements


@router.post(
    "/{group_id}/settlements",
    response_model=GroupSettlementRead,
    status_code=status.HTTP_201_CREATED,
)
async def create_settlement(
    group_id: uuid.UUID,
    data: GroupSettlementCreate,
    ctx: WorkspaceContext = Depends(current_writable_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    try:
        settlement = await settlement_service.create_settlement(
            session, group_id, ctx.workspace.id, ctx.user_id, data
        )
    except PermissionError as e:
        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=str(e))
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
    if settlement is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Group not found")
    return settlement


@router.patch(
    "/{group_id}/settlements/{settlement_id}", response_model=GroupSettlementRead
)
async def update_settlement(
    group_id: uuid.UUID,
    settlement_id: uuid.UUID,
    data: GroupSettlementUpdate,
    ctx: WorkspaceContext = Depends(current_writable_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    try:
        settlement = await settlement_service.update_settlement(
            session, group_id, settlement_id, ctx.workspace.id, ctx.user_id, data
        )
    except PermissionError as e:
        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=str(e))
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
    if settlement is None:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND, detail="Settlement not found"
        )
    return settlement


@router.delete(
    "/{group_id}/settlements/{settlement_id}",
    status_code=status.HTTP_204_NO_CONTENT,
)
async def delete_settlement(
    group_id: uuid.UUID,
    settlement_id: uuid.UUID,
    ctx: WorkspaceContext = Depends(current_writable_workspace),
    session: AsyncSession = Depends(get_async_session),
):
    try:
        deleted = await settlement_service.delete_settlement(
            session, group_id, settlement_id, ctx.workspace.id, ctx.user_id
        )
    except PermissionError as e:
        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=str(e))
    if not deleted:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND, detail="Settlement not found"
        )