Merge pull request #15 from C216-Distribuid-System-Project/feat/AR-task_route

feat(tasks): add CRUD endpoints for task management module

Author: matheusAFONSECA

src/models/project_model.py

@@ -29,3 +29,4 @@ class Project(Base):
     updated_at = Column(TIMESTAMP, server_default=func.now(), onupdate=func.now())
 
     user = relationship("User", back_populates="projects")
+    tasks = relationship("Task", back_populates="project", cascade="all, delete-orphan")

src/models/task_model.py

@@ -0,0 +1,53 @@
+from sqlalchemy.orm import relationship
+from src.modules.database_conection import Base
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    Text,
+    ForeignKey,
+    TIMESTAMP,
+    func,
+    Boolean,
+    DATETIME,
+)
+
+
+class Task(Base):
+    """
+    Represents a task entity in the to-do list application.
+
+    Attributes:
+        id (int): Primary key identifier for the task.
+        user_id (int): Foreign key referencing the user who owns the task.
+        project_id (int, optional): Foreign key referencing the project the task belongs to.
+        title (str): Title of the task.
+        description (str, optional): Detailed description of the task.
+        due_date (datetime, optional): Deadline for the task.
+        reminder (bool): Flag to enable reminders.
+        completed (bool): Status of the task (completed or not).
+        created_at (datetime): Timestamp when the task was created.
+        updated_at (datetime): Timestamp when the task was last updated.
+        user (User): Relationship to the User model.
+        project (Project): Relationship to the Project model.
+    """
+
+    __tablename__ = "tasks"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(
+        Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False
+    )
+    project_id = Column(
+        Integer, ForeignKey("projects.id", ondelete="CASCADE"), nullable=True
+    )
+    title = Column(String(255), nullable=False)
+    description = Column(Text, nullable=True)
+    due_date = Column(DATETIME, nullable=True)
+    reminder = Column(Boolean, default=False)
+    completed = Column(Boolean, default=False)
+    created_at = Column(TIMESTAMP, server_default=func.now())
+    updated_at = Column(TIMESTAMP, server_default=func.now(), onupdate=func.now())
+
+    user = relationship("User", back_populates="tasks")
+    project = relationship("Project", back_populates="tasks")

src/models/user_model.py

@@ -29,3 +29,5 @@ class User(Base):
 
     # Relationship to projects
     projects = relationship("Project", back_populates="user", cascade="all, delete-orphan")
+
+    tasks = relationship("Task", back_populates="user", cascade="all, delete-orphan")

src/modules/modules_api.py

@@ -1,6 +1,7 @@
 from fastapi import APIRouter
 
 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.authentication_routes import authentication_router
 
@@ -10,3 +11,4 @@
 router.include_router(authentication_router)
 router.include_router(user_router)
 router.include_router(project_router)
+router.include_router(task_router)

src/routes/task_routes.py

@@ -0,0 +1,110 @@
+from typing import List
+from sqlalchemy.orm import Session
+from src.utils.utils import get_db
+from src.models.user_model import User
+from src.models.task_model import Task
+from src.utils.security import get_current_user
+from fastapi import APIRouter, Depends, HTTPException, status
+from src.schemas.tasks.tasks_schema import TaskCreate, TaskResponse
+
+task_router = APIRouter(prefix="/tasks", tags=["tasks"])
+
+
+@task_router.post("/", response_model=TaskResponse, status_code=status.HTTP_201_CREATED)
+def create_task(
+    task: TaskCreate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """
+    Create a new task for the authenticated user.
+    """
+    new_task = Task(**task.model_dump(), user_id=current_user.id)
+    db.add(new_task)
+    db.commit()
+    db.refresh(new_task)
+    return new_task
+
+
+@task_router.get("/", response_model=List[TaskResponse])
+def list_tasks(
+    db: Session = Depends(get_db), current_user: User = Depends(get_current_user)
+):
+    """
+    List all tasks for the authenticated user.
+    """
+    return db.query(Task).filter(Task.user_id == current_user.id).all()
+
+
+@task_router.get("/{task_id}", response_model=TaskResponse)
+def get_task(
+    task_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """
+    Get a specific task by its ID for the authenticated user.
+    """
+    task = (
+        db.query(Task)
+        .filter(Task.id == task_id, Task.user_id == current_user.id)
+        .first()
+    )
+    if not task:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Tarefa com id {task_id} não encontrada.",
+        )
+    return task
+
+
+@task_router.put("/{task_id}", response_model=TaskResponse)
+def update_task(
+    task_id: int,
+    task_update: TaskCreate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """
+    Update a specific task for the authenticated user.
+    """
+    db_task = (
+        db.query(Task)
+        .filter(Task.id == task_id, Task.user_id == current_user.id)
+        .first()
+    )
+    if not db_task:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Tarefa com id {task_id} não encontrada.",
+        )
+
+    for key, value in task_update.model_dump().items():
+        setattr(db_task, key, value)
+
+    db.commit()
+    db.refresh(db_task)
+    return db_task
+
+
+@task_router.delete("/{task_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_task(
+    task_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """
+    Delete a specific task for the authenticated user.
+    """
+    task = (
+        db.query(Task)
+        .filter(Task.id == task_id, Task.user_id == current_user.id)
+        .first()
+    )
+    if not task:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Tarefa com id {task_id} não encontrada.",
+        )
+    db.delete(task)
+    db.commit()

src/schemas/tasks/tasks_schema.py

@@ -0,0 +1,56 @@
+from typing import Optional
+from datetime import datetime
+from pydantic import BaseModel
+
+
+class TaskBase(BaseModel):
+    """
+    Base schema for a task.
+
+    Attributes:
+        title (str): Title of the task.
+        description (Optional[str]): Description of the task.
+        project_id (Optional[int]): ID of the project the task belongs to.
+        due_date (Optional[datetime]): Deadline for the task.
+        reminder (bool): Flag for reminders.
+        completed (bool): Status of the task.
+    """
+
+    title: str
+    description: Optional[str] = None
+    project_id: Optional[int] = None
+    due_date: Optional[datetime] = None
+    reminder: bool = False
+    completed: bool = False
+
+
+class TaskCreate(TaskBase):
+    """
+    Schema for creating a new task. Inherits from TaskBase.
+    """
+
+    pass
+
+
+class TaskResponse(TaskBase):
+    """
+    Schema for API responses for tasks.
+
+    Inherits from TaskBase and adds fields for the task ID,
+    creation timestamp, and last update timestamp.
+
+    Attributes:
+        id (int): Unique identifier for the task.
+        created_at (datetime): Timestamp when the task was created.
+        updated_at (datetime): Timestamp when the task was last updated.
+
+    Config:
+        from_attributes (bool): Enables population from ORM objects.
+    """
+
+    id: int
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True