Add task management functionality with JSON storage and API endpoints

Author: faresh9

backend/api/endpoints/smart.py

@@ -7,7 +7,7 @@
 from backend.core.ai import categorize_email, schedule_meeting, prioritize_task
 from backend.integrations.gmail_service import GmailService
 from backend.integrations.calendar_service import CalendarService
-from backend.integrations.trello_service import TrelloService
+from backend.api.endpoints.task import get_tasks, save_tasks
 
 router = APIRouter(prefix="/api/smart", tags=["smart"])
 
@@ -17,15 +17,11 @@ def get_gmail_service():
 def get_calendar_service():
     return CalendarService()
 
-def get_trello_service():
-    return TrelloService()
-
 @router.post("/email-process")
 def process_email_with_ai(
     request: EmailRequest,
     gmail_service: GmailService = Depends(get_gmail_service),
-    calendar_service: CalendarService = Depends(get_calendar_service),
-    trello_service: TrelloService = Depends(get_trello_service)
+    calendar_service: CalendarService = Depends(get_calendar_service)
 ):
     """Process an email with AI, categorize it, and take appropriate actions."""
     try:
@@ -63,19 +59,26 @@ def process_email_with_ai(
 
         # Check for task-related emails
         if "task" in ai_analysis.lower() or "todo" in ai_analysis.lower() or "action" in ai_analysis.lower():
-            # Get the first Trello board and list for demo purposes
-            boards = trello_service.get_boards()
-            if boards:
-                lists = trello_service.get_lists(boards[0]['id'])
-                if lists:
-                    # Create a task in Trello
-                    card = trello_service.create_card(
-                        list_id=lists[0]['id'],
-                        name=f"Task from email: {subject}",
-                        description=f"Generated from email:\n\n{request.email_text[:1000]}...",
-                        due=None  # Could extract deadline from email text with more complex regex
-                    )
-                    actions_taken.append({"type": "task_created", "details": card})
+            # Create a task from the email
+            task = {
+                "id": f"task_{int(datetime.now().timestamp())}",
+                "description": f"Task from email: {subject}",
+                "assigned_to": "Auto-assigned",
+                "deadline": (datetime.now() + timedelta(days=7)).isoformat(),
+                "priority": "Medium",
+                "status": "To Do",
+                "analysis": ai_analysis,
+                "created_at": datetime.now().isoformat(),
+                "source": "email",
+                "email_content": request.email_text[:1000]
+            }
+            
+            # Save to local storage
+            tasks = get_tasks()
+            tasks.append(task)
+            save_tasks(tasks)
+            
+            actions_taken.append({"type": "task_created", "details": task})
 
         # Reply to the email with a confirmation of actions taken
         if actions_taken:
@@ -156,11 +159,9 @@ def smart_schedule_meeting(
 
 @router.post("/create-task")
 def smart_create_task(
-    request: TaskRequest,
-    board_name: Optional[str] = "Tasks",
-    trello_service: TrelloService = Depends(get_trello_service)
+    request: TaskRequest
 ):
-    """Analyze a task with AI and create it in Trello with appropriate labels and priority."""
+    """Analyze a task with AI and create it with appropriate tags based on priority."""
     try:
         # 1. Get AI analysis
         ai_analysis = prioritize_task(request)
@@ -183,62 +184,35 @@ def smart_create_task(
         elif days_until_deadline <= 7:
             tags.append("Due This Week")
 
-        # 3. Determine which list to place the task in
-        list_name = "To Do"
+        # 3. Determine status based on analysis
+        status = "To Do"
         if "started" in ai_analysis.lower() or "in progress" in ai_analysis.lower():
-            list_name = "In Progress"
-        
-        # 4. Find or create the board and list
-        boards = trello_service.get_boards()
-        board_id = None
+            status = "In Progress"
+        
+        # 4. Create task
+        task = {
+            "id": f"task_{int(datetime.now().timestamp())}",
+            "description": request.description,
+            "assigned_to": request.assigned_to,
+            "deadline": request.deadline,
+            "priority": request.priority,
+            "status": status,
+            "tags": tags,
+            "analysis": ai_analysis,
+            "created_at": datetime.now().isoformat()
+        }
 
-        # Look for an existing board with the specified name
-        for board in boards:
-            if board['name'].lower() == board_name.lower():
-                board_id = board['id']
-                break
-                
-        # Create a new board if needed
-        if not board_id:
-            new_board = trello_service.create_board(board_name)
-            board_id = new_board['id']
-            
-        # Get lists for this board
-        lists = trello_service.get_lists(board_id)
-        list_id = None
-        
-        # Find the appropriate list
-        for lst in lists:
-            if lst['name'].lower() == list_name.lower():
-                list_id = lst['id']
-                break
-                
-        # Create the list if it doesn't exist
-        if not list_id and lists:
-            new_list = trello_service.create_list(board_id, list_name)
-            list_id = new_list['id']
-        elif not list_id and not lists:
-            # Create default lists if board is empty
-            to_do_list = trello_service.create_list(board_id, "To Do")
-            in_progress_list = trello_service.create_list(board_id, "In Progress")
-            done_list = trello_service.create_list(board_id, "Done")
-            list_id = to_do_list['id']
-            
-        # 5. Create the card with all the collected information
-        card = trello_service.create_card(
-            list_id=list_id,
-            name=request.description,
-            description=f"Assigned to: {request.assigned_to}\nAI Analysis: {ai_analysis}",
-            due=deadline_date.isoformat(),
-            labels=tags
-        )
+        # 5. Save to local storage
+        tasks = get_tasks()
+        tasks.append(task)
+        save_tasks(tasks)
 
         return {
             "analysis": ai_analysis,
             "task_created": True,
-            "task_details": card,
+            "task_details": task,
             "tags": tags,
-            "list": list_name
+            "status": status
         }
 
     except Exception as e:

backend/api/endpoints/task.py

@@ -1,13 +1,33 @@
-from fastapi import APIRouter, HTTPException, Depends
+from fastapi import APIRouter, HTTPException, Depends, Body
 from typing import List, Optional
-from backend.core.models import TaskRequest
+from backend.core.models import TaskRequest, TaskStatus
 from backend.core.ai import prioritize_task
-from backend.integrations.trello_service import TrelloService
-
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from pydantic import BaseModel, Field, EmailStr, field_validator
 router = APIRouter(prefix="/api", tags=["task"])
 
-def get_trello_service():
-    return TrelloService()
+# Create a simple file-based task storage
+TASKS_FILE = Path("backend/data/tasks.json")
+
+def get_tasks():
+    """Get all tasks from the local storage."""
+    if not TASKS_FILE.exists():
+        TASKS_FILE.parent.mkdir(parents=True, exist_ok=True)
+        return []
+    
+    try:
+        with open(TASKS_FILE, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError):
+        return []
+
+def save_tasks(tasks):
+    """Save tasks to the local storage."""
+    with open(TASKS_FILE, "w") as f:
+        json.dump(tasks, f, indent=2)
 
 @router.post("/prioritize-task")
 def api_prioritize_task(request: TaskRequest):
@@ -17,34 +37,58 @@ def api_prioritize_task(request: TaskRequest):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-@router.get("/trello/boards")
-def get_trello_boards(trello_service: TrelloService = Depends(get_trello_service)):
+@router.get("/tasks")
+def get_all_tasks():
+    """Get all tasks."""
     try:
-        boards = trello_service.get_boards()
-        return {"boards": boards}
+        return {"tasks": get_tasks()}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-@router.post("/trello/board")
-def create_trello_board(name: str, description: Optional[str] = None, trello_service: TrelloService = Depends(get_trello_service)):
+@router.post("/task")
+def create_task(request: TaskRequest):
+    """Create a new task."""
     try:
-        board = trello_service.create_board(name, description)
-        return board
+        # Use the AI to analyze the task
+        analysis = prioritize_task(request)
+        
+        # Create the task
+        task = {
+            "id": f"task_{int(datetime.now().timestamp())}",
+            "description": request.description,
+            "assigned_to": request.assigned_to,
+            "deadline": request.deadline,
+            "priority": request.priority,
+            "status": "To Do",
+            "analysis": analysis,
+            "created_at": datetime.now().isoformat()
+        }
+        
+        # Save to local storage
+        tasks = get_tasks()
+        tasks.append(task)
+        save_tasks(tasks)
+        
+        return task
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-@router.post("/trello/card")
-def create_trello_card(
-    list_id: str,
-    name: str,
-    description: Optional[str] = None, 
-    due: Optional[str] = None, 
-    labels: Optional[List[str]] = None, 
-    members: Optional[List[str]] = None,
-    trello_service: TrelloService = Depends(get_trello_service)
-):
+class StatusUpdate(BaseModel):
+    status: str
+
+@router.put("/task/{task_id}/status")
+def update_task_status(task_id: str, update: StatusUpdate):
+    """Update a task's status."""
     try:
-        card = trello_service.create_card(list_id, name, description, due, labels, members)
-        return card
+        tasks = get_tasks()
+        
+        for task in tasks:
+            if task.get("id") == task_id:
+                task["status"] = update.status
+                task["updated_at"] = datetime.now().isoformat()
+                save_tasks(tasks)
+                return task
+                
+        raise HTTPException(status_code=404, detail="Task not found")
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))

backend/core/models.py

@@ -1,17 +1,102 @@
-from pydantic import BaseModel
-from typing import List, Optional
+from pydantic import BaseModel, Field, EmailStr, field_validator
+from typing import List, Optional, Dict, Any, Union
+from datetime import datetime, date
+from enum import Enum
+import re
 
+# Enums for consistent value handling
+class Priority(str, Enum):
+    LOW = "Low"
+    MEDIUM = "Medium"
+    HIGH = "High"
+    URGENT = "Urgent"
+
+class TaskStatus(str, Enum):
+    TODO = "To Do"
+    IN_PROGRESS = "In Progress"
+    DONE = "Done"
+
+# Base models
 class EmailRequest(BaseModel):
-    email_text: str
-    
+    """Model for email content to be analyzed by AI."""
+    email_text: str = Field(..., 
+        description="Full email text including headers and body.",
+        examples=["From: john@example.com\nSubject: Meeting Request\n\nCan we schedule a meeting for next week?"])
+
 class MeetingRequest(BaseModel):
-    organizer: str
-    attendees: List[str]
-    proposed_dates: List[str]
-    duration: str
+    """Model for meeting scheduling requests."""
+    organizer: str = Field(..., 
+        description="Name or email of the meeting organizer", 
+        examples=["John Smith", "john@example.com"])
+    attendees: List[str] = Field(..., 
+        description="List of attendee names or emails", 
+        examples=[["jane@example.com", "Mark Wilson", "sarah@example.com"]])
+    proposed_dates: List[str] = Field(..., 
+        description="List of potential meeting dates in YYYY-MM-DD format", 
+        examples=[["2025-04-01", "2025-04-02", "2025-04-03"]])
+    duration: str = Field(..., 
+        description="Meeting duration in hours or minutes", 
+        examples=["1 hour", "30 minutes", "2 hours"])
 
+    @field_validator('proposed_dates')
+    def validate_dates(cls, dates):
+        """Ensure dates are in the correct format."""
+        date_pattern = re.compile(r'^\d{4}-\d{2}-\d{2}$')
+        for d in dates:
+            if not date_pattern.match(d):
+                raise ValueError(f"Date {d} must be in YYYY-MM-DD format")
+        return dates
+
 class TaskRequest(BaseModel):
+    """Model for task creation requests."""
+    description: str = Field(..., 
+        description="Task description/title", 
+        examples=["Complete project proposal"])
+    assigned_to: str = Field(..., 
+        description="Person assigned to this task", 
+        examples=["John Smith"])
+    deadline: str = Field(..., 
+        description="Task deadline in YYYY-MM-DD format", 
+        examples=["2025-04-15"])
+    priority: Priority = Field(Priority.MEDIUM, 
+        description="Task priority level")
+    
+    @field_validator('deadline')
+    def validate_deadline(cls, deadline):
+        """Ensure deadline is in the correct format."""
+        try:
+            datetime.strptime(deadline, "%Y-%m-%d")
+            return deadline
+        except ValueError:
+            raise ValueError("Deadline must be in YYYY-MM-DD format")
+
+# Response models for consistent API responses
+class AnalysisResponse(BaseModel):
+    """Standard response for AI analysis requests."""
+    analysis: str
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+class TaskResponse(BaseModel):
+    """Standard response model for task operations."""
+    id: str
     description: str
     assigned_to: str
     deadline: str
-    priority: Optional[str] = "Medium"
+    priority: str
+    status: str
+    analysis: Optional[str] = None
+    tags: Optional[List[str]] = None
+    created_at: str
+    updated_at: Optional[str] = None
+
+class EmailProcessResponse(BaseModel):
+    """Response model for email processing."""
+    analysis: str
+    actions_taken: List[Dict[str, Any]]
+
+class MeetingScheduleResponse(BaseModel):
+    """Response model for meeting scheduling."""
+    recommendation: str
+    event_created: bool
+    event_details: Dict[str, Any]
+    scheduled_time: Dict[str, str]

backend/data/tasks.json

@@ -0,0 +1,37 @@
+[
+  {
+    "id": "task_1742498524",
+    "description": "Complete project proposal",
+    "assigned_to": "John Smith",
+    "deadline": "2025-04-15",
+    "priority": "High",
+    "status": "Done",
+    "analysis": "This is a high priority task with creation deadline approaching. I recommend immediate focus to outline key project sections. Allocate approximately 4 hours for initial draft creation, followed by 2 hours for review and revision. Notify project manager upon completion for feedback integration.",
+    "created_at": "2025-03-20T22:22:04.266193",
+    "updated_at": "2025-03-20T22:39:09.910434"
+  },
+  {
+    "id": "task_1742498555",
+    "description": "Complete project proposal",
+    "assigned_to": "John Smith",
+    "deadline": "2025-04-15",
+    "priority": "High",
+    "status": "To Do",
+    "analysis": "This is a high priority task assigned to John Smith with a impending deadline. I recommend immediate action to outline the project scope and key deliverables. John should focus on research, planning, and drafting the proposal today, aiming for completion by tomorrow.",
+    "created_at": "2025-03-20T22:22:35.222861"
+  },
+  {
+    "id": "task_1742499620",
+    "description": "Fix critical server outage",
+    "assigned_to": "IT Support",
+    "deadline": "2025-03-25",
+    "priority": "Urgent",
+    "status": "To Do",
+    "tags": [
+      "Urgent",
+      "Due This Week"
+    ],
+    "analysis": "This is an urgent task requiring immediate attention. The IT Support team should focus on resolving the server outage problem promptly. Other non-critical tasks should be postponed to prioritize this issue.",
+    "created_at": "2025-03-20T22:40:20.122205"
+  }
+]