feat(B-NOTIF): Notification→Message Konsolidierung — System-Channel, post_system_message(), Migration

B-NOTIF-SYS: CommConversation um is_system Feld erweitert, get_or_create_system_channel()
B-NOTIF-EVT: post_system_message() in kommunikation/services.py — erstellt CommMessage im System-Channel
- create_notification() als deprecated Wrapper delegiert auf post_system_message()
- Text-Block + action_card Block mit Deep-Link, Metadata: notification_type/severity/entity_ref
B-NOTIF-PREF: NotificationPreference als Routing-Konfiguration, stumm/disabled respektiert
B-NOTIF-MIG: Migration 0120 — Notifications → CommMessages migriert, notifications_legacy View
B-NOTIF-DEPREC: Notification-Routes als deprecated markiert, keine Routes entfernt
B-NOTIF-TEST: 19 Tests in test_notification_migration.py — alle grün
- System-Channel, post_system_message, create_notification Wrapper, Preferences, Unread-Badge, Migration Mapping, Sensitive Fields

app/plugins/builtins/kommunikation/models.py

@@ -44,6 +44,7 @@ class CommConversation(Base, TenantMixin, OwnedMixin):
     locked_by: Mapped[str | None] = mapped_column(String(100), nullable=True)
     is_direct: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
     is_archived: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
+    is_system: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
     created_by: Mapped[uuid.UUID | None] = mapped_column(PGUUID(as_uuid=True), nullable=True)
     created_by_type: Mapped[str] = mapped_column(String(20), nullable=False, default="user")
     last_msg_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)

app/plugins/builtins/kommunikation/services.py

@@ -1135,3 +1135,205 @@ async def create_plugin_room(
 
     parts = [plugin_p, user_p]
     return conversation_to_response(conv, parts, is_pinned_by_user=True)
+
+
+
+# ─── System Channel ───
+
+
+async def get_or_create_system_channel(
+    db: AsyncSession,
+    tenant_id: uuid.UUID,
+) -> CommConversation:
+    """Get or create the tenant-wide system channel.
+
+    The system channel is a locked, is_system=True conversation that serves as
+    the central destination for system notifications, user alerts, and agent messages.
+    All users of the tenant are automatically added as participants.
+    """
+    result = await db.execute(
+        select(CommConversation).where(
+            CommConversation.tenant_id == tenant_id,
+            CommConversation.is_system.is_(True),
+            CommConversation.deleted_at.is_(None),
+        )
+    )
+    conv = result.scalar_one_or_none()
+    if conv is not None:
+        return conv
+
+    # Create the system channel
+    conv = CommConversation(
+        tenant_id=tenant_id,
+        title="System Channel",
+        is_pinned=False,
+        is_locked=True,
+        is_direct=False,
+        is_archived=False,
+        is_system=True,
+        created_by=None,
+        created_by_type="system",
+        metadata_={},
+    )
+    db.add(conv)
+    await db.flush()
+
+    # Add all tenant users as participants
+    from app.models.user import User, UserTenant
+
+    users_result = await db.execute(
+        select(User.id)
+        .join(UserTenant, UserTenant.user_id == User.id)
+        .where(UserTenant.tenant_id == tenant_id)
+    )
+    user_ids = [row[0] for row in users_result.all()]
+
+    for uid in user_ids:
+        p = CommParticipant(
+            tenant_id=tenant_id,
+            conversation_id=conv.id,
+            participant_id=uid,
+            participant_type="user",
+            role="member",
+        )
+        db.add(p)
+
+    await db.flush()
+    return conv
+
+
+async def post_system_message(
+    db: AsyncSession,
+    tenant_id: uuid.UUID,
+    user_id: uuid.UUID,
+    message_type: str,
+    title: str,
+    body: str | None = None,
+    entity_type: str | None = None,
+    entity_id: uuid.UUID | None = None,
+    severity: str = "info",
+) -> CommMessage | None:
+    """Post a typed system message to the tenant system channel.
+
+    Creates a CommMessage in the system channel with:
+    - A text block containing title + body
+    - An action_card block with deep-link if entity_type/entity_id is set
+    - Block/message metadata: notification_type, severity, entity_ref
+
+    Returns the created CommMessage, or None if the user has muted this type.
+    """
+    # Check user preferences — reuse the notification preference system
+    from app.models.notification import NotificationPreference, NotificationType
+
+    pref = await db.execute(
+        select(NotificationPreference).where(
+            and_(
+                NotificationPreference.user_id == user_id,
+                NotificationPreference.type_key == message_type,
+                NotificationPreference.tenant_id == tenant_id,
+            )
+        )
+    )
+    pref_row = pref.scalar_one_or_none()
+
+    if pref_row and not pref_row.is_enabled:
+        return None
+
+    if not pref_row:
+        type_def = await db.execute(
+            select(NotificationType).where(NotificationType.type_key == message_type)
+        )
+        type_row = type_def.scalar_one_or_none()
+        if type_row and not type_row.is_enabled_by_default:
+            return None
+
+    # Get or create system channel
+    conv = await get_or_create_system_channel(db, tenant_id)
+
+    # Build message content
+    content = title
+    if body:
+        content = f"{title}\n{body}"
+
+    # Build metadata
+    msg_metadata: dict[str, Any] = {
+        "notification_type": message_type,
+        "severity": severity,
+        "target_user_id": str(user_id),
+    }
+    if entity_type and entity_id:
+        msg_metadata["entity_ref"] = {
+            "entity_type": entity_type,
+            "entity_id": str(entity_id),
+        }
+
+    # Build blocks
+    blocks: list[dict[str, Any]] = [
+        {
+            "block_type": "text",
+            "block_data": {"text": content, "title": title, "body": body or ""},
+        }
+    ]
+    if entity_type and entity_id:
+        blocks.append(
+            {
+                "block_type": "action_card",
+                "block_data": {
+                    "label": "Open",
+                    "entity_type": entity_type,
+                    "entity_id": str(entity_id),
+                },
+            }
+        )
+
+    # Create message directly (not via send_message to avoid trigger_depth issues)
+    msg = CommMessage(
+        tenant_id=tenant_id,
+        conversation_id=conv.id,
+        sender_id=None,
+        sender_type="system",
+        content=content,
+        content_format="text",
+        metadata_=msg_metadata,
+    )
+    db.add(msg)
+    await db.flush()
+
+    # Create blocks
+    for i, block in enumerate(blocks):
+        b = CommMessageBlock(
+            tenant_id=tenant_id,
+            message_id=msg.id,
+            block_type=block["block_type"],
+            block_data=block["block_data"],
+            sort_order=i,
+        )
+        db.add(b)
+
+    await db.flush()
+
+    # Update conversation last_msg
+    from datetime import datetime, timezone as dt_timezone
+
+    await db.execute(
+        update(CommConversation)
+        .where(CommConversation.id == conv.id)
+        .values(
+            last_msg_at=datetime.now(dt_timezone.utc),
+            last_msg_preview=content[:200],
+            last_msg_sender_type="system",
+        )
+    )
+
+    # Publish event
+    event_bus = get_event_bus()
+    await event_bus.publish("system.message.posted", {
+        "conversation_id": str(conv.id),
+        "message_id": str(msg.id),
+        "tenant_id": str(tenant_id),
+        "user_id": str(user_id),
+        "message_type": message_type,
+        "severity": severity,
+    })
+
+    return msg