Coverage for src/robot_dispatch/api/routers/tasks.py: 100%
33 statements
« prev ^ index » next coverage.py v7.17.2, created at 2026-11-07 17:18 +0000
« prev ^ index » next coverage.py v7.17.2, created at 2026-11-07 17:18 +0000
1from __future__ import annotations
3import uuid
4from typing import Annotated
6from fastapi import APIRouter, Depends, Header, Query, Response, status
8from robot_dispatch.api.deps import ApiKeyGuard, get_task_service
9from robot_dispatch.api.schemas import (
10 TaskCreateRequest,
11 TaskEventResponse,
12 TaskListResponse,
13 TaskResponse,
14)
15from robot_dispatch.domain.enums import TaskStatus
16from robot_dispatch.services.task_service import CreateTaskCommand, TaskService
18router = APIRouter(prefix="/tasks", tags=["tasks"], dependencies=[ApiKeyGuard])
21@router.post(
22 "",
23 response_model=TaskResponse,
24 status_code=status.HTTP_201_CREATED,
25 responses={200: {"description": "Idempotent replay: the task already exists"}},
26)
27async def create_task(
28 body: TaskCreateRequest,
29 response: Response,
30 service: Annotated[TaskService, Depends(get_task_service)],
31 idempotency_key: Annotated[str | None, Header(alias="Idempotency-Key")] = None,
32) -> TaskResponse:
33 external_id = body.external_id or (idempotency_key.strip() if idempotency_key else None)
34 result = await service.create(
35 CreateTaskCommand(
36 type=body.type,
37 payload=body.payload,
38 priority=body.priority,
39 external_id=external_id,
40 max_attempts=body.max_attempts,
41 timeout_seconds=body.timeout_seconds,
42 )
43 )
44 if result.replayed:
45 response.status_code = status.HTTP_200_OK
46 response.headers["Idempotent-Replay"] = "true"
47 else:
48 response.headers["Location"] = f"/api/v1/tasks/{result.task.id}"
49 return TaskResponse.model_validate(result.task)
52@router.get("", response_model=TaskListResponse)
53async def list_tasks(
54 service: Annotated[TaskService, Depends(get_task_service)],
55 task_status: Annotated[list[TaskStatus] | None, Query(alias="status")] = None,
56 robot_id: uuid.UUID | None = None,
57 task_type: Annotated[str | None, Query(alias="type")] = None,
58 limit: Annotated[int, Query(ge=1, le=200)] = 50,
59 offset: Annotated[int, Query(ge=0)] = 0,
60) -> TaskListResponse:
61 items = await service.list(
62 statuses=[item.value for item in task_status] if task_status else None,
63 robot_id=robot_id,
64 task_type=task_type,
65 limit=limit,
66 offset=offset,
67 )
68 return TaskListResponse(
69 items=[TaskResponse.model_validate(item) for item in items],
70 limit=limit,
71 offset=offset,
72 )
75@router.get("/{task_id}", response_model=TaskResponse)
76async def get_task(
77 task_id: uuid.UUID,
78 service: Annotated[TaskService, Depends(get_task_service)],
79) -> TaskResponse:
80 return TaskResponse.model_validate(await service.get(task_id))
83@router.get("/{task_id}/events", response_model=list[TaskEventResponse])
84async def get_task_events(
85 task_id: uuid.UUID,
86 service: Annotated[TaskService, Depends(get_task_service)],
87) -> list[TaskEventResponse]:
88 await service.get(task_id)
89 events = await service.events(task_id)
90 return [TaskEventResponse.model_validate(event) for event in events]
93@router.post("/{task_id}/cancel", response_model=TaskResponse)
94async def cancel_task(
95 task_id: uuid.UUID,
96 service: Annotated[TaskService, Depends(get_task_service)],
97) -> TaskResponse:
98 return TaskResponse.model_validate(await service.cancel(task_id))