Merge pull request #16 from C216-Distribuid-System-Project/feat/MF-relationships_filters

Filters and Relationship Routes Integrated with Authenticated User

Author: AlvaroLucioRibeiro

src/modules/modules_api.py

@@ -3,6 +3,7 @@
 from src.routes.user_routes import user_router
 from src.routes.task_routes import task_router
 from src.routes.project_routes import project_router
+from src.routes.filter_routes import router as filter_router
 from src.routes.authentication_routes import authentication_router
 
 # -------------------- API ROUTES -------------------- #
@@ -12,3 +13,4 @@
 router.include_router(user_router)
 router.include_router(project_router)
 router.include_router(task_router)
+router.include_router(filter_router)

src/routes/filter_routes.py

@@ -0,0 +1,159 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from datetime import date
+from typing import List, Optional
+
+from src.utils.utils import get_db
+from src.models.user_model import User
+from src.models.project_model import Project
+from src.models.task_model import Task
+from src.schemas.projects.projects_schema import ProjectResponse
+from src.schemas.tasks.tasks_schema import TaskResponse
+from src.utils.security import get_current_user
+
+router = APIRouter(
+    prefix="/filters",
+    tags=["Filters and Relationships"]
+)
+
+
+@router.get("/tasks", response_model=List[TaskResponse])
+def filter_tasks(
+    completed: Optional[bool] = Query(None, description="Filter by completion status (true/false)"),
+    reminder: Optional[bool] = Query(None, description="Filter by reminder flag (true/false)"),
+    due_before: Optional[date] = Query(None, description="Tasks due before this date"),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Return tasks filtered by completion status, reminder flag, and due date,
+    only for tasks belonging to projects owned by the authenticated user.
+
+    Args:
+        completed (Optional[bool]): Filter by completion status.
+        reminder (Optional[bool]): Filter by reminder flag.
+        due_before (Optional[date]): Filter tasks due before this date.
+        db (Session): Database session.
+        current_user (User): Authenticated user.
+
+    Returns:
+        List[Task]: List of filtered tasks.
+
+    Raises:
+        HTTPException: If no tasks are found.
+    """
+
+    query = (
+        db.query(Task)
+        .join(Project, Project.id == Task.project_id)
+        .filter(Project.user_id == current_user.id)
+    )
+
+    if completed is not None:
+        query = query.filter(Task.completed == completed)
+    if reminder is not None:
+        query = query.filter(Task.reminder == reminder)
+    if due_before:
+        query = query.filter(Task.due_date <= due_before)
+
+    return query.all()
+
+
+@router.get("/user/projects", response_model=List[ProjectResponse])
+def get_projects_by_user(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Return all projects belonging to the authenticated user.
+
+    Args:
+        db (Session): Database session.
+        current_user (User): Authenticated user.
+
+    Returns:
+        List[Project]: List of projects owned by the user.
+
+    Raises:
+        HTTPException: If no projects are found.
+    """
+
+    projects = db.query(Project).filter(Project.user_id == current_user.id).all()
+    if not projects:
+        raise HTTPException(status_code=404, detail="No projects found.")
+    return projects
+
+
+@router.get("/project/{project_id}/tasks", response_model=List[TaskResponse])
+def get_tasks_by_project(
+    project_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Return all tasks for a specific project,
+    only if the project belongs to the authenticated user.
+
+    Args:
+        project_id (int): ID of the project.
+        db (Session): Database session.
+        current_user (User): Authenticated user.
+
+    Returns:
+        List[Task]: List of tasks for the specified project.
+
+    Raises:
+        HTTPException: If the project is not found or not owned by the user.
+    """
+
+    project = db.query(Project).filter(Project.id == project_id, Project.user_id == current_user.id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found or not owned by user")
+
+    return db.query(Task).filter(Task.project_id == project.id).all()
+
+
+@router.get("/tasks/advanced", response_model=List[TaskResponse])
+def advanced_filter_tasks(
+    completed: Optional[bool] = Query(None, description="Filter by completion status"),
+    reminder: Optional[bool] = Query(None, description="Filter by reminder flag"),
+    project_id: Optional[int] = Query(None, description="Filter by project ID"),
+    due_before: Optional[date] = Query(None, description="Tasks due before this date"),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Advanced filtering for tasks related to the authenticated user.
+    Allows combining multiple search parameters.
+
+    Args:
+        completed (Optional[bool]): Filter by completion status.
+        reminder (Optional[bool]): Filter by reminder flag.
+        project_id (Optional[int]): Filter by project ID.
+        due_before (Optional[date]): Filter tasks due before this date.
+        db (Session): Database session.
+        current_user (User): Authenticated user.
+
+    Returns:    
+        List[Task]: List of filtered tasks.
+
+    Raises:
+        HTTPException: If no tasks are found.
+    """
+
+    query = (
+        db.query(Task)
+        .join(Project, Project.id == Task.project_id)
+        .filter(Project.user_id == current_user.id)
+    )
+
+    if completed is not None:
+        query = query.filter(Task.completed == completed)
+    if reminder is not None:
+        query = query.filter(Task.reminder == reminder)
+    if project_id is not None:
+        query = query.filter(Task.project_id == project_id)
+    if due_before:
+        query = query.filter(Task.due_date <= due_before)
+
+    return query.all()