project.py

"""Project API."""

from datetime import datetime
from http import HTTPStatus
from typing import Literal

from django.http import HttpRequest
from ninja import Field, FilterSchema, Path, Query, Schema
from ninja.decorators import decorate_view
from ninja.pagination import RouterPaginated
from ninja.responses import Response

from apps.api.decorators.cache import cache_response
from apps.api.rest.v0.common import Leader, ValidationErrorSchema
from apps.api.rest.v0.sponsor import Sponsor
from apps.api.rest.v0.structured_search import FieldConfig, apply_structured_search
from apps.owasp.models.enums.project import ProjectLevel, ProjectType
from apps.owasp.models.project import Project as ProjectModel
from apps.owasp.models.sponsor import Sponsor as SponsorModel

PROJECT_SEARCH_FIELDS: dict[str, FieldConfig] = {
    "name": {
        "type": "string",
        "lookup": "icontains",
    },
    "stars": {
        "type": "number",
        "field": "stars_count",
    },
}

router = RouterPaginated(tags=["Projects"])


class ProjectBase(Schema):
    """Base schema for Project (used in list endpoints)."""

    created_at: datetime
    key: str
    level: ProjectLevel
    name: str
    type: ProjectType
    updated_at: datetime

    @staticmethod
    def resolve_key(obj: ProjectModel) -> str:
        """Resolve key."""
        return obj.nest_key


class Project(ProjectBase):
    """Schema for Project (minimal fields for list display)."""


class ProjectDetail(ProjectBase):
    """Detail schema for Project (used in single item endpoints)."""

    description: str
    leaders: list[Leader]

    @staticmethod
    def resolve_leaders(obj):
        """Resolve leaders."""
        return [
            Leader(key=leader.member.login if leader.member else None, name=leader.member_name)
            for leader in obj.entity_leaders
        ]


class ProjectError(Schema):
    """Project error schema."""

    message: str


class ProjectFilter(FilterSchema):
    """Filter for Project."""

    level: ProjectLevel | None = Field(
        None,
        description="Level of the project",
    )
    q: str | None = Field(
        None,
        description="Structured search query (e.g. 'name:security stars:>100')",
    )
    type: list[ProjectType] | None = Field(
        None,
        description="Type of the project",
    )


@router.get(
    "/",
    description="Retrieve a paginated list of OWASP projects.",
    operation_id="list_projects",
    response=list[Project],
    summary="List projects",
)
@decorate_view(cache_response())
def list_projects(
    request: HttpRequest,
    filters: ProjectFilter = Query(...),
    ordering: Literal["created_at", "-created_at", "updated_at", "-updated_at"] | None = Query(
        None,
        description="Ordering field",
    ),
) -> list[Project]:
    """Get projects."""
    queryset = apply_structured_search(
        queryset=ProjectModel.active_projects,
        query=filters.q,
        field_schema=PROJECT_SEARCH_FIELDS,
    )

    if filters.level is not None:
        queryset = queryset.filter(level=filters.level)

    if filters.type is not None:
        queryset = queryset.filter(type__in=filters.type)

    return queryset.order_by(ordering or "-level_raw", "-stars_count", "-forks_count")


@router.get(
    "/{str:project_id}",
    description="Retrieve project details.",
    operation_id="get_project",
    response={
        HTTPStatus.BAD_REQUEST: ValidationErrorSchema,
        HTTPStatus.NOT_FOUND: ProjectError,
        HTTPStatus.OK: ProjectDetail,
    },
    summary="Get project",
)
@decorate_view(cache_response())
def get_project(
    request: HttpRequest,
    project_id: str = Path(example="Nest"),
) -> ProjectDetail | ProjectError:
    """Get project."""
    if project := ProjectModel.active_projects.filter(
        key__iexact=(
            project_id if project_id.startswith("www-project-") else f"www-project-{project_id}"
        )
    ).first():
        return project

    return Response({"message": "Project not found"}, status=HTTPStatus.NOT_FOUND)


@router.get(
    "/nest/sponsors",
    description="Retrieve sponsors associated with project nest.",
    operation_id="list_nest_sponsors",
    response=list[Sponsor],
    summary="List nest sponsors",
)
@decorate_view(cache_response())
def list_nest_sponsors(
    request: HttpRequest,
) -> list[Sponsor]:
    """Get sponsors for a project."""
    return SponsorModel.objects.filter(status=SponsorModel.StatusType.ACTIVE)