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.pyindex 34c4c69b..bc271f67 100644--- a/backend/app/api/transactions.py+++ b/backend/app/api/transactions.py@@ -12,7 +12,7 @@ from sqlalchemy.ext.asyncio import AsyncSessionfrom app.core.auth import current_active_userfrom app.core.database import get_async_sessionfrom 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, TransferReadfrom app.services import transaction_servicefrom 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.pyindex 01d29478..6bb5f4f3 100644--- a/backend/app/schemas/transaction.py+++ b/backend/app/schemas/transaction.py@@ -1,12 +1,13 @@import uuidfrom datetime import date as _Datefrom decimal import Decimal-from typing import Optional+from typing import Literal, Optional-from pydantic import BaseModel, ConfigDict+from pydantic import BaseModel, ConfigDict, Fieldfrom app.schemas.category import CategoryReadfrom 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.UUIDto_account_id: uuid.UUIDdiff --git a/backend/app/services/transaction_service.py b/backend/app/services/transaction_service.pyindex 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 Transactionfrom app.models.transaction_attachment import TransactionAttachmentfrom app.models.account import Accountfrom app.models.bank_connection import BankConnection+from app.models.group import Group, GroupMemberfrom app.models.payee import Payeefrom app.schemas.transaction import TransactionCreate, TransactionUpdate, TransferCreate+from app.schemas.transaction_split import TransactionSplitInput, TransactionSplitsInputfrom app.services import split_servicefrom app.services.credit_card_service import apply_effective_datefrom 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.pynew file mode 100644index 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.tsxnew file mode 100644index 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.tsindex 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.jsonindex 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.jsonindex 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.tsxindex 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() {<divclassName={`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 */}<LinkTransferDialogopen={linkTransferDialogOpen}