'code'

src/main.py

@@ -2,7 +2,7 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from .config import settings
 
-from .routers import auth, tasks, projects, chat, audit
+from .routers import auth, tasks, projects, chat, audit, stats
 from .utils.health_check import kafka_health_checker
 
 app = FastAPI(
@@ -17,6 +17,7 @@ app.include_router(tasks.router)
 app.include_router(projects.router)
 app.include_router(chat.router)
 app.include_router(audit.router)
+app.include_router(stats.router)
 
 # Prepare allowed origins from settings.FRONTEND_URL (comma separated)
 _frontend_origins = [o.strip() for o in settings.FRONTEND_URL.split(",")] if settings.FRONTEND_URL else []

src/routers/__init__.py

@@ -1,3 +1,3 @@
-from . import auth, tasks, projects, chat, audit
+from . import auth, tasks, projects, chat, audit, stats
 
-__all__ = ["auth", "tasks", "projects", "chat", "audit"]
+__all__ = ["auth", "tasks", "projects", "chat", "audit", "stats"]

src/routers/audit.py

@@ -1,8 +1,10 @@
 from fastapi import APIRouter, HTTPException, Depends, status, Body
 from sqlmodel import Session, select
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 from uuid import UUID
 import logging
+from datetime import datetime
+import uuid
 
 from ..models.audit_log import AuditLog, AuditLogCreate
 from ..models.user import User
@@ -76,6 +78,95 @@ async def receive_audit_event(
         return {"status": "error", "message": str(e)}
 
 
+@router.post("/events/{user_id}")
+async def create_audit_event(
+    user_id: str,
+    data: Dict[str, Any] = Body(...),
+    current_user: User = Depends(get_current_user),
+    session: Session = Depends(get_session_dep)
+):
+    """
+    Frontend API endpoint to create audit events for task operations.
+    Called by the frontend when tasks are created, updated, completed, or deleted.
+    
+    Expected request body:
+    {
+        "event_type": "created|updated|completed|deleted",
+        "task_id": 123,
+        "event_data": {
+            "title": "task title",
+            "description": "optional description",
+            "completed": false
+        }
+    }
+    """
+    try:
+        # Verify that the user is creating audit events for themselves
+        if str(current_user.id) != user_id:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Unauthorized"
+            )
+        
+        # Extract fields from request body
+        event_type = data.get("event_type")
+        task_id = data.get("task_id")
+        event_data = data.get("event_data", {})
+        
+        # Validate required fields
+        if not event_type or not task_id:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Missing required fields: event_type, task_id"
+            )
+        
+        # Validate event type
+        valid_event_types = ['created', 'updated', 'completed', 'deleted']
+        if event_type not in valid_event_types:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Invalid event type. Must be one of: {valid_event_types}"
+            )
+        
+        # Generate unique event ID
+        event_id = str(uuid.uuid4())
+        
+        # Create audit log entry
+        audit_log = AuditLog(
+            event_id=event_id,
+            event_type=event_type,
+            user_id=user_id,
+            task_id=task_id,
+            event_data={
+                "title": event_data.get("title", ""),
+                "description": event_data.get("description", ""),
+                "completed": event_data.get("completed", False)
+            }
+        )
+        
+        session.add(audit_log)
+        session.commit()
+        session.refresh(audit_log)
+        
+        logger.info(f"Audit event {event_id} created successfully for user {user_id}")
+        return {
+            "status": "success",
+            "message": "Audit event created",
+            "id": audit_log.id,
+            "event_id": audit_log.event_id
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating audit event: {e}", exc_info=True)
+        session.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to create audit event: {str(e)}"
+        )
+
+
 @router.get("/events/{user_id}", response_model=dict)
 async def get_user_audit_events(
     user_id: UUID,

src/routers/stats.py

@@ -0,0 +1,166 @@
+"""
+Task statistics router
+Provides endpoints for calculating and retrieving task statistics
+"""
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from datetime import datetime, timedelta
+from src.database import get_db
+from src.models.task import Task
+from src.models.user import User
+from src.middleware.auth import get_current_user
+
+router = APIRouter(prefix="/api", tags=["stats"])
+
+
+@router.get("/{user_id}/tasks/stats")
+async def get_task_stats(
+    user_id: str,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Get task statistics for a user.
+    Returns: total tasks, completed tasks, pending tasks, completion rate, streak, etc.
+    """
+    # Verify user is requesting their own stats
+    if current_user.id != user_id:
+        raise HTTPException(status_code=403, detail="Unauthorized")
+    
+    # Get all tasks for user
+    tasks = db.query(Task).filter(Task.user_id == user_id).all()
+    
+    total = len(tasks)
+    completed = len([t for t in tasks if t.completed])
+    pending = total - completed
+    completion_rate = (completed / total * 100) if total > 0 else 0
+    
+    # Calculate streak (consecutive days with completed tasks)
+    streak = calculate_streak(tasks)
+    
+    # Get achievements
+    achievements = calculate_achievements(total, completed, streak)
+    
+    # Chart data for last 7 days
+    chart_data = calculate_chart_data(tasks)
+    
+    return {
+        "total": total,
+        "completed": completed,
+        "pending": pending,
+        "completionRate": completion_rate,
+        "streak": streak,
+        "achievements": achievements,
+        "chartData": chart_data
+    }
+
+
+def calculate_streak(tasks: list) -> int:
+    """Calculate consecutive days with completed tasks"""
+    if not tasks:
+        return 0
+    
+    # Sort tasks by completion date (most recent first)
+    completed_tasks = sorted(
+        [t for t in tasks if t.completed and t.updated_at],
+        key=lambda x: x.updated_at,
+        reverse=True
+    )
+    
+    if not completed_tasks:
+        return 0
+    
+    streak = 0
+    current_date = datetime.now().date()
+    
+    for task in completed_tasks:
+        task_date = task.updated_at.date() if hasattr(task.updated_at, 'date') else task.updated_at
+        
+        # Check if task was completed today or yesterday from current streak
+        if task_date == current_date or task_date == current_date - timedelta(days=streak):
+            streak += 1
+            current_date = task_date
+        else:
+            break
+    
+    return streak
+
+
+def calculate_achievements(total: int, completed: int, streak: int) -> list:
+    """Calculate unlocked achievements based on stats"""
+    achievements = []
+    
+    # First task completed
+    if completed >= 1:
+        achievements.append({
+            "id": "first_task",
+            "name": "Getting Started",
+            "description": "Completed your first task",
+            "icon": "Star",
+            "unlocked": True
+        })
+    
+    # 5 tasks completed
+    if completed >= 5:
+        achievements.append({
+            "id": "five_tasks",
+            "name": "Task Master",
+            "description": "Completed 5 tasks",
+            "icon": "Trophy",
+            "unlocked": True
+        })
+    
+    # 10 tasks completed
+    if completed >= 10:
+        achievements.append({
+            "id": "ten_tasks",
+            "name": "Productivity Pro",
+            "description": "Completed 10 tasks",
+            "icon": "Zap",
+            "unlocked": True
+        })
+    
+    # 3 day streak
+    if streak >= 3:
+        achievements.append({
+            "id": "three_day_streak",
+            "name": "On Fire",
+            "description": "3 day completion streak",
+            "icon": "Flame",
+            "unlocked": True
+        })
+    
+    # 100% completion rate
+    if total > 0 and (completed / total) == 1.0:
+        achievements.append({
+            "id": "perfect_score",
+            "name": "Perfect Score",
+            "description": "100% task completion rate",
+            "icon": "Award",
+            "unlocked": True
+        })
+    
+    return achievements
+
+
+def calculate_chart_data(tasks: list) -> list:
+    """Calculate chart data for last 7 days"""
+    chart_data = []
+    today = datetime.now().date()
+    
+    for i in range(6, -1, -1):
+        date = today - timedelta(days=i)
+        count = len([
+            t for t in tasks
+            if t.completed
+            and hasattr(t.updated_at, 'date')
+            and t.updated_at.date() == date
+        ])
+        
+        chart_data.append({
+            "date": date.strftime("%a"),
+            "count": count,
+            "isToday": date == today
+        })
+    
+    return chart_data

src/routers/tasks.py

@@ -2,7 +2,7 @@ from fastapi import APIRouter, HTTPException, status, Depends
 from sqlmodel import Session, select, and_, func
 from typing import List
 from uuid import UUID
-from datetime import datetime, timedelta, date
+from datetime import datetime, timedelta, date, timezone
 import logging
 import uuid as uuid_lib
 
@@ -80,7 +80,7 @@ def get_task_stats(
     
     streak = 0
     if completed_dates:
-        today = datetime.now(datetime.UTC).date()
+        today = datetime.now(timezone.utc).date()
         yesterday = today - timedelta(days=1)
         
         # Check if the streak is still active (completed something today or yesterday)
@@ -140,7 +140,7 @@ def get_task_stats(
     # Productivity chart data (last 7 days)
     chart_data = []
     for i in range(6, -1, -1):
-        day = (datetime.now(datetime.UTC) - timedelta(days=i)).date()
+        day = (datetime.now(timezone.utc) - timedelta(days=i)).date()
         count = len([t for t in completed_tasks if t.updated_at.date() == day])
         chart_data.append({
             "date": day.strftime("%a"), 
@@ -386,7 +386,7 @@ async def update_task(
         task.project_id = task_data.project_id
 
     # Update the timestamp
-    task.updated_at = datetime.now(datetime.UTC)
+    task.updated_at = datetime.now(timezone.utc)
 
     session.add(task)
     session.commit()
@@ -484,7 +484,7 @@ async def patch_task(
         task.project_id = task_data.project_id
 
     # Update the timestamp
-    task.updated_at = datetime.now(datetime.UTC)
+    task.updated_at = datetime.now(timezone.utc)
 
     session.add(task)
     session.commit()
@@ -599,7 +599,7 @@ async def toggle_task_completion(
 
     # Toggle the completion status
     task.completed = not task.completed
-    task.updated_at = datetime.now(datetime.UTC)
+    task.updated_at = datetime.now(timezone.utc)
 
     session.add(task)
     session.commit()