from datetime import date as date_type from fastapi import APIRouter, Depends, HTTPException, Query from sqlalchemy.orm import Session from typing import List, Optional from database import get_db from models.models import Plan, Task, User from schemas.schemas import PlanResponse, TaskResponse, TaskUpdate, TaskCreate from routes.deps import get_current_user_id from utils import build_task_tree, find_in_tree, calculate_task_depths, collect_descendant_ids router = APIRouter(prefix="/api/plans", tags=["plans"]) XP_BY_DEPTH = {0: 120, 1: 50, 2: 15} XP_ALL_DONE_BONUS = 300 @router.get("/", response_model=List[PlanResponse]) def get_user_plans(user_id: int = Depends(get_current_user_id), db: Session = Depends(get_db)): plans = db.query(Plan).filter(Plan.user_id == user_id).all() plan_ids = [p.id for p in plans] # Batch load all tasks for all plans at once all_tasks = db.query(Task).filter(Task.plan_id.in_(plan_ids)).all() if plan_ids else [] tasks_by_plan = {} for t in all_tasks: tasks_by_plan.setdefault(t.plan_id, []).append(t) result = [] for plan in plans: result.append({ "id": plan.id, "user_id": plan.user_id, "goal": plan.goal, "created_at": plan.created_at, "tasks": build_task_tree(tasks_by_plan.get(plan.id, [])) }) return result @router.get("/{plan_id}", response_model=PlanResponse) def get_plan(plan_id: int, user_id: int = Depends(get_current_user_id), db: Session = Depends(get_db)): plan = db.query(Plan).filter(Plan.id == plan_id, Plan.user_id == user_id).first() if not plan: raise HTTPException(status_code=404, detail="Plan not found") tasks = db.query(Task).filter(Task.plan_id == plan.id).all() return { "id": plan.id, "user_id": plan.user_id, "goal": plan.goal, "created_at": plan.created_at, "tasks": build_task_tree(tasks) } @router.delete("/{plan_id}") def delete_plan(plan_id: int, user_id: int = Depends(get_current_user_id), db: Session = Depends(get_db)): plan = db.query(Plan).filter(Plan.id == plan_id, Plan.user_id == user_id).first() if not plan: raise HTTPException(status_code=404, detail="Plan not found") db.query(Task).filter(Task.plan_id == plan_id).delete() db.delete(plan) db.commit() return {"message": "Plan deleted successfully"} @router.post("/{plan_id}/tasks", response_model=TaskResponse) def create_task(plan_id: int, task_data: TaskCreate, user_id: int = Depends(get_current_user_id), db: Session = Depends(get_db)): """Create a new task under a plan. Optionally set parent_id for subtask.""" plan = db.query(Plan).filter(Plan.id == plan_id, Plan.user_id == user_id).first() if not plan: raise HTTPException(status_code=404, detail="Plan not found") # Validate parent_id if provided parent_id = task_data.parent_id if task_data.parent_id else None if parent_id is not None: parent_task = db.query(Task).filter(Task.id == parent_id, Task.plan_id == plan_id).first() if not parent_task: raise HTTPException(status_code=404, detail="Parent task not found") # Parse due_date due_date_val = None if task_data.due_date: try: due_date_val = date_type.fromisoformat(task_data.due_date) except ValueError: raise HTTPException(status_code=400, detail="Invalid due_date format, use YYYY-MM-DD") task = Task( plan_id=plan_id, parent_id=parent_id, task_id=task_data.task_id, title=task_data.title, description=task_data.description, dependencies=task_data.dependencies, duration_in_hours=task_data.duration_in_hours, priority=task_data.priority, due_date=due_date_val, status=task_data.status, sort_order=task_data.sort_order, ) db.add(task) db.commit() db.refresh(task) # Build response with children all_tasks = db.query(Task).filter(Task.plan_id == plan_id).all() tree = build_task_tree(all_tasks) result = find_in_tree(tree, task.id) return result or task @router.delete("/{plan_id}/tasks/{task_db_id}") def delete_task(plan_id: int, task_db_id: int, user_id: int = Depends(get_current_user_id), db: Session = Depends(get_db)): """Delete a task and all its children (cascade). Also clean up dependency references.""" plan = db.query(Plan).filter(Plan.id == plan_id, Plan.user_id == user_id).first() if not plan: raise HTTPException(status_code=404, detail="Plan not found") task = db.query(Task).filter(Task.id == task_db_id, Task.plan_id == plan_id).first() if not task: raise HTTPException(status_code=404, detail="Task not found") # Load all plan tasks once for batch descendant collection all_plan_tasks = db.query(Task).filter(Task.plan_id == plan_id).all() # Collect all descendant IDs (no N+1) deleted_ids = [task.id] + collect_descendant_ids(all_plan_tasks, task.id) # Collect task_id strings for dependency cleanup deleted_task_ids = set() task_by_id = {t.id: t for t in all_plan_tasks} for tid in deleted_ids: t = task_by_id.get(tid) if t: deleted_task_ids.add(t.task_id) # Remove dependency references to the deleted tasks in remaining tasks for t in all_plan_tasks: if t.id in deleted_ids: continue if t.dependencies: cleaned = [d for d in t.dependencies if d not in deleted_task_ids] if len(cleaned) != len(t.dependencies): t.dependencies = cleaned # Delete the task (cascade will handle children) db.delete(task) db.commit() return {"message": "Task deleted successfully", "deleted_ids": deleted_ids} @router.put("/{plan_id}/tasks/reorder") def reorder_tasks( plan_id: int, task_orders: list[dict], user_id: int = Depends(get_current_user_id), db: Session = Depends(get_db), ): """Batch update sort_order for tasks within a plan.""" plan = db.query(Plan).filter(Plan.id == plan_id, Plan.user_id == user_id).first() if not plan: raise HTTPException(status_code=404, detail="Plan not found") for item in task_orders: task_id = item.get("id") sort_order = item.get("sort_order") if task_id is None or sort_order is None: continue task = db.query(Task).filter(Task.id == task_id, Task.plan_id == plan_id).first() if task: task.sort_order = sort_order db.commit() return {"message": "Tasks reordered successfully"} @router.put("/{plan_id}/tasks/{task_db_id}", response_model=TaskResponse) def update_task(plan_id: int, task_db_id: int, task_data: TaskUpdate, user_id: int = Depends(get_current_user_id), db: Session = Depends(get_db)): task = db.query(Task).filter(Task.id == task_db_id).first() if not task: raise HTTPException(status_code=404, detail="Task not found") plan = db.query(Plan).filter(Plan.id == task.plan_id, Plan.user_id == user_id).first() if not plan: raise HTTPException(status_code=403, detail="Not authorized") update_data = task_data.model_dump(exclude_unset=True) # Handle due_date conversion if "due_date" in update_data: val = update_data.pop("due_date") if val is not None: try: update_data["due_date"] = date_type.fromisoformat(val) except ValueError: raise HTTPException(status_code=400, detail="Invalid due_date format, use YYYY-MM-DD") else: update_data["due_date"] = None for key, value in update_data.items(): setattr(task, key, value) db.commit() db.refresh(task) # Build response with children all_tasks = db.query(Task).filter(Task.plan_id == task.plan_id).all() tree = build_task_tree(all_tasks) result = find_in_tree(tree, task.id) return result or task @router.put("/{plan_id}/tasks/{task_db_id}/status") def update_task_status( plan_id: int, task_db_id: int, status: str = Query(..., description="New status: todo, in_progress, or done"), user_id: int = Depends(get_current_user_id), db: Session = Depends(get_db), ): # Validate status value valid_statuses = {"todo", "in_progress", "done"} if status not in valid_statuses: raise HTTPException(status_code=400, detail=f"Invalid status. Must be one of: {', '.join(valid_statuses)}") task = db.query(Task).filter(Task.id == task_db_id).first() if not task: raise HTTPException(status_code=404, detail="Task not found") plan = db.query(Plan).filter(Plan.id == task.plan_id, Plan.user_id == user_id).first() if not plan: raise HTTPException(status_code=403, detail="Not authorized") # If trying to mark a parent task as done, check all children are done if status == "done": children = db.query(Task).filter(Task.parent_id == task.id).all() if children and not all(c.status == "done" for c in children): raise HTTPException( status_code=400, detail="Cannot mark this task as done until all subtasks are completed" ) # Track all status changes for cascade changes = [{"id": task.id, "status": status}] task.status = status # Cascade up: if all siblings are done, auto-complete parent; if uncompleting, auto-uncomplete parent if task.parent_id is not None: parent = db.query(Task).filter(Task.id == task.parent_id).first() if parent: siblings = db.query(Task).filter(Task.parent_id == parent.id).all() if status == "done": # All siblings done → auto-complete parent if all(s.status == "done" for s in siblings): if parent.status != "done": parent.status = "done" changes.append({"id": parent.id, "status": "done"}) _cascade_parent_completion(parent, db, changes) elif status == "todo": # Uncompleting a child → auto-uncomplete parent if it was done if parent.status == "done": parent.status = "todo" changes.append({"id": parent.id, "status": "todo"}) _cascade_parent_uncompletion(parent, db, changes) # === XP Reward System === # Batch calculate depths (no N+1) all_plan_tasks = db.query(Task).filter(Task.plan_id == plan.id).all() depth_map = calculate_task_depths(all_plan_tasks) xp_change = 0 for change in changes: depth = depth_map.get(change["id"], 0) if change["status"] == "done": xp_change += XP_BY_DEPTH.get(min(depth, 2), 15) elif change["status"] == "todo": # Only deduct XP if the task was previously "done" xp_change -= XP_BY_DEPTH.get(min(depth, 2), 15) # Check if all tasks in the plan are done (bonus XP) # Fix: check regardless of xp_change sign (was only checking when xp_change > 0) all_done_bonus = 0 all_currently_done = all(t.status == "done" for t in all_plan_tasks) if all_currently_done and xp_change > 0: # Only award bonus on the transition to all-done, not when uncompleting all_done_bonus = XP_ALL_DONE_BONUS xp_change += all_done_bonus # Update user XP user = db.query(User).filter(User.id == user_id).first() old_level = min(100, int(((user.xp if user else 0) / 5) ** 0.5)) if user and user.xp > 0 else 0 if user and xp_change != 0: user.xp = max(0, user.xp + xp_change) new_level = min(100, int(((user.xp if user else 0) / 5) ** 0.5)) if user and user.xp > 0 else 0 db.commit() user_xp = user.xp if user else 0 user_level = new_level level_up = new_level > old_level return { "message": "Task status updated", "changes": changes, "xp_change": xp_change, "all_done_bonus": all_done_bonus, "user_xp": user_xp, "user_level": user_level, "level_up": level_up, "old_level": old_level, "new_level": new_level, } def _cascade_parent_completion(task: Task, db: Session, changes: list): """Recursively auto-complete parent if all its children are done.""" if task.parent_id is None: return parent = db.query(Task).filter(Task.id == task.parent_id).first() if not parent: return siblings = db.query(Task).filter(Task.parent_id == parent.id).all() if all(s.status == "done" for s in siblings): if parent.status != "done": parent.status = "done" changes.append({"id": parent.id, "status": "done"}) _cascade_parent_completion(parent, db, changes) def _cascade_parent_uncompletion(task: Task, db: Session, changes: list): """Recursively auto-uncomplete parent chain.""" if task.parent_id is None: return parent = db.query(Task).filter(Task.id == task.parent_id).first() if not parent: return if parent.status == "done": parent.status = "todo" changes.append({"id": parent.id, "status": "todo"}) _cascade_parent_uncompletion(parent, db, changes)