kanban-app/backend/app/schemas/wiki.py

"""Pydantic schemas for Wiki model"""
from datetime import datetime
from typing import Any, List, Optional

from pydantic import BaseModel, ConfigDict, Field, field_validator

from app.schemas.card import CardResponse
from app.schemas.epic import EpicResponse


class WikiCreateRequest(BaseModel):
    """Schema for creating a new wiki"""

    model_config = ConfigDict(
        json_schema_extra={
            "example": {
                "name": "Security Guidelines",
                "slug": "security-guidelines",
                "content": [
                    {"type": "paragraph", "children": [{"text": "Security rules..."}]}
                ],
                "summary": "Brief security overview",
                "category": "Documentation",
                "tags": ["security", "guidelines"],
            }
        }
    )

    name: str = Field(..., min_length=1, max_length=200, description="Wiki name")
    slug: Optional[str] = Field(None, max_length=200, description="URL-friendly slug")
    content: Any = Field(..., description="Rich text content")
    summary: Optional[str] = Field(None, description="Brief summary")
    category: Optional[str] = Field(None, max_length=100, description="Wiki category")
    tags: Optional[List[str]] = Field(None, description="Wiki tags")

    @field_validator("slug")
    @classmethod
    def validate_slug(cls, v):
        """Validate slug is URL-friendly."""
        if v and not v.islower():
            raise ValueError("Slug must be lowercase")
        if v and not all(c.isalnum() or c == "-" for c in v):
            raise ValueError(
                "Slug must contain only lowercase letters, numbers, and hyphens"
            )
        return v


class WikiResponse(BaseModel):
    """Schema for wiki response"""

    model_config = ConfigDict(
        from_attributes=True,
        json_schema_extra={
            "example": {
                "id": 1,
                "name": "Security Guidelines",
                "slug": "security-guidelines",
                "content": [
                    {"type": "paragraph", "children": [{"text": "Security rules..."}]}
                ],
                "summary": "Brief security overview",
                "category": "Documentation",
                "tags": ["security", "guidelines"],
                "board_id": 1,
                "created_by": 1,
                "updated_by": 1,
                "created_at": "2024-01-01T10:00:00",
                "updated_at": "2024-01-15T10:30:00",
                "linked_cards": [],
                "linked_epics": [],
            }
        },
    )

    id: int
    name: str
    slug: Optional[str] = None
    content: Any
    summary: Optional[str] = None
    category: Optional[str] = None
    tags: Optional[List[str]] = None
    board_id: int
    created_by: Optional[int] = None
    updated_by: Optional[int] = None
    created_at: Optional[datetime] = None
    updated_at: Optional[datetime] = None
    linked_cards: Optional[List[CardResponse]] = None
    linked_epics: Optional[List[EpicResponse]] = None


class WikiUpdateRequest(BaseModel):
    """Schema for updating a wiki"""

    model_config = ConfigDict(
        json_schema_extra={
            "example": {
                "name": "Updated Security Guidelines",
                "slug": "updated-security-guidelines",
                "content": [
                    {"type": "paragraph", "children": [{"text": "Updated..."}]}
                ],
                "summary": "Updated summary",
                "category": "Updated Category",
                "tags": ["security", "updated"],
            }
        }
    )

    name: Optional[str] = Field(None, min_length=1, max_length=200)
    slug: Optional[str] = Field(None, max_length=200)
    content: Optional[Any] = None
    summary: Optional[str] = None
    category: Optional[str] = Field(None, max_length=100)
    tags: Optional[List[str]] = None

    @field_validator("slug")
    @classmethod
    def validate_slug(cls, v):
        """Validate slug is URL-friendly."""
        if v and not v.islower():
            raise ValueError("Slug must be lowercase")
        if v and not all(c.isalnum() or c == "-" for c in v):
            raise ValueError(
                "Slug must contain only lowercase letters, numbers, and hyphens"
            )
        return v


class WikiEntityLink(BaseModel):
    """Schema for wiki entity link response"""

    model_config = ConfigDict(
        json_schema_extra={
            "example": {
                "wiki_id": 1,
                "entity_type": "card",
                "entity_id": 5,
                "created_at": "2024-01-15T10:30:00",
                "linked_by": 1,
            }
        }
    )

    wiki_id: int
    entity_type: str
    entity_id: int
    created_at: Optional[datetime] = None
    linked_by: Optional[int] = None


class WikiLinkRequest(BaseModel):
    """Schema for creating a wiki entity link"""

    model_config = ConfigDict(
        json_schema_extra={
            "example": {
                "entity_type": "card",
                "entity_id": 5,
            }
        }
    )

    entity_type: str = Field(..., description="Entity type (card, epic, list, board)")
    entity_id: int = Field(..., description="Entity ID")

    @field_validator("entity_type")
    @classmethod
    def validate_entity_type(cls, v):
        """Validate entity type is supported."""
        valid_types = ["card", "epic", "list", "board"]
        if v not in valid_types:
            raise ValueError(f"entity_type must be one of: {', '.join(valid_types)}")
        return v