feat: add Planka service provider with full notification and command support

Webhook-based provider for Planka (self-hosted Kanban board) with:
- 15 event types (cards, boards, lists, comments, tasks, attachments, labels)
- Bearer token webhook authentication
- Async API client for boards/cards/lists
- 30 notification templates (en/ru) + 26 command templates (en/ru)
- Bot commands: /status, /boards, /cards, /lists
- Default tracking config, template config, command config seeded on startup
- DB migration for 15 new tracking_config columns
- Frontend: provider config UI with auto-name, Planka-specific hints
- Frontend: tracking config event toggles for all 15 Planka events

packages/server/src/notify_bridge_server/api/webhooks.py

@@ -14,6 +14,7 @@ from sqlmodel.ext.asyncio.session import AsyncSession
 from notify_bridge_core.models.events import ServiceEvent
 from notify_bridge_core.notifications.dispatcher import NotificationDispatcher, TargetConfig
 from notify_bridge_core.providers.gitea.event_parser import parse_webhook as parse_gitea_webhook
+from notify_bridge_core.providers.planka.event_parser import parse_webhook as parse_planka_webhook
 
 from ..database.engine import get_engine
 from ..database.models import (
@@ -174,6 +175,118 @@ async def gitea_webhook(provider_id: int, request: Request):
     return {"ok": True, "dispatched": dispatched}
 
 
+# ---------------------------------------------------------------------------
+# Planka webhook endpoint
+# ---------------------------------------------------------------------------
+
+def _verify_planka_token(expected_token: str, request: Request) -> bool:
+    """Verify Planka webhook Bearer token."""
+    auth_header = request.headers.get("Authorization", "")
+    if auth_header.startswith("Bearer "):
+        token = auth_header[7:]
+        return hmac.compare_digest(token, expected_token)
+    return False
+
+
+@router.post("/planka/{provider_id}")
+async def planka_webhook(provider_id: int, request: Request):
+    """Receive a Planka webhook, parse it, filter, and dispatch notifications."""
+    engine = get_engine()
+
+    # --- Load provider and validate token ---
+    async with AsyncSession(engine) as session:
+        provider = await session.get(ServiceProvider, provider_id)
+        if not provider or provider.type != "planka":
+            raise HTTPException(status_code=404, detail="Provider not found")
+
+        webhook_secret = (provider.config or {}).get("webhook_secret", "")
+
+    if not webhook_secret:
+        raise HTTPException(
+            status_code=403,
+            detail="Webhook secret not configured on this provider",
+        )
+
+    if not _verify_planka_token(webhook_secret, request):
+        raise HTTPException(status_code=403, detail="Invalid token")
+
+    # Parse payload
+    try:
+        payload = await request.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid JSON")
+
+    event_type = payload.get("type", "")
+    if not event_type:
+        return {"ok": True, "skipped": "no event type"}
+
+    base_url = (provider.config or {}).get("url", "")
+    event = parse_planka_webhook(event_type, payload, provider.name, base_url=base_url)
+    if event is None:
+        return {"ok": True, "skipped": "unmapped event"}
+
+    # --- Find trackers for this provider and dispatch ---
+    dispatched = 0
+    async with AsyncSession(engine) as session:
+        tracker_result = await session.exec(
+            select(NotificationTracker).where(
+                NotificationTracker.provider_id == provider_id,
+                NotificationTracker.enabled == True,
+            )
+        )
+        trackers = tracker_result.all()
+
+        for tracker in trackers:
+            filters = tracker.filters or {}
+            if not _passes_filters(event, filters):
+                _LOGGER.debug(
+                    "Event filtered out for tracker %d (%s)", tracker.id, tracker.name
+                )
+                continue
+
+            link_data = await load_link_data(session, tracker.id)
+            if not link_data:
+                continue
+
+            # Log event
+            session.add(EventLog(
+                tracker_id=tracker.id,
+                tracker_name=tracker.name,
+                provider_id=provider_id,
+                provider_name=provider.name,
+                event_type=event.event_type.value,
+                collection_id=event.collection_id,
+                collection_name=event.collection_name,
+                assets_count=0,
+                details={
+                    "provider_type": event.provider_type.value,
+                    **{k: v for k, v in event.extra.items() if k in (
+                        "sender", "card_name", "board_name",
+                        "list_name", "old_list_name", "new_list_name",
+                        "comment_text", "task_name", "attachment_name",
+                        "label_name",
+                    )},
+                },
+            ))
+            await session.commit()
+
+            # Dispatch to targets
+            dispatcher = NotificationDispatcher()
+            target_configs = _build_target_configs(event, link_data, provider.config or {})
+            if target_configs:
+                results = await dispatcher.dispatch(event, target_configs)
+                for r in results:
+                    if r.get("success"):
+                        dispatched += 1
+                    else:
+                        _LOGGER.error(
+                            "Notification failed for tracker %d: %s",
+                            tracker.id, r.get("error", "unknown"),
+                        )
+
+    return {"ok": True, "dispatched": dispatched}
+
+
 def _build_target_configs(
     event: ServiceEvent,
     link_data: list[dict[str, Any]],