Skip to content

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

adding groups on bulk (#164)

Tássio Noronha4921c074a29f
diff --git a/backend/app/api/transactions.py b/backend/app/api/transactions.py
index 34c4c69b..bc271f67 100644
--- a/backend/app/api/transactions.py
+++ b/backend/app/api/transactions.py
@@ -12,7 +12,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
from app.core.auth import current_active_user
from app.core.database import get_async_session
from app.models.user import User
-from app.schemas.transaction import BulkCategorizeRequest, BulkTagsRequest, LinkTransferRequest, TransactionCreate, TransactionRead, TransactionUpdate, TransferCreate, TransferRead
+from app.schemas.transaction import BulkAddToGroupRequest, BulkCategorizeRequest, BulkTagsRequest, LinkTransferRequest, TransactionCreate, TransactionRead, TransactionUpdate, TransferCreate, TransferRead
from app.services import transaction_service
from app.services.admin_service import get_credit_card_accounting_mode
@@ -181,6 +181,25 @@ async def bulk_remove_tags(
return {"updated": count}
[email protected]("/bulk-add-to-group")
+async def bulk_add_to_group(
+ data: BulkAddToGroupRequest,
+ session: AsyncSession = Depends(get_async_session),
+ user: User = Depends(current_active_user),
+):
+ try:
+ return await transaction_service.bulk_add_to_group(
+ session,
+ user.id,
+ data.transaction_ids,
+ data.group_id,
+ share_type=data.share_type,
+ member_splits=data.member_splits,
+ )
+ except ValueError as e:
+ raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+
+
@router.post("/transfer", response_model=TransferRead, status_code=status.HTTP_201_CREATED)
async def create_transfer(
data: TransferCreate,
diff --git a/backend/app/schemas/transaction.py b/backend/app/schemas/transaction.py
index 01d29478..6bb5f4f3 100644
--- a/backend/app/schemas/transaction.py
+++ b/backend/app/schemas/transaction.py
@@ -1,12 +1,13 @@
import uuid
from datetime import date as _Date
from decimal import Decimal
-from typing import Optional
+from typing import Literal, Optional
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
from app.schemas.category import CategoryRead
from app.schemas.transaction_split import (
+ TransactionSplitInput,
TransactionSplitRead,
TransactionSplitsInput,
)
@@ -101,6 +102,18 @@ class BulkCategorizeRequest(BaseModel):
category_id: Optional[uuid.UUID] = None
+class BulkAddToGroupRequest(BaseModel):
+ transaction_ids: list[uuid.UUID]
+ group_id: uuid.UUID
+ # Bulk supports `equal` and `percent` only — `exact` amounts can't
+ # generalize across transactions of different totals.
+ share_type: Literal["equal", "percent"] = "equal"
+ # Subset of group members to include. Each entry's `share_pct` is
+ # required when share_type='percent' (and must sum to 100). For
+ # share_type='equal' only `group_member_id` is read.
+ member_splits: list[TransactionSplitInput] = Field(default_factory=list)
+
+
class TransferCreate(BaseModel):
from_account_id: uuid.UUID
to_account_id: uuid.UUID
diff --git a/backend/app/services/transaction_service.py b/backend/app/services/transaction_service.py
index 230c0965..759283fc 100644
--- a/backend/app/services/transaction_service.py
+++ b/backend/app/services/transaction_service.py
@@ -11,8 +11,10 @@ from app.models.transaction import Transaction
from app.models.transaction_attachment import TransactionAttachment
from app.models.account import Account
from app.models.bank_connection import BankConnection
+from app.models.group import Group, GroupMember
from app.models.payee import Payee
from app.schemas.transaction import TransactionCreate, TransactionUpdate, TransferCreate
+from app.schemas.transaction_split import TransactionSplitInput, TransactionSplitsInput
from app.services import split_service
from app.services.credit_card_service import apply_effective_date
from app.services.rule_service import apply_rules_to_transaction
@@ -1037,6 +1039,90 @@ async def bulk_remove_tags(
return touched
+async def bulk_add_to_group(
+ session: AsyncSession,
+ user_id: uuid.UUID,
+ transaction_ids: list[uuid.UUID],
+ group_id: uuid.UUID,
+ share_type: str = "equal",
+ member_splits: Optional[list[TransactionSplitInput]] = None,
+) -> dict[str, int]:
+ """Apply the same group-split configuration to every selected transaction.
+
+ Supports `share_type` of "equal" or "percent" only — exact amounts
+ can't generalize across transactions of different totals.
+
+ Conservative semantics (issue #156): transactions that are transfers
+ or already have splits are skipped — never overwritten — so the
+ operation can't destroy prior splitting work.
+ """
+ if share_type not in ("equal", "percent"):
+ raise ValueError(
+ "Bulk add-to-group only supports share_type 'equal' or 'percent' — "
+ "use the per-transaction dialog for exact amounts"
+ )
+
+ if not transaction_ids:
+ return {"updated": 0, "skipped": 0}
+
+ group_result = await session.execute(
+ select(Group).where(Group.id == group_id, Group.user_id == user_id)
+ )
+ group = group_result.scalar_one_or_none()
+ if group is None:
+ raise ValueError("Group not found")
+
+ members_result = await session.execute(
+ select(GroupMember).where(GroupMember.group_id == group_id)
+ )
+ members = members_result.scalars().all()
+ if not members:
+ raise ValueError("Group has no members")
+
+ valid_member_ids = {m.id for m in members}
+
+ # If the caller didn't specify, default to all members (the previous
+ # behavior). Otherwise honor the subset they chose.
+ if not member_splits:
+ chosen = [TransactionSplitInput(group_member_id=m.id) for m in members]
+ else:
+ chosen = list(member_splits)
+
+ if not chosen:
+ raise ValueError("At least one member must be selected")
+
+ for entry in chosen:
+ if entry.group_member_id not in valid_member_ids:
+ raise ValueError("One or more split members not found")
+
+ payload = TransactionSplitsInput(share_type=share_type, splits=chosen)
+
+ txs_result = await session.execute(
+ select(Transaction)
+ .where(
+ Transaction.id.in_(transaction_ids),
+ Transaction.user_id == user_id,
+ )
+ .options(selectinload(Transaction.splits))
+ )
+ txs = txs_result.scalars().all()
+
+ updated = 0
+ skipped = 0
+ for tx in txs:
+ if tx.transfer_pair_id is not None or tx.splits:
+ skipped += 1
+ continue
+ await split_service.replace_splits(session, tx, payload, user_id)
+ updated += 1
+
+ # Account for ids that didn't match (wrong user, deleted, etc.)
+ skipped += len(set(transaction_ids)) - len(txs)
+
+ await session.commit()
+ return {"updated": updated, "skipped": skipped}
+
+
async def delete_transaction(
session: AsyncSession, transaction_id: uuid.UUID, user_id: uuid.UUID
) -> bool:
diff --git a/backend/tests/test_transactions_bulk_add_to_group.py b/backend/tests/test_transactions_bulk_add_to_group.py
new file mode 100644
index 00000000..2e372a41
--- /dev/null
+++ b/backend/tests/test_transactions_bulk_add_to_group.py
@@ -0,0 +1,296 @@
+"""Tests for bulk-add-to-group (issue #156).
+
+Conservative semantics: equal split across all members; transactions that
+are transfers or already have splits are skipped, never overwritten.
+"""
+
+import pytest
+from httpx import AsyncClient
+
+
+async def _create_account(client: AsyncClient, auth_headers, name="Wallet") -> dict:
+ resp = await client.post(
+ "/api/accounts",
+ headers=auth_headers,
+ json={"name": name, "type": "checking", "balance": 0, "currency": "USD"},
+ )
+ assert resp.status_code in (200, 201), resp.text
+ return resp.json()
+
+
+async def _create_group_with_members(client, auth_headers, *names):
+ g = (
+ await client.post(
+ "/api/groups",
+ headers=auth_headers,
+ json={"name": f"Trip-{names[0]}", "kind": "social", "default_currency": "USD"},
+ )
+ ).json()
+ members = []
+ for n in names:
+ m = (
+ await client.post(
+ f"/api/groups/{g['id']}/members",
+ headers=auth_headers,
+ json={"name": n, "is_self": n == names[0]},
+ )
+ ).json()
+ members.append(m)
+ return g, members
+
+
+async def _create_tx(client, auth_headers, account_id, amount=100, description="X"):
+ resp = await client.post(
+ "/api/transactions",
+ headers=auth_headers,
+ json={
+ "account_id": account_id,
+ "description": description,
+ "amount": amount,
+ "date": "2026-04-28",
+ "type": "debit",
+ "currency": "USD",
+ },
+ )
+ assert resp.status_code == 201, resp.text
+ return resp.json()
+
+
+async def test_bulk_add_to_group_equal_split(client, auth_headers):
+ account = await _create_account(client, auth_headers)
+ _, members = await _create_group_with_members(client, auth_headers, "Me", "A", "B")
+ group_id = members[0]["group_id"]
+
+ tx1 = await _create_tx(client, auth_headers, account["id"], amount=99)
+ tx2 = await _create_tx(client, auth_headers, account["id"], amount=60)
+
+ resp = await client.patch(
+ "/api/transactions/bulk-add-to-group",
+ headers=auth_headers,
+ json={"transaction_ids": [tx1["id"], tx2["id"]], "group_id": group_id},
+ )
+ assert resp.status_code == 200, resp.text
+ body = resp.json()
+ assert body == {"updated": 2, "skipped": 0}
+
+ # Verify splits materialized for both
+ full1 = (await client.get(f"/api/transactions/{tx1['id']}", headers=auth_headers)).json()
+ assert len(full1["splits"]) == 3
+ assert abs(sum(float(s["share_amount"]) for s in full1["splits"]) - 99.0) < 0.01
+
+ full2 = (await client.get(f"/api/transactions/{tx2['id']}", headers=auth_headers)).json()
+ assert len(full2["splits"]) == 3
+ assert abs(sum(float(s["share_amount"]) for s in full2["splits"]) - 60.0) < 0.01
+
+
+async def test_bulk_add_skips_already_split(client, auth_headers):
+ """A tx that already has splits must not be overwritten."""
+ account = await _create_account(client, auth_headers)
+ _, members = await _create_group_with_members(client, auth_headers, "Me", "A")
+ group_id = members[0]["group_id"]
+
+ # Pre-split tx with exact amounts that the bulk equal-split would *not* produce.
+ pre = await client.post(
+ "/api/transactions",
+ headers=auth_headers,
+ json={
+ "account_id": account["id"],
+ "description": "Pre-split",
+ "amount": 100,
+ "date": "2026-04-28",
+ "type": "debit",
+ "currency": "USD",
+ "splits": {
+ "share_type": "exact",
+ "splits": [
+ {"group_member_id": members[0]["id"], "share_amount": "30.00"},
+ {"group_member_id": members[1]["id"], "share_amount": "70.00"},
+ ],
+ },
+ },
+ )
+ assert pre.status_code == 201, pre.text
+ pre_tx = pre.json()
+
+ fresh = await _create_tx(client, auth_headers, account["id"], amount=50)
+
+ resp = await client.patch(
+ "/api/transactions/bulk-add-to-group",
+ headers=auth_headers,
+ json={"transaction_ids": [pre_tx["id"], fresh["id"]], "group_id": group_id},
+ )
+ assert resp.status_code == 200, resp.text
+ assert resp.json() == {"updated": 1, "skipped": 1}
+
+ # Pre-existing splits preserved exactly.
+ refreshed = (await client.get(f"/api/transactions/{pre_tx['id']}", headers=auth_headers)).json()
+ by_member = {s["group_member_id"]: float(s["share_amount"]) for s in refreshed["splits"]}
+ assert by_member[members[0]["id"]] == 30.0
+ assert by_member[members[1]["id"]] == 70.0
+
+
+async def test_bulk_add_skips_transfers(client, auth_headers):
+ src = await _create_account(client, auth_headers, name="Src")
+ dst = await _create_account(client, auth_headers, name="Dst")
+ _, members = await _create_group_with_members(client, auth_headers, "Me", "A")
+ group_id = members[0]["group_id"]
+
+ transfer = await client.post(
+ "/api/transactions/transfer",
+ headers=auth_headers,
+ json={
+ "from_account_id": src["id"],
+ "to_account_id": dst["id"],
+ "description": "Move",
+ "amount": 200,
+ "date": "2026-04-28",
+ },
+ )
+ assert transfer.status_code == 201, transfer.text
+ debit_id = transfer.json()["debit"]["id"]
+
+ fresh = await _create_tx(client, auth_headers, src["id"], amount=40)
+
+ resp = await client.patch(
+ "/api/transactions/bulk-add-to-group",
+ headers=auth_headers,
+ json={"transaction_ids": [debit_id, fresh["id"]], "group_id": group_id},
+ )
+ assert resp.status_code == 200, resp.text
+ assert resp.json() == {"updated": 1, "skipped": 1}
+
+
+async def test_bulk_add_unknown_group_returns_400(client, auth_headers):
+ account = await _create_account(client, auth_headers)
+ fresh = await _create_tx(client, auth_headers, account["id"], amount=10)
+
+ bogus_group = "00000000-0000-0000-0000-000000000000"
+ resp = await client.patch(
+ "/api/transactions/bulk-add-to-group",
+ headers=auth_headers,
+ json={"transaction_ids": [fresh["id"]], "group_id": bogus_group},
+ )
+ assert resp.status_code == 400, resp.text
+ assert "Group" in resp.json()["detail"]
+
+
+async def test_bulk_add_percent_split(client, auth_headers):
+ """Same percentages applied to each tx — sums must match each tx's amount."""
+ account = await _create_account(client, auth_headers)
+ _, members = await _create_group_with_members(client, auth_headers, "Me", "A", "B")
+ group_id = members[0]["group_id"]
+
+ tx1 = await _create_tx(client, auth_headers, account["id"], amount=120)
+ tx2 = await _create_tx(client, auth_headers, account["id"], amount=80)
+
+ resp = await client.patch(
+ "/api/transactions/bulk-add-to-group",
+ headers=auth_headers,
+ json={
+ "transaction_ids": [tx1["id"], tx2["id"]],
+ "group_id": group_id,
+ "share_type": "percent",
+ "member_splits": [
+ {"group_member_id": members[0]["id"], "share_pct": "50"},
+ {"group_member_id": members[1]["id"], "share_pct": "30"},
+ {"group_member_id": members[2]["id"], "share_pct": "20"},
+ ],
+ },
+ )
+ assert resp.status_code == 200, resp.text
+ assert resp.json() == {"updated": 2, "skipped": 0}
+
+ full1 = (await client.get(f"/api/transactions/{tx1['id']}", headers=auth_headers)).json()
+ by_member1 = {s["group_member_id"]: float(s["share_amount"]) for s in full1["splits"]}
+ assert by_member1[members[0]["id"]] == 60.0 # 50% of 120
+ assert by_member1[members[1]["id"]] == 36.0 # 30% of 120
+
+ full2 = (await client.get(f"/api/transactions/{tx2['id']}", headers=auth_headers)).json()
+ by_member2 = {s["group_member_id"]: float(s["share_amount"]) for s in full2["splits"]}
+ assert by_member2[members[0]["id"]] == 40.0 # 50% of 80
+ assert by_member2[members[1]["id"]] == 24.0 # 30% of 80
+
+
+async def test_bulk_add_partial_member_subset(client, auth_headers):
+ """Only the explicitly chosen members get a share."""
+ account = await _create_account(client, auth_headers)
+ _, members = await _create_group_with_members(client, auth_headers, "Me", "A", "B")
+ group_id = members[0]["group_id"]
+
+ tx = await _create_tx(client, auth_headers, account["id"], amount=100)
+
+ resp = await client.patch(
+ "/api/transactions/bulk-add-to-group",
+ headers=auth_headers,
+ json={
+ "transaction_ids": [tx["id"]],
+ "group_id": group_id,
+ "share_type": "equal",
+ "member_splits": [
+ {"group_member_id": members[0]["id"]},
+ {"group_member_id": members[1]["id"]},
+ ],
+ },
+ )
+ assert resp.status_code == 200, resp.text
+ full = (await client.get(f"/api/transactions/{tx['id']}", headers=auth_headers)).json()
+ assert len(full["splits"]) == 2
+ assert {s["group_member_id"] for s in full["splits"]} == {members[0]["id"], members[1]["id"]}
+
+
+async def test_bulk_add_rejects_exact_share_type(client, auth_headers):
+ """Exact amounts can't generalize across many txs — must be 400."""
+ account = await _create_account(client, auth_headers)
+ _, members = await _create_group_with_members(client, auth_headers, "Me", "A")
+ group_id = members[0]["group_id"]
+
+ tx = await _create_tx(client, auth_headers, account["id"], amount=100)
+
+ resp = await client.patch(
+ "/api/transactions/bulk-add-to-group",
+ headers=auth_headers,
+ json={
+ "transaction_ids": [tx["id"]],
+ "group_id": group_id,
+ "share_type": "exact",
+ "member_splits": [
+ {"group_member_id": members[0]["id"], "share_amount": "60"},
+ {"group_member_id": members[1]["id"], "share_amount": "40"},
+ ],
+ },
+ )
+ # Pydantic Literal["equal","percent"] rejects with 422; if Literal
+ # constraint is removed in the future the service catches it as 400.
+ assert resp.status_code in (400, 422), resp.text
+
+
+async def test_bulk_add_percent_must_sum_to_100(client, auth_headers):
+ account = await _create_account(client, auth_headers)
+ _, members = await _create_group_with_members(client, auth_headers, "Me", "A")
+ group_id = members[0]["group_id"]
+
+ tx = await _create_tx(client, auth_headers, account["id"], amount=100)
+
+ resp = await client.patch(
+ "/api/transactions/bulk-add-to-group",
+ headers=auth_headers,
+ json={
+ "transaction_ids": [tx["id"]],
+ "group_id": group_id,
+ "share_type": "percent",
+ "member_splits": [
+ {"group_member_id": members[0]["id"], "share_pct": "60"},
+ {"group_member_id": members[1]["id"], "share_pct": "30"},
+ ],
+ },
+ )
+ assert resp.status_code == 400, resp.text
+ assert "100" in resp.json()["detail"]
diff --git a/frontend/src/components/bulk-add-to-group-dialog.tsx b/frontend/src/components/bulk-add-to-group-dialog.tsx
new file mode 100644
index 00000000..950d96b9
--- /dev/null
+++ b/frontend/src/components/bulk-add-to-group-dialog.tsx
@@ -0,0 +1,278 @@
+import { useMemo, useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import { useQuery } from '@tanstack/react-query'
+
+import { groups as groupsApi } from '@/lib/api'
+import { Button } from '@/components/ui/button'
+import {
+ Dialog,
+ DialogContent,
+ DialogFooter,
+ DialogHeader,
+ DialogTitle,
+} from '@/components/ui/dialog'
+import { Input } from '@/components/ui/input'
+import { Label } from '@/components/ui/label'
+
+type BulkShareType = 'equal' | 'percent'
+
+interface MemberSelection {
+ selected: boolean
+ percent: string
+}
+
+export interface BulkAddToGroupSubmission {
+ groupId: string
+ share_type: BulkShareType
+ member_splits: { group_member_id: string; share_pct?: number }[]
+}
+
+export function BulkAddToGroupDialog({
+ open,
+ onClose,
+ selectedCount,
+ onSubmit,
+ isPending,
+}: {
+ open: boolean
+ onClose: () => void
+ selectedCount: number
+ onSubmit: (payload: BulkAddToGroupSubmission) => void
+ isPending: boolean
+}) {
+ return (
+ <Dialog open={open} onOpenChange={(v) => { if (!v) onClose() }}>
+ <DialogContent className="sm:max-w-md">
+ {/* DialogContent only renders while open, so the form below
+ mounts fresh on every open and unmounts on close — no
+ reset effects needed. */}
+ <BulkAddToGroupForm
+ selectedCount={selectedCount}
+ onCancel={onClose}
+ onSubmit={onSubmit}
+ isPending={isPending}
+ />
+ </DialogContent>
+ </Dialog>
+ )
+}
+
+function BulkAddToGroupForm({
+ selectedCount,
+ onCancel,
+ onSubmit,
+ isPending,
+}: {
+ selectedCount: number
+ onCancel: () => void
+ onSubmit: (payload: BulkAddToGroupSubmission) => void
+ isPending: boolean
+}) {
+ const { t } = useTranslation()
+ // Track only the user's explicit group choice — the effective `groupId`
+ // is derived below so we don't need an effect to "auto-pick" the first
+ // group when data arrives.
+ const [explicitGroupId, setExplicitGroupId] = useState<string | null>(null)
+ const [shareType, setShareType] = useState<BulkShareType>('equal')
+ // Per-member selection state, keyed by member id. Members not present in
+ // the map use defaults (selected, empty percent) so we don't need an
+ // effect to seed the rows when the group query resolves.
+ const [selectionByMember, setSelectionByMember] = useState<Record<string, MemberSelection>>({})
+
+ const { data: groups } = useQuery({
+ queryKey: ['groups'],
+ queryFn: () => groupsApi.list(false),
+ })
+
+ const ownedGroups = useMemo(
+ () => (groups ?? []).filter((g) => g.is_owner && !g.is_archived),
+ [groups],
+ )
+
+ const groupId = explicitGroupId ?? ownedGroups[0]?.id ?? ''
+
+ const { data: group } = useQuery({
+ queryKey: ['groups', groupId],
+ queryFn: () => groupsApi.get(groupId),
+ enabled: !!groupId,
+ })
+
+ const rows = useMemo(
+ () =>
+ (group?.members ?? []).map((m) => ({
+ member_id: m.id,
+ selected: selectionByMember[m.id]?.selected ?? true,
+ percent: selectionByMember[m.id]?.percent ?? '',
+ })),
+ [group, selectionByMember],
+ )
+
+ const updateRow = (memberId: string, patch: Partial<MemberSelection>) => {
+ setSelectionByMember((prev) => ({
+ ...prev,
+ [memberId]: {
+ selected: prev[memberId]?.selected ?? true,
+ percent: prev[memberId]?.percent ?? '',
+ ...patch,
+ },
+ }))
+ }
+
+ const selectedRows = rows.filter((r) => r.selected)
+
+ const percentSum = useMemo(() => {
+ if (shareType !== 'percent') return null
+ return selectedRows.reduce((s, r) => s + (parseFloat(r.percent) || 0), 0)
+ }, [shareType, selectedRows])
+
+ const isValid = useMemo(() => {
+ if (!groupId) return false
+ if (selectedRows.length === 0) return false
+ if (shareType === 'equal') return true
+ return Math.abs((percentSum ?? 0) - 100) < 0.005
+ }, [groupId, selectedRows, shareType, percentSum])
+
+ const handleSubmit = () => {
+ if (!isValid) return
+ onSubmit({
+ groupId,
+ share_type: shareType,
+ member_splits: selectedRows.map((r) => {
+ if (shareType === 'percent') {
+ return {
+ group_member_id: r.member_id,
+ share_pct: parseFloat(r.percent) || 0,
+ }
+ }
+ return { group_member_id: r.member_id }
+ }),
+ })
+ }
+
+ return (
+ <>
+ <DialogHeader>
+ <DialogTitle>
+ {t('transactions.bulkAddToGroupTitle', { count: selectedCount })}
+ </DialogTitle>
+ </DialogHeader>
+
+ {ownedGroups.length === 0 ? (
+ <p className="text-sm text-muted-foreground py-2">
+ {t('splitGroups.splitNoGroups')}
+ </p>
+ ) : (
+ <div className="space-y-4">
+ <div className="grid grid-cols-2 gap-3">
+ <div className="space-y-1">
+ <Label className="text-xs">{t('splitGroups.group')}</Label>
+ <select
+ className="w-full border border-border rounded-md px-2 py-1.5 text-sm bg-background"
+ value={groupId}
+ onChange={(e) => setExplicitGroupId(e.target.value)}
+ >
+ {ownedGroups.map((g) => (
+ <option key={g.id} value={g.id}>{g.name}</option>
+ ))}
+ </select>
+ </div>
+ <div className="space-y-1">
+ <Label className="text-xs">{t('splitGroups.shareType')}</Label>
+ <select
+ className="w-full border border-border rounded-md px-2 py-1.5 text-sm bg-background"
+ value={shareType}
+ onChange={(e) => setShareType(e.target.value as BulkShareType)}
+ >
+ <option value="equal">{t('splitGroups.shareEqual')}</option>
+ <option value="percent">{t('splitGroups.sharePercent')}</option>
+ </select>
+ </div>
+ </div>
+
+ <p className="text-xs text-muted-foreground">
+ {t('transactions.bulkAddToGroupExactHint')}
+ </p>
+
+ {group && (
+ <div className="space-y-2 max-h-64 overflow-y-auto pr-1">
+ {group.members.length === 0 ? (
+ <p className="text-xs text-muted-foreground">
+ {t('splitGroups.splitNoMembers')}
+ </p>
+ ) : (
+ group.members.map((m) => {
+ const row = rows.find((r) => r.member_id === m.id)
+ if (!row) return null
+ return (
+ <div key={m.id} className="flex items-center gap-2">
+ <input
+ type="checkbox"
+ checked={row.selected}
+ onChange={(e) =>
+ updateRow(m.id, { selected: e.target.checked })
+ }
+ className="h-4 w-4 rounded border-border accent-primary"
+ />
+ <span className="text-sm flex-1 min-w-0 truncate">
+ {m.name}
+ {m.is_self && (
+ <span className="ml-1.5 text-xs text-primary">
+ ({t('splitGroups.you')})
+ </span>
+ )}
+ </span>
+ {shareType === 'percent' && row.selected && (
+ <div className="flex items-center gap-1">
+ <Input
+ type="number"
+ step="0.01"
+ className="w-20 h-8 text-sm"
+ value={row.percent}
+ onChange={(e) => updateRow(m.id, { percent: e.target.value })}
+ />
+ <span className="text-xs text-muted-foreground">%</span>
+ </div>
+ )}
+ </div>
+ )
+ })
+ )}
+ </div>
+ )}
+
+ {shareType === 'percent' && percentSum !== null && selectedRows.length > 0 && (
+ <div className="text-xs">
+ <span
+ className={
+ Math.abs(percentSum - 100) < 0.005
+ ? 'text-emerald-600'
+ : 'text-amber-600'
+ }
+ >
+ {t('splitGroups.percentSum', { total: percentSum.toFixed(2) })}
+ </span>
+ </div>
+ )}
+
+ {shareType === 'equal' && selectedRows.length > 0 && (
+ <p className="text-xs text-muted-foreground">
+ {t('splitGroups.equalHint')}
+ </p>
+ )}
+ </div>
+ )}
+
+ <DialogFooter>
+ <Button variant="ghost" onClick={onCancel} disabled={isPending}>
+ {t('common.cancel', 'Cancel')}
+ </Button>
+ <Button
+ onClick={handleSubmit}
+ disabled={!isValid || isPending || ownedGroups.length === 0}
+ >
+ {t('transactions.bulkAddToGroupSubmit')}
+ </Button>
+ </DialogFooter>
+ </>
+ )
+}
diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts
index 1635294e..0e86068e 100644
--- a/frontend/src/lib/api.ts
+++ b/frontend/src/lib/api.ts
@@ -330,6 +330,22 @@ export const transactions = {
})
return data
},
+ bulkAddToGroup: async (
+ transactionIds: string[],
+ groupId: string,
+ options?: {
+ share_type?: 'equal' | 'percent'
+ member_splits?: { group_member_id: string; share_pct?: number }[]
+ },
+ ): Promise<{ updated: number; skipped: number }> => {
+ const { data } = await api.patch('/transactions/bulk-add-to-group', {
+ transaction_ids: transactionIds,
+ group_id: groupId,
+ ...(options?.share_type ? { share_type: options.share_type } : {}),
+ ...(options?.member_splits ? { member_splits: options.member_splits } : {}),
+ })
+ return data
+ },
linkTransfer: async (transactionIds: string[]): Promise<{ debit: Transaction; credit: Transaction; transfer_pair_id: string }> => {
const { data } = await api.post('/transactions/link-transfer', {
transaction_ids: transactionIds,
diff --git a/frontend/src/locales/en.json b/frontend/src/locales/en.json
index ccbce027..64e196ba 100644
--- a/frontend/src/locales/en.json
+++ b/frontend/src/locales/en.json
@@ -193,6 +193,12 @@
"bulkCategorize": "Apply",
"bulkSuccess": "{{count}} transactions categorized",
"selectCategory": "Select category...",
+ "addToGroup": "Add to group",
+ "bulkAddToGroupTitle": "Add {{count}} transactions to a group",
+ "bulkAddToGroupSubmit": "Add to group",
+ "bulkAddToGroupExactHint": "Exact amounts must be set per transaction. Use Equal or Percent to apply the same rule across all selected.",
+ "bulkAddToGroupSuccess": "{{count}} transactions added to group",
+ "bulkAddToGroupPartial": "{{added}} added to group, {{skipped}} skipped (transfers or already split)",
"noResults": "No transactions found",
"previous": "Previous",
"next": "Next",
diff --git a/frontend/src/locales/pt-BR.json b/frontend/src/locales/pt-BR.json
index bc073a34..ea73425f 100644
--- a/frontend/src/locales/pt-BR.json
+++ b/frontend/src/locales/pt-BR.json
@@ -193,6 +193,12 @@
"bulkCategorize": "Aplicar",
"bulkSuccess": "{{count}} transações categorizadas",
"selectCategory": "Selecionar categoria...",
+ "addToGroup": "Adicionar ao grupo",
+ "bulkAddToGroupTitle": "Adicionar {{count}} transações a um grupo",
+ "bulkAddToGroupSubmit": "Adicionar ao grupo",
+ "bulkAddToGroupExactHint": "Valores exatos precisam ser definidos por transação. Use Igual ou Porcentagem para aplicar a mesma regra em todas as selecionadas.",
+ "bulkAddToGroupSuccess": "{{count}} transações adicionadas ao grupo",
+ "bulkAddToGroupPartial": "{{added}} adicionadas ao grupo, {{skipped}} ignoradas (transferências ou já divididas)",
"noResults": "Nenhuma transação encontrada",
"previous": "Anterior",
"next": "Próxima",
diff --git a/frontend/src/pages/transactions.tsx b/frontend/src/pages/transactions.tsx
index 0f3e1ade..5987a17d 100644
--- a/frontend/src/pages/transactions.tsx
+++ b/frontend/src/pages/transactions.tsx
@@ -23,13 +23,14 @@ import {
TableRow,
} from '@/components/ui/table'
import { Skeleton } from '@/components/ui/skeleton'
-import { AlertTriangle, ArrowLeftRight, Check, Download, HelpCircle, Info, Paperclip, X } from 'lucide-react'
+import { AlertTriangle, ArrowLeftRight, Check, Download, HelpCircle, Info, Paperclip, Users, X } from 'lucide-react'
import type { Transaction } from '@/types'
import { PageHeader } from '@/components/page-header'
import { CategoryIcon } from '@/components/category-icon'
import { TransactionDialog, extractApiError, type SaveAction } from '@/components/transaction-dialog'
import { TransferDialog } from '@/components/transfer-dialog'
import { LinkTransferDialog } from '@/components/link-transfer-dialog'
+import { BulkAddToGroupDialog, type BulkAddToGroupSubmission } from '@/components/bulk-add-to-group-dialog'
import { TransactionsFilterBar } from '@/components/transactions-filter-bar'
import { usePrivacyMode } from '@/hooks/use-privacy-mode'
import { useAuth } from '@/contexts/auth-context'
@@ -122,6 +123,7 @@ export default function TransactionsPage() {
const [linkTransferDialogOpen, setLinkTransferDialogOpen] = useState(false)
const [selectedIds, setSelectedIds] = useState<Set<string>>(new Set())
const [bulkCategory, setBulkCategory] = useState<string>('')
+ const [bulkAddToGroupOpen, setBulkAddToGroupOpen] = useState(false)
const [bulkTagInput, setBulkTagInput] = useState<string>('')
const debounceRef = useRef<ReturnType<typeof setTimeout>>(null)
const highlightId = searchParams.get('highlight')
@@ -367,6 +369,27 @@ export default function TransactionsPage() {
},
})
+ const bulkAddToGroupMutation = useMutation({
+ mutationFn: ({ ids, payload }: { ids: string[]; payload: BulkAddToGroupSubmission }) =>
+ transactions.bulkAddToGroup(ids, payload.groupId, {
+ share_type: payload.share_type,
+ member_splits: payload.member_splits,
+ }),
+ onSuccess: (result) => {
+ invalidateAfterTxMutation()
+ setSelectedIds(new Set())
+ setBulkAddToGroupOpen(false)
+ if (result.skipped > 0) {
+ toast.success(t('transactions.bulkAddToGroupPartial', { added: result.updated, skipped: result.skipped }))
+ } else {
+ toast.success(t('transactions.bulkAddToGroupSuccess', { count: result.updated }))
+ }
+ },
+ onError: (error) => {
+ toast.error(extractApiError(error))
+ },
+ })
+
const linkTransferMutation = useMutation({
mutationFn: (ids: [string, string]) => transactions.linkTransfer(ids),
onSuccess: () => {
@@ -886,7 +909,7 @@ export default function TransactionsPage() {
<div
className={`fixed bottom-0 left-0 right-0 z-50 transition-transform duration-200 ease-out ${selectedIds.size > 0 ? 'translate-y-0' : 'translate-y-full'}`}
>
- <div className="mx-auto max-w-5xl px-3 md:px-4 pb-4 md:pb-6">
+ <div className="mx-auto max-w-6xl px-3 md:px-4 pb-4 md:pb-6">
<div className="flex items-stretch gap-1.5 bg-card border border-border shadow-xl rounded-2xl p-2">
{/* Selection count */}
<div className="flex items-center gap-2 pl-3 pr-4 text-sm font-medium text-foreground whitespace-nowrap">
@@ -919,6 +942,22 @@ export default function TransactionsPage() {
<div className="w-px bg-border/60 self-stretch" />
+ {/* Add to group — opens a dialog to configure share type and
+ members. Mirrors the per-tx splits options (issue #156). */}
+ <Button
+ size="sm"
+ variant="ghost"
+ disabled={bulkAddToGroupMutation.isPending}
+ onClick={() => setBulkAddToGroupOpen(true)}
+ title={t('transactions.addToGroup')}
+ className="h-8 px-3 shrink-0 text-sm"
+ >
+ <Users size={15} className="lg:mr-1.5" />
+ <span className="hidden lg:inline">{t('transactions.addToGroup')}</span>
+ </Button>
+
+ <div className="w-px bg-border/60 self-stretch" />
+
{/* Add tags inline */}
<div className="flex items-center gap-1 px-1">
<input
@@ -980,6 +1019,17 @@ export default function TransactionsPage() {
</div>
</div>
+ {/* Bulk Add-to-Group Dialog */}
+ <BulkAddToGroupDialog
+ open={bulkAddToGroupOpen}
+ onClose={() => setBulkAddToGroupOpen(false)}
+ selectedCount={selectedIds.size}
+ onSubmit={(payload) =>
+ bulkAddToGroupMutation.mutate({ ids: Array.from(selectedIds), payload })
+ }
+ isPending={bulkAddToGroupMutation.isPending}
+ />
+
{/* Link Transfer Dialog */}
<LinkTransferDialog
open={linkTransferDialogOpen}