models.py

"""Pydantic models for request/response validation."""

from datetime import datetime
from typing import Optional, List
from pydantic import BaseModel, Field, field_validator
import bleach


def sanitize_text(value: str) -> str:
    """Sanitize text to prevent XSS."""
    if value is None:
        return ""
    # Strip all HTML tags
    return bleach.clean(value, tags=[], strip=True)


PRIORITY_VALUES = ["highest", "high", "medium", "low", "lowest"]


class ProjectCreate(BaseModel):
    """Schema for creating a project."""
    name: str = Field(..., min_length=1, max_length=255)
    description: str = Field(default="", max_length=2000)
    path: str = Field(default="", max_length=500)
    notes: str = Field(default="", max_length=10000)
    priority: str = Field(default="medium")

    @field_validator("name", "description", "notes", mode="before")
    @classmethod
    def sanitize(cls, v):
        return sanitize_text(str(v)) if v else ""

    @field_validator("priority", mode="before")
    @classmethod
    def validate_priority(cls, v):
        if v is None:
            return "medium"
        v = str(v).lower()
        return v if v in PRIORITY_VALUES else "medium"


class ProjectUpdate(BaseModel):
    """Schema for updating a project."""
    name: Optional[str] = Field(None, min_length=1, max_length=255)
    description: Optional[str] = Field(None, max_length=2000)
    path: Optional[str] = Field(None, max_length=500)
    notes: Optional[str] = Field(None, max_length=10000)
    priority: Optional[str] = Field(None)
    paused: Optional[bool] = Field(None)

    @field_validator("name", "description", "notes", mode="before")
    @classmethod
    def sanitize(cls, v):
        if v is None:
            return None
        return sanitize_text(str(v))

    @field_validator("priority", mode="before")
    @classmethod
    def validate_priority(cls, v):
        if v is None:
            return None
        v = str(v).lower()
        return v if v in PRIORITY_VALUES else None


class ProjectResponse(BaseModel):
    """Schema for project response."""
    id: int
    name: str
    description: str
    path: str
    notes: str
    priority: str
    paused: bool
    position: int
    created_at: Optional[datetime]
    tasks: List["TaskResponse"] = []
    services: List["ServiceResponse"] = []


class ProjectReorder(BaseModel):
    """Schema for reordering projects."""
    project_ids: List[int] = Field(..., min_length=1)


class TaskCreate(BaseModel):
    """Schema for creating a task."""
    title: str = Field(..., min_length=1, max_length=500)
    priority: int = Field(default=0, ge=0)

    @field_validator("title", mode="before")
    @classmethod
    def sanitize(cls, v):
        return sanitize_text(str(v)) if v else ""


class TaskUpdate(BaseModel):
    """Schema for updating a task."""
    title: Optional[str] = Field(None, min_length=1, max_length=500)
    completed: Optional[bool] = None
    highlighted: Optional[bool] = None
    blue_highlighted: Optional[bool] = None
    priority: Optional[int] = Field(None, ge=0)

    @field_validator("title", mode="before")
    @classmethod
    def sanitize(cls, v):
        return sanitize_text(str(v)) if v else None


class TaskResponse(BaseModel):
    """Schema for task response."""
    id: int
    project_id: int
    title: str
    completed: bool
    highlighted: bool
    blue_highlighted: bool
    priority: int
    created_at: Optional[datetime]


class TaskReorder(BaseModel):
    """Schema for reordering tasks."""
    task_ids: List[int] = Field(..., min_length=1)


class ServiceCreate(BaseModel):
    """Schema for creating a service."""
    name: str = Field(..., min_length=1, max_length=255)
    check_type: str = Field(default="http", pattern="^(http|tcp|command)$")
    target: str = Field(..., min_length=1, max_length=500)

    @field_validator("name", mode="before")
    @classmethod
    def sanitize_name(cls, v):
        return sanitize_text(str(v)) if v else ""

    @field_validator("target", mode="before")
    @classmethod
    def validate_target(cls, v):
        """Basic validation for service targets."""
        if not v:
            return ""
        v = str(v).strip()
        # Allow localhost, IPs, and domain names
        # Block obviously dangerous patterns
        dangerous = ["&&", "||", ";", "|", "`", "$", "$(", "${"]
        for d in dangerous:
            if d in v:
                raise ValueError(f"Invalid character sequence in target: {d}")
        return v


class ServiceUpdate(BaseModel):
    """Schema for updating a service."""
    name: Optional[str] = Field(None, min_length=1, max_length=255)
    check_type: Optional[str] = Field(None, pattern="^(http|tcp|command)$")
    target: Optional[str] = Field(None, min_length=1, max_length=500)

    @field_validator("name", mode="before")
    @classmethod
    def sanitize_name(cls, v):
        return sanitize_text(str(v)) if v else None

    @field_validator("target", mode="before")
    @classmethod
    def validate_target(cls, v):
        if v is None:
            return None
        v = str(v).strip()
        dangerous = ["&&", "||", ";", "|", "`", "$", "$(", "${"]
        for d in dangerous:
            if d in v:
                raise ValueError(f"Invalid character sequence in target: {d}")
        return v


class ServiceResponse(BaseModel):
    """Schema for service response."""
    id: int
    project_id: int
    name: str
    check_type: str
    target: str
    status: str
    status_code: Optional[int]
    response_time_ms: Optional[int]
    last_error: Optional[str]
    last_checked: Optional[datetime]
    consecutive_failures: int


class SSEEvent(BaseModel):
    """Schema for SSE events."""
    event_type: str
    data: dict


# Forward references
ProjectResponse.model_rebuild()