init: new structure + fix lint errors

cpv3/modules/jobs/router.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import uuid
+
+from fastapi import APIRouter, Depends, HTTPException, Response, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from cpv3.infrastructure.auth import get_current_user
+from cpv3.db.session import get_db
+from cpv3.modules.jobs.schemas import (
+    JobCreate,
+    JobEventCreate,
+    JobEventRead,
+    JobEventUpdate,
+    JobRead,
+    JobUpdate,
+)
+from cpv3.modules.jobs.service import JobService
+from cpv3.modules.users.models import User
+
+jobs_router = APIRouter(prefix="/api/jobs", tags=["jobs"])
+events_router = APIRouter(prefix="/api/jobs", tags=["events"])
+
+
+@jobs_router.get("/jobs/", response_model=list[JobRead])
+async def list_jobs_endpoint(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+) -> list[JobRead]:
+    service = JobService(db)
+    jobs = await service.list_jobs(requester=current_user)
+    return [JobRead.model_validate(j) for j in jobs]
+
+
+@jobs_router.post("/jobs/", response_model=JobRead, status_code=status.HTTP_201_CREATED)
+async def create_job_endpoint(
+    body: JobCreate,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+) -> JobRead:
+    service = JobService(db)
+    job = await service.create_job(requester=current_user, data=body)
+    return JobRead.model_validate(job)
+
+
+@jobs_router.get("/jobs/{job_id}/", response_model=JobRead)
+async def retrieve_job_endpoint(
+    job_id: uuid.UUID,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+) -> JobRead:
+    service = JobService(db)
+    job = await service.get_job(job_id)
+    if job is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
+
+    if not current_user.is_staff and job.user_id != current_user.id:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden")
+
+    return JobRead.model_validate(job)
+
+
+@jobs_router.patch("/jobs/{job_id}/", response_model=JobRead)
+async def patch_job_endpoint(
+    job_id: uuid.UUID,
+    body: JobUpdate,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+) -> JobRead:
+    service = JobService(db)
+    job = await service.get_job(job_id)
+    if job is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
+
+    if not current_user.is_staff and job.user_id != current_user.id:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden")
+
+    job = await service.update_job(job, body)
+    return JobRead.model_validate(job)
+
+
+@jobs_router.delete("/jobs/{job_id}/", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_job_endpoint(
+    job_id: uuid.UUID,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+) -> Response:
+    service = JobService(db)
+    job = await service.get_job(job_id)
+    if job is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
+
+    if not current_user.is_staff and job.user_id != current_user.id:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden")
+
+    await service.deactivate_job(job)
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+@events_router.get("/events/", response_model=list[JobEventRead])
+async def list_events_endpoint(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+) -> list[JobEventRead]:
+    _ = current_user
+    service = JobService(db)
+    events = await service.list_job_events()
+    return [JobEventRead.model_validate(e) for e in events]
+
+
+@events_router.post("/events/", response_model=JobEventRead, status_code=status.HTTP_201_CREATED)
+async def create_event_endpoint(
+    body: JobEventCreate,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+) -> JobEventRead:
+    _ = current_user
+    service = JobService(db)
+    event = await service.create_job_event(body)
+    return JobEventRead.model_validate(event)
+
+
+@events_router.get("/events/{event_id}/", response_model=JobEventRead)
+async def retrieve_event_endpoint(
+    event_id: uuid.UUID,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+) -> JobEventRead:
+    _ = current_user
+    service = JobService(db)
+    event = await service.get_job_event(event_id)
+    if event is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
+
+    return JobEventRead.model_validate(event)
+
+
+@events_router.patch("/events/{event_id}/", response_model=JobEventRead)
+async def patch_event_endpoint(
+    event_id: uuid.UUID,
+    body: JobEventUpdate,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+) -> JobEventRead:
+    _ = current_user
+    service = JobService(db)
+    event = await service.get_job_event(event_id)
+    if event is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
+
+    event = await service.update_job_event(event, body)
+    return JobEventRead.model_validate(event)
+
+
+@events_router.delete("/events/{event_id}/", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_event_endpoint(
+    event_id: uuid.UUID,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+) -> Response:
+    _ = current_user
+    service = JobService(db)
+    event = await service.get_job_event(event_id)
+    if event is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
+
+    await service.deactivate_job_event(event)
+    return Response(status_code=status.HTTP_204_NO_CONTENT)