Refactor code structure for improved readability and maintainability

app/api/v1/scheduler.py

@@ -1,7 +1,9 @@
 """API endpoints for scheduled task management."""
 
+from typing import Annotated
 
 from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlmodel import select
 from sqlmodel.ext.asyncio.session import AsyncSession
 
 from app.core.database import get_db
@@ -9,12 +11,15 @@ from app.core.dependencies import (
     get_admin_user,
     get_current_active_user,
 )
+from app.core.services import get_global_scheduler_service
 from app.models.scheduled_task import ScheduledTask, TaskStatus, TaskType
 from app.models.user import User
+from app.repositories.scheduled_task import ScheduledTaskRepository
 from app.schemas.scheduler import (
     ScheduledTaskCreate,
     ScheduledTaskResponse,
     ScheduledTaskUpdate,
+    TaskFilterParams,
 )
 from app.services.scheduler import SchedulerService
 
@@ -23,47 +28,21 @@ router = APIRouter(prefix="/scheduler")
 
 def get_scheduler_service() -> SchedulerService:
     """Get the global scheduler service instance."""
-    from app.main import get_global_scheduler_service
     return get_global_scheduler_service()
 
 
-@router.post("/tasks", response_model=ScheduledTaskResponse)
-async def create_task(
-    task_data: ScheduledTaskCreate,
-    current_user: User = Depends(get_current_active_user),
-    scheduler_service: SchedulerService = Depends(get_scheduler_service),
-) -> ScheduledTask:
-    """Create a new scheduled task."""
-    try:
-        task = await scheduler_service.create_task(
-            name=task_data.name,
-            task_type=task_data.task_type,
-            scheduled_at=task_data.scheduled_at,
-            parameters=task_data.parameters,
-            user_id=current_user.id,
-            timezone=task_data.timezone,
-            recurrence_type=task_data.recurrence_type,
-            cron_expression=task_data.cron_expression,
-            recurrence_count=task_data.recurrence_count,
-            expires_at=task_data.expires_at,
-        )
-        return task
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-
-@router.get("/tasks", response_model=list[ScheduledTaskResponse])
-async def get_user_tasks(
-    status: TaskStatus | None = Query(None, description="Filter by task status"),
-    task_type: TaskType | None = Query(None, description="Filter by task type"),
-    limit: int | None = Query(50, description="Maximum number of tasks to return"),
-    offset: int | None = Query(0, description="Number of tasks to skip"),
-    current_user: User = Depends(get_current_active_user),
-    scheduler_service: SchedulerService = Depends(get_scheduler_service),
-) -> list[ScheduledTask]:
-    """Get user's scheduled tasks."""
-    return await scheduler_service.get_user_tasks(
-        user_id=current_user.id,
+def get_task_filters(
+    status: Annotated[
+        TaskStatus | None, Query(description="Filter by task status"),
+    ] = None,
+    task_type: Annotated[
+        TaskType | None, Query(description="Filter by task type"),
+    ] = None,
+    limit: Annotated[int, Query(description="Maximum number of tasks to return")] = 50,
+    offset: Annotated[int, Query(description="Number of tasks to skip")] = 0,
+) -> TaskFilterParams:
+    """Create task filter parameters from query parameters."""
+    return TaskFilterParams(
         status=status,
         task_type=task_type,
         limit=limit,
@@ -71,15 +50,45 @@ async def get_user_tasks(
     )
 
 
+@router.post("/tasks", response_model=ScheduledTaskResponse)
+async def create_task(
+    task_data: ScheduledTaskCreate,
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    scheduler_service: Annotated[SchedulerService, Depends(get_scheduler_service)],
+) -> ScheduledTask:
+    """Create a new scheduled task."""
+    try:
+        return await scheduler_service.create_task(
+            task_data=task_data,
+            user_id=current_user.id,
+        )
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e)) from e
+
+
+@router.get("/tasks", response_model=list[ScheduledTaskResponse])
+async def get_user_tasks(
+    filters: Annotated[TaskFilterParams, Depends(get_task_filters)],
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    scheduler_service: Annotated[SchedulerService, Depends(get_scheduler_service)],
+) -> list[ScheduledTask]:
+    """Get user's scheduled tasks."""
+    return await scheduler_service.get_user_tasks(
+        user_id=current_user.id,
+        status=filters.status,
+        task_type=filters.task_type,
+        limit=filters.limit,
+        offset=filters.offset,
+    )
+
+
 @router.get("/tasks/{task_id}", response_model=ScheduledTaskResponse)
 async def get_task(
     task_id: int,
-    current_user: User = Depends(get_current_active_user),
-    db_session: AsyncSession = Depends(get_db),
+    current_user: Annotated[User, Depends(get_current_active_user)] = ...,
+    db_session: Annotated[AsyncSession, Depends(get_db)] = ...,
 ) -> ScheduledTask:
     """Get a specific scheduled task."""
-    from app.repositories.scheduled_task import ScheduledTaskRepository
-
     repo = ScheduledTaskRepository(db_session)
     task = await repo.get_by_id(task_id)
 
@@ -97,12 +106,10 @@ async def get_task(
 async def update_task(
     task_id: int,
     task_update: ScheduledTaskUpdate,
-    current_user: User = Depends(get_current_active_user),
-    db_session: AsyncSession = Depends(get_db),
+    current_user: Annotated[User, Depends(get_current_active_user)] = ...,
+    db_session: Annotated[AsyncSession, Depends(get_db)] = ...,
 ) -> ScheduledTask:
     """Update a scheduled task."""
-    from app.repositories.scheduled_task import ScheduledTaskRepository
-
     repo = ScheduledTaskRepository(db_session)
     task = await repo.get_by_id(task_id)
 
@@ -118,20 +125,19 @@ async def update_task(
     for field, value in update_data.items():
         setattr(task, field, value)
 
-    updated_task = await repo.update(task)
-    return updated_task
+    return await repo.update(task)
 
 
 @router.delete("/tasks/{task_id}")
 async def cancel_task(
     task_id: int,
-    current_user: User = Depends(get_current_active_user),
-    scheduler_service: SchedulerService = Depends(get_scheduler_service),
-    db_session: AsyncSession = Depends(get_db),
+    current_user: Annotated[User, Depends(get_current_active_user)] = ...,
+    scheduler_service: Annotated[
+        SchedulerService, Depends(get_scheduler_service),
+    ] = ...,
+    db_session: Annotated[AsyncSession, Depends(get_db)] = ...,
 ) -> dict:
     """Cancel a scheduled task."""
-    from app.repositories.scheduled_task import ScheduledTaskRepository
-
     repo = ScheduledTaskRepository(db_session)
     task = await repo.get_by_id(task_id)
 
@@ -152,20 +158,23 @@ async def cancel_task(
 # Admin-only endpoints
 @router.get("/admin/tasks", response_model=list[ScheduledTaskResponse])
 async def get_all_tasks(
-    status: TaskStatus | None = Query(None, description="Filter by task status"),
-    task_type: TaskType | None = Query(None, description="Filter by task type"),
-    limit: int | None = Query(100, description="Maximum number of tasks to return"),
-    offset: int | None = Query(0, description="Number of tasks to skip"),
-    current_user: User = Depends(get_admin_user),
-    db_session: AsyncSession = Depends(get_db),
+    status: Annotated[
+        TaskStatus | None, Query(description="Filter by task status"),
+    ] = None,
+    task_type: Annotated[
+        TaskType | None, Query(description="Filter by task type"),
+    ] = None,
+    limit: Annotated[
+        int | None, Query(description="Maximum number of tasks to return"),
+    ] = 100,
+    offset: Annotated[
+        int | None, Query(description="Number of tasks to skip"),
+    ] = 0,
+    _: Annotated[User, Depends(get_admin_user)] = ...,
+    db_session: Annotated[AsyncSession, Depends(get_db)] = ...,
 ) -> list[ScheduledTask]:
     """Get all scheduled tasks (admin only)."""
-    from app.repositories.scheduled_task import ScheduledTaskRepository
-
-    repo = ScheduledTaskRepository(db_session)
-
-    # Get all tasks with pagination and filtering
-    from sqlmodel import select
+    # Build query with pagination and filtering
 
     statement = select(ScheduledTask)
 
@@ -189,14 +198,16 @@ async def get_all_tasks(
 
 @router.get("/admin/system-tasks", response_model=list[ScheduledTaskResponse])
 async def get_system_tasks(
-    status: TaskStatus | None = Query(None, description="Filter by task status"),
-    task_type: TaskType | None = Query(None, description="Filter by task type"),
-    current_user: User = Depends(get_admin_user),
-    db_session: AsyncSession = Depends(get_db),
+    status: Annotated[
+        TaskStatus | None, Query(description="Filter by task status"),
+    ] = None,
+    task_type: Annotated[
+        TaskType | None, Query(description="Filter by task type"),
+    ] = None,
+    _: Annotated[User, Depends(get_admin_user)] = ...,
+    db_session: Annotated[AsyncSession, Depends(get_db)] = ...,
 ) -> list[ScheduledTask]:
     """Get system tasks (admin only)."""
-    from app.repositories.scheduled_task import ScheduledTaskRepository
-
     repo = ScheduledTaskRepository(db_session)
     return await repo.get_system_tasks(status=status, task_type=task_type)
 
@@ -204,23 +215,16 @@ async def get_system_tasks(
 @router.post("/admin/system-tasks", response_model=ScheduledTaskResponse)
 async def create_system_task(
     task_data: ScheduledTaskCreate,
-    current_user: User = Depends(get_admin_user),
-    scheduler_service: SchedulerService = Depends(get_scheduler_service),
+    _: Annotated[User, Depends(get_admin_user)] = ...,
+    scheduler_service: Annotated[
+        SchedulerService, Depends(get_scheduler_service),
+    ] = ...,
 ) -> ScheduledTask:
     """Create a system task (admin only)."""
     try:
-        task = await scheduler_service.create_task(
-            name=task_data.name,
-            task_type=task_data.task_type,
-            scheduled_at=task_data.scheduled_at,
-            parameters=task_data.parameters,
+        return await scheduler_service.create_task(
+            task_data=task_data,
             user_id=None,  # System task
-            timezone=task_data.timezone,
-            recurrence_type=task_data.recurrence_type,
-            cron_expression=task_data.cron_expression,
-            recurrence_count=task_data.recurrence_count,
-            expires_at=task_data.expires_at,
         )
-        return task
     except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))
+        raise HTTPException(status_code=400, detail=str(e)) from e