feat: Kontakt-Ordner mit Drag&Drop Baum (wie KI-Chat Sidebar)

- Backend: ContactFolder model (hierarchisch, parent_id, sort_order)
- Migration 0022: contact_folders Tabelle + folder_id FK auf contacts
- CRUD Routes: /api/v1/contact-folders (list, create, update, delete, reorder)
- Move Contact API: /api/v1/contact-folders/contacts/{id}/move
- folder_id Filter in contacts list API
- Frontend: ContactFolderTree mit Baum-Struktur, Drag&Drop, Kontext-Menü
- Kontakt-Personen-Icon statt Ordner-Symbol
- ContactList Items draggable (List/Table/Cards View)
- React Query Hooks für Folder CRUD + Move Contact
- Alle 266 Frontend-Tests passing

app/services/contact_folder_service.py

@@ -0,0 +1,194 @@
+"""Contact folder service — CRUD, tree building, move contacts."""
+
+from __future__ import annotations
+
+import uuid
+from typing import Any
+
+from sqlalchemy import func, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.models.contact import Contact
+from app.models.contact_folder import ContactFolder
+
+
+def _serialize_folder(f: ContactFolder, contact_count: int = 0) -> dict:
+    return {
+        "id": str(f.id),
+        "name": f.name,
+        "parent_id": str(f.parent_id) if f.parent_id else None,
+        "user_id": str(f.user_id),
+        "sort_order": f.sort_order,
+        "contact_count": contact_count,
+    }
+
+
+async def list_folders(
+    db: AsyncSession, tenant_id: uuid.UUID, user_id: uuid.UUID
+) -> list[dict]:
+    """List all folders for a user (flat list, frontend builds tree)."""
+    result = await db.execute(
+        select(ContactFolder)
+        .where(ContactFolder.tenant_id == tenant_id)
+        .where(ContactFolder.user_id == user_id)
+        .where(ContactFolder.deleted_at.is_(None))
+        .order_by(ContactFolder.parent_id, ContactFolder.sort_order, ContactFolder.name)
+    )
+    folders = result.scalars().all()
+
+    # Count contacts per folder
+    folder_ids = [f.id for f in folders]
+    counts: dict[uuid.UUID, int] = {}
+    if folder_ids:
+        count_result = await db.execute(
+            select(Contact.folder_id, func.count(Contact.id))
+            .where(Contact.folder_id.in_(folder_ids))
+            .where(Contact.deleted_at.is_(None))
+            .group_by(Contact.folder_id)
+        )
+        for fid, cnt in count_result:
+            counts[fid] = cnt
+
+    return [
+        {**_serialize_folder(f), "contact_count": counts.get(f.id, 0)}
+        for f in folders
+    ]
+
+
+async def create_folder(
+    db: AsyncSession,
+    tenant_id: uuid.UUID,
+    user_id: uuid.UUID,
+    name: str,
+    parent_id: str | None = None,
+) -> dict:
+    """Create a new contact folder."""
+    parent_uuid = uuid.UUID(parent_id) if parent_id else None
+
+    # Determine sort_order: max + 1 among siblings
+    max_order_result = await db.execute(
+        select(func.max(ContactFolder.sort_order))
+        .where(ContactFolder.tenant_id == tenant_id)
+        .where(ContactFolder.user_id == user_id)
+        .where(ContactFolder.parent_id == parent_uuid if parent_uuid else ContactFolder.parent_id.is_(None))
+    )
+    max_order = max_order_result.scalar() or 0
+
+    folder = ContactFolder(
+        tenant_id=tenant_id,
+        user_id=user_id,
+        name=name,
+        parent_id=parent_uuid,
+        sort_order=max_order + 1,
+    )
+    db.add(folder)
+    await db.commit()
+    await db.refresh(folder)
+    return _serialize_folder(folder)
+
+
+async def update_folder(
+    db: AsyncSession,
+    tenant_id: uuid.UUID,
+    user_id: uuid.UUID,
+    folder_id: str,
+    data: dict,
+) -> dict:
+    """Update a contact folder (name, parent_id, sort_order)."""
+    result = await db.execute(
+        select(ContactFolder)
+        .where(ContactFolder.id == uuid.UUID(folder_id))
+        .where(ContactFolder.tenant_id == tenant_id)
+        .where(ContactFolder.user_id == user_id)
+        .where(ContactFolder.deleted_at.is_(None))
+    )
+    folder = result.scalar_one_or_none()
+    if not folder:
+        raise ValueError("Folder not found")
+
+    if "name" in data and data["name"]:
+        folder.name = data["name"]
+    if "parent_id" in data:
+        new_parent = data["parent_id"]
+        folder.parent_id = uuid.UUID(new_parent) if new_parent else None
+    if "sort_order" in data and data["sort_order"] is not None:
+        folder.sort_order = data["sort_order"]
+
+    await db.commit()
+    await db.refresh(folder)
+    return _serialize_folder(folder)
+
+
+async def delete_folder(
+    db: AsyncSession,
+    tenant_id: uuid.UUID,
+    user_id: uuid.UUID,
+    folder_id: str,
+) -> None:
+    """Delete a contact folder. Contacts are unassigned (folder_id SET NULL)."""
+    result = await db.execute(
+        select(ContactFolder)
+        .where(ContactFolder.id == uuid.UUID(folder_id))
+        .where(ContactFolder.tenant_id == tenant_id)
+        .where(ContactFolder.user_id == user_id)
+        .where(ContactFolder.deleted_at.is_(None))
+    )
+    folder = result.scalar_one_or_none()
+    if not folder:
+        raise ValueError("Folder not found")
+
+    # Unassign contacts in this folder (and subfolders via CASCADE on folder delete)
+    await db.execute(
+        update(Contact)
+        .where(Contact.folder_id == folder.id)
+        .values(folder_id=None)
+    )
+
+    await db.delete(folder)
+    await db.commit()
+
+
+async def move_contact(
+    db: AsyncSession,
+    tenant_id: uuid.UUID,
+    contact_id: str,
+    folder_id: str | None,
+) -> dict:
+    """Move a contact to a folder (or unassign with folder_id=None)."""
+    result = await db.execute(
+        select(Contact)
+        .where(Contact.id == uuid.UUID(contact_id))
+        .where(Contact.tenant_id == tenant_id)
+        .where(Contact.deleted_at.is_(None))
+    )
+    contact = result.scalar_one_or_none()
+    if not contact:
+        raise ValueError("Contact not found")
+
+    contact.folder_id = uuid.UUID(folder_id) if folder_id else None
+    await db.commit()
+    await db.refresh(contact)
+    return {"id": str(contact.id), "folder_id": str(contact.folder_id) if contact.folder_id else None}
+
+
+async def reorder_folders(
+    db: AsyncSession,
+    tenant_id: uuid.UUID,
+    user_id: uuid.UUID,
+    folder_orders: list[dict],
+) -> None:
+    """Batch update sort_order for folders. Each item: {id, sort_order, parent_id?}."""
+    for item in folder_orders:
+        fid = uuid.UUID(item["id"])
+        await db.execute(
+            update(ContactFolder)
+            .where(ContactFolder.id == fid)
+            .where(ContactFolder.tenant_id == tenant_id)
+            .where(ContactFolder.user_id == user_id)
+            .values(
+                sort_order=item.get("sort_order", 0),
+                parent_id=uuid.UUID(item["parent_id"]) if item.get("parent_id") else None,
+            )
+        )
+    await db.commit()

app/services/contact_service.py

@@ -90,6 +90,7 @@ def _serialize_contact(c: Contact) -> dict:
         "tags": c.tags,
         "image": c.image,
         "custom": c.custom,
+        "folder_id": str(c.folder_id) if c.folder_id else None,
         "default_person_id": str(c.default_person_id) if c.default_person_id else None,
         "admin_contactperson_id": str(c.admin_contactperson_id) if c.admin_contactperson_id else None,
         "created_at": c.created_at.isoformat() if c.created_at else None,
@@ -137,11 +138,12 @@ async def list_contacts(
     page_size: int = 20,
     search: str | None = None,
     contact_type: str | None = None,
+    folder_id: str | None = None,
     sort_by: str = "displayname",
     sort_order: str = "asc",
     resolved_perms: dict | None = None,
 ) -> dict:
-    """List contacts with pagination, FTS search, type filter, sorting."""
+    """List contacts with pagination, FTS search, type/folder filter, sorting."""
     base = select(Contact).where(
         Contact.tenant_id == tenant_id,
         Contact.deleted_at.is_(None),
@@ -150,6 +152,9 @@ async def list_contacts(
     if contact_type:
         base = base.where(Contact.type == contact_type)
 
+    if folder_id:
+        base = base.where(Contact.folder_id == uuid.UUID(folder_id))
+
     if search:
         base = base.where(
             Contact.search_tsv.op("@@")(func.plainto_tsquery("german", search))