summaryrefslogtreecommitdiff
path: root/internal/handlers
diff options
context:
space:
mode:
Diffstat (limited to 'internal/handlers')
-rw-r--r--internal/handlers/ai_handlers.go273
-rw-r--r--internal/handlers/handlers.go360
-rw-r--r--internal/handlers/handlers_test.go393
3 files changed, 1026 insertions, 0 deletions
diff --git a/internal/handlers/ai_handlers.go b/internal/handlers/ai_handlers.go
new file mode 100644
index 0000000..26c945e
--- /dev/null
+++ b/internal/handlers/ai_handlers.go
@@ -0,0 +1,273 @@
+package handlers
+
+import (
+ "encoding/json"
+ "log"
+ "net/http"
+ "time"
+
+ "task-dashboard/internal/models"
+)
+
+// AISnapshotResponse matches the exact format requested by the user
+type AISnapshotResponse struct {
+ GeneratedAt string `json:"generated_at"`
+ Tasks AITasksSection `json:"tasks"`
+ Meals AIMealsSection `json:"meals"`
+ Notes AINotesSection `json:"notes"`
+ TrelloBoards []AITrelloBoard `json:"trello_boards,omitempty"`
+}
+
+type AITasksSection struct {
+ Today []AITask `json:"today"`
+ Overdue []AITask `json:"overdue"`
+ Next7Days []AITask `json:"next_7_days"`
+}
+
+type AITask struct {
+ ID string `json:"id"`
+ Content string `json:"content"`
+ Priority int `json:"priority"`
+ Due *string `json:"due,omitempty"`
+ Project string `json:"project"`
+ Completed bool `json:"completed"`
+}
+
+type AIMealsSection struct {
+ Today AIDayMeals `json:"today"`
+ Next7Days []AIDayMeals `json:"next_7_days"`
+}
+
+type AIDayMeals struct {
+ Date string `json:"date"`
+ Breakfast string `json:"breakfast,omitempty"`
+ Lunch string `json:"lunch,omitempty"`
+ Dinner string `json:"dinner,omitempty"`
+ Snack string `json:"snack,omitempty"`
+}
+
+type AINotesSection struct {
+ Recent []AINote `json:"recent"`
+}
+
+type AINote struct {
+ Title string `json:"title"`
+ Modified string `json:"modified"`
+ Preview string `json:"preview"`
+ Path string `json:"path"`
+}
+
+type AITrelloBoard struct {
+ ID string `json:"id"`
+ Name string `json:"name"`
+ Cards []AITrelloCard `json:"cards"`
+}
+
+type AITrelloCard struct {
+ ID string `json:"id"`
+ Name string `json:"name"`
+ List string `json:"list"`
+ Due *string `json:"due,omitempty"`
+ URL string `json:"url"`
+}
+
+// HandleAISnapshot returns a complete dashboard snapshot optimized for AI consumption
+func (h *Handler) HandleAISnapshot(w http.ResponseWriter, r *http.Request) {
+ ctx := r.Context()
+
+ // Fetch all data (with caching)
+ data, err := h.aggregateData(ctx, false)
+ if err != nil {
+ respondJSON(w, http.StatusInternalServerError, map[string]string{
+ "error": "server_error",
+ "message": "Failed to fetch dashboard data",
+ })
+ log.Printf("AI snapshot error: %v", err)
+ return
+ }
+
+ // Build AI-optimized response
+ response := AISnapshotResponse{
+ GeneratedAt: time.Now().UTC().Format(time.RFC3339),
+ Tasks: buildAITasksSection(data.Tasks),
+ Meals: buildAIMealsSection(data.Meals),
+ Notes: buildAINotesSection(data.Notes),
+ TrelloBoards: buildAITrelloBoardsSection(data.Boards),
+ }
+
+ respondJSON(w, http.StatusOK, response)
+}
+
+// buildAITasksSection organizes tasks by time window
+func buildAITasksSection(tasks []models.Task) AITasksSection {
+ now := time.Now()
+ today := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+ next7Days := today.AddDate(0, 0, 7)
+
+ section := AITasksSection{
+ Today: []AITask{},
+ Overdue: []AITask{},
+ Next7Days: []AITask{},
+ }
+
+ for _, task := range tasks {
+ if task.Completed {
+ continue // Skip completed tasks
+ }
+
+ aiTask := AITask{
+ ID: task.ID,
+ Content: task.Content,
+ Priority: task.Priority,
+ Project: task.ProjectName,
+ Completed: task.Completed,
+ }
+
+ if task.DueDate != nil {
+ dueStr := task.DueDate.UTC().Format(time.RFC3339)
+ aiTask.Due = &dueStr
+
+ taskDay := time.Date(task.DueDate.Year(), task.DueDate.Month(), task.DueDate.Day(), 0, 0, 0, 0, task.DueDate.Location())
+
+ if taskDay.Before(today) {
+ section.Overdue = append(section.Overdue, aiTask)
+ } else if taskDay.Equal(today) {
+ section.Today = append(section.Today, aiTask)
+ } else if taskDay.Before(next7Days) {
+ section.Next7Days = append(section.Next7Days, aiTask)
+ }
+ }
+ }
+
+ return section
+}
+
+// buildAIMealsSection organizes meals by day
+func buildAIMealsSection(meals []models.Meal) AIMealsSection {
+ now := time.Now()
+ today := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+ next7Days := today.AddDate(0, 0, 7)
+
+ section := AIMealsSection{
+ Today: AIDayMeals{Date: today.Format("2006-01-02")},
+ Next7Days: []AIDayMeals{},
+ }
+
+ // Group meals by date
+ mealsByDate := make(map[string]*AIDayMeals)
+
+ for _, meal := range meals {
+ mealDay := time.Date(meal.Date.Year(), meal.Date.Month(), meal.Date.Day(), 0, 0, 0, 0, meal.Date.Location())
+
+ if mealDay.Before(today) || mealDay.After(next7Days) {
+ continue // Skip meals outside our window
+ }
+
+ dateStr := mealDay.Format("2006-01-02")
+
+ if _, exists := mealsByDate[dateStr]; !exists {
+ mealsByDate[dateStr] = &AIDayMeals{Date: dateStr}
+ }
+
+ dayMeals := mealsByDate[dateStr]
+
+ switch meal.MealType {
+ case "breakfast":
+ dayMeals.Breakfast = meal.RecipeName
+ case "lunch":
+ dayMeals.Lunch = meal.RecipeName
+ case "dinner":
+ dayMeals.Dinner = meal.RecipeName
+ case "snack":
+ dayMeals.Snack = meal.RecipeName
+ }
+ }
+
+ // Assign today's meals
+ if todayMeals, exists := mealsByDate[today.Format("2006-01-02")]; exists {
+ section.Today = *todayMeals
+ }
+
+ // Collect next 7 days (excluding today)
+ for i := 1; i <= 7; i++ {
+ day := today.AddDate(0, 0, i)
+ dateStr := day.Format("2006-01-02")
+ if dayMeals, exists := mealsByDate[dateStr]; exists {
+ section.Next7Days = append(section.Next7Days, *dayMeals)
+ }
+ }
+
+ return section
+}
+
+// buildAINotesSection returns the 10 most recent notes with previews
+func buildAINotesSection(notes []models.Note) AINotesSection {
+ section := AINotesSection{
+ Recent: []AINote{},
+ }
+
+ // Limit to 10 most recent
+ limit := 10
+ if len(notes) < limit {
+ limit = len(notes)
+ }
+
+ for i := 0; i < limit; i++ {
+ note := notes[i]
+
+ // Limit preview to 150 chars
+ preview := note.Content
+ if len(preview) > 150 {
+ preview = preview[:150] + "..."
+ }
+
+ section.Recent = append(section.Recent, AINote{
+ Title: note.Title,
+ Modified: note.Modified.UTC().Format(time.RFC3339),
+ Preview: preview,
+ Path: note.Path,
+ })
+ }
+
+ return section
+}
+
+// buildAITrelloBoardsSection formats Trello boards for AI
+func buildAITrelloBoardsSection(boards []models.Board) []AITrelloBoard {
+ aiBoards := []AITrelloBoard{}
+
+ for _, board := range boards {
+ aiBoard := AITrelloBoard{
+ ID: board.ID,
+ Name: board.Name,
+ Cards: []AITrelloCard{},
+ }
+
+ for _, card := range board.Cards {
+ aiCard := AITrelloCard{
+ ID: card.ID,
+ Name: card.Name,
+ List: card.ListName,
+ URL: card.URL,
+ }
+
+ if card.DueDate != nil {
+ dueStr := card.DueDate.UTC().Format(time.RFC3339)
+ aiCard.Due = &dueStr
+ }
+
+ aiBoard.Cards = append(aiBoard.Cards, aiCard)
+ }
+
+ aiBoards = append(aiBoards, aiBoard)
+ }
+
+ return aiBoards
+}
+
+// respondJSON sends a JSON response
+func respondJSON(w http.ResponseWriter, status int, data interface{}) {
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(status)
+ json.NewEncoder(w).Encode(data)
+}
diff --git a/internal/handlers/handlers.go b/internal/handlers/handlers.go
new file mode 100644
index 0000000..6872ba7
--- /dev/null
+++ b/internal/handlers/handlers.go
@@ -0,0 +1,360 @@
+package handlers
+
+import (
+ "context"
+ "encoding/json"
+ "html/template"
+ "log"
+ "net/http"
+ "sync"
+ "time"
+
+ "task-dashboard/internal/api"
+ "task-dashboard/internal/config"
+ "task-dashboard/internal/models"
+ "task-dashboard/internal/store"
+)
+
+// Handler holds dependencies for HTTP handlers
+type Handler struct {
+ store *store.Store
+ todoistClient api.TodoistAPI
+ trelloClient api.TrelloAPI
+ obsidianClient api.ObsidianAPI
+ planToEatClient api.PlanToEatAPI
+ config *config.Config
+ templates *template.Template
+}
+
+// New creates a new Handler instance
+func New(store *store.Store, todoist api.TodoistAPI, trello api.TrelloAPI, obsidian api.ObsidianAPI, planToEat api.PlanToEatAPI, cfg *config.Config) *Handler {
+ // Parse templates
+ tmpl, err := template.ParseGlob("web/templates/*.html")
+ if err != nil {
+ log.Printf("Warning: failed to parse templates: %v", err)
+ }
+
+ return &Handler{
+ store: store,
+ todoistClient: todoist,
+ trelloClient: trello,
+ obsidianClient: obsidian,
+ planToEatClient: planToEat,
+ config: cfg,
+ templates: tmpl,
+ }
+}
+
+// HandleDashboard renders the main dashboard view
+func (h *Handler) HandleDashboard(w http.ResponseWriter, r *http.Request) {
+ ctx := r.Context()
+
+ // Aggregate data from all sources
+ data, err := h.aggregateData(ctx, false)
+ if err != nil {
+ http.Error(w, "Failed to load dashboard data", http.StatusInternalServerError)
+ log.Printf("Error aggregating data: %v", err)
+ return
+ }
+
+ // Render template
+ if h.templates == nil {
+ http.Error(w, "Templates not loaded", http.StatusInternalServerError)
+ return
+ }
+
+ if err := h.templates.ExecuteTemplate(w, "index.html", data); err != nil {
+ http.Error(w, "Failed to render template", http.StatusInternalServerError)
+ log.Printf("Error rendering template: %v", err)
+ }
+}
+
+// HandleRefresh forces a refresh of all data
+func (h *Handler) HandleRefresh(w http.ResponseWriter, r *http.Request) {
+ ctx := r.Context()
+
+ // Force refresh by passing true
+ data, err := h.aggregateData(ctx, true)
+ if err != nil {
+ http.Error(w, "Failed to refresh data", http.StatusInternalServerError)
+ log.Printf("Error refreshing data: %v", err)
+ return
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ json.NewEncoder(w).Encode(data)
+}
+
+// HandleGetTasks returns tasks as JSON
+func (h *Handler) HandleGetTasks(w http.ResponseWriter, r *http.Request) {
+ tasks, err := h.store.GetTasks()
+ if err != nil {
+ http.Error(w, "Failed to get tasks", http.StatusInternalServerError)
+ return
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ json.NewEncoder(w).Encode(tasks)
+}
+
+// HandleGetNotes returns notes as JSON
+func (h *Handler) HandleGetNotes(w http.ResponseWriter, r *http.Request) {
+ notes, err := h.store.GetNotes(20)
+ if err != nil {
+ http.Error(w, "Failed to get notes", http.StatusInternalServerError)
+ return
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ json.NewEncoder(w).Encode(notes)
+}
+
+// HandleGetMeals returns meals as JSON
+func (h *Handler) HandleGetMeals(w http.ResponseWriter, r *http.Request) {
+ startDate := time.Now()
+ endDate := startDate.AddDate(0, 0, 7)
+
+ meals, err := h.store.GetMeals(startDate, endDate)
+ if err != nil {
+ http.Error(w, "Failed to get meals", http.StatusInternalServerError)
+ return
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ json.NewEncoder(w).Encode(meals)
+}
+
+// HandleGetBoards returns Trello boards with cards as JSON
+func (h *Handler) HandleGetBoards(w http.ResponseWriter, r *http.Request) {
+ boards, err := h.store.GetBoards()
+ if err != nil {
+ http.Error(w, "Failed to get boards", http.StatusInternalServerError)
+ return
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ json.NewEncoder(w).Encode(boards)
+}
+
+// aggregateData fetches and caches data from all sources
+func (h *Handler) aggregateData(ctx context.Context, forceRefresh bool) (*models.DashboardData, error) {
+ data := &models.DashboardData{
+ LastUpdated: time.Now(),
+ Errors: make([]string, 0),
+ }
+
+ var wg sync.WaitGroup
+ var mu sync.Mutex
+
+ // Fetch Trello boards (PRIORITY - most important)
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ boards, err := h.fetchBoards(ctx, forceRefresh)
+ mu.Lock()
+ defer mu.Unlock()
+ if err != nil {
+ data.Errors = append(data.Errors, "Trello: "+err.Error())
+ } else {
+ data.Boards = boards
+ }
+ }()
+
+ // Fetch Todoist tasks
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ tasks, err := h.fetchTasks(ctx, forceRefresh)
+ mu.Lock()
+ defer mu.Unlock()
+ if err != nil {
+ data.Errors = append(data.Errors, "Todoist: "+err.Error())
+ } else {
+ data.Tasks = tasks
+ }
+ }()
+
+ // Fetch Obsidian notes (if configured)
+ if h.obsidianClient != nil {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ notes, err := h.fetchNotes(ctx, forceRefresh)
+ mu.Lock()
+ defer mu.Unlock()
+ if err != nil {
+ data.Errors = append(data.Errors, "Obsidian: "+err.Error())
+ } else {
+ data.Notes = notes
+ }
+ }()
+ }
+
+ // Fetch PlanToEat meals (if configured)
+ if h.planToEatClient != nil {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ meals, err := h.fetchMeals(ctx, forceRefresh)
+ mu.Lock()
+ defer mu.Unlock()
+ if err != nil {
+ data.Errors = append(data.Errors, "PlanToEat: "+err.Error())
+ } else {
+ data.Meals = meals
+ }
+ }()
+ }
+
+ wg.Wait()
+
+ return data, nil
+}
+
+// fetchTasks fetches tasks from cache or API
+func (h *Handler) fetchTasks(ctx context.Context, forceRefresh bool) ([]models.Task, error) {
+ cacheKey := "todoist_tasks"
+
+ // Check cache validity
+ if !forceRefresh {
+ valid, err := h.store.IsCacheValid(cacheKey)
+ if err == nil && valid {
+ return h.store.GetTasks()
+ }
+ }
+
+ // Fetch from API
+ tasks, err := h.todoistClient.GetTasks(ctx)
+ if err != nil {
+ // Try to return cached data even if stale
+ cachedTasks, cacheErr := h.store.GetTasks()
+ if cacheErr == nil && len(cachedTasks) > 0 {
+ return cachedTasks, nil
+ }
+ return nil, err
+ }
+
+ // Save to cache
+ if err := h.store.SaveTasks(tasks); err != nil {
+ log.Printf("Failed to save tasks to cache: %v", err)
+ }
+
+ // Update cache metadata
+ if err := h.store.UpdateCacheMetadata(cacheKey, h.config.CacheTTLMinutes); err != nil {
+ log.Printf("Failed to update cache metadata: %v", err)
+ }
+
+ return tasks, nil
+}
+
+// fetchNotes fetches notes from cache or filesystem
+func (h *Handler) fetchNotes(ctx context.Context, forceRefresh bool) ([]models.Note, error) {
+ cacheKey := "obsidian_notes"
+
+ // Check cache validity
+ if !forceRefresh {
+ valid, err := h.store.IsCacheValid(cacheKey)
+ if err == nil && valid {
+ return h.store.GetNotes(20)
+ }
+ }
+
+ // Fetch from filesystem
+ notes, err := h.obsidianClient.GetNotes(ctx, 20)
+ if err != nil {
+ // Try to return cached data even if stale
+ cachedNotes, cacheErr := h.store.GetNotes(20)
+ if cacheErr == nil && len(cachedNotes) > 0 {
+ return cachedNotes, nil
+ }
+ return nil, err
+ }
+
+ // Save to cache
+ if err := h.store.SaveNotes(notes); err != nil {
+ log.Printf("Failed to save notes to cache: %v", err)
+ }
+
+ // Update cache metadata
+ if err := h.store.UpdateCacheMetadata(cacheKey, h.config.CacheTTLMinutes); err != nil {
+ log.Printf("Failed to update cache metadata: %v", err)
+ }
+
+ return notes, nil
+}
+
+// fetchMeals fetches meals from cache or API
+func (h *Handler) fetchMeals(ctx context.Context, forceRefresh bool) ([]models.Meal, error) {
+ cacheKey := "plantoeat_meals"
+
+ // Check cache validity
+ if !forceRefresh {
+ valid, err := h.store.IsCacheValid(cacheKey)
+ if err == nil && valid {
+ startDate := time.Now()
+ endDate := startDate.AddDate(0, 0, 7)
+ return h.store.GetMeals(startDate, endDate)
+ }
+ }
+
+ // Fetch from API
+ meals, err := h.planToEatClient.GetUpcomingMeals(ctx, 7)
+ if err != nil {
+ // Try to return cached data even if stale
+ startDate := time.Now()
+ endDate := startDate.AddDate(0, 0, 7)
+ cachedMeals, cacheErr := h.store.GetMeals(startDate, endDate)
+ if cacheErr == nil && len(cachedMeals) > 0 {
+ return cachedMeals, nil
+ }
+ return nil, err
+ }
+
+ // Save to cache
+ if err := h.store.SaveMeals(meals); err != nil {
+ log.Printf("Failed to save meals to cache: %v", err)
+ }
+
+ // Update cache metadata
+ if err := h.store.UpdateCacheMetadata(cacheKey, h.config.CacheTTLMinutes); err != nil {
+ log.Printf("Failed to update cache metadata: %v", err)
+ }
+
+ return meals, nil
+}
+
+// fetchBoards fetches Trello boards from cache or API
+func (h *Handler) fetchBoards(ctx context.Context, forceRefresh bool) ([]models.Board, error) {
+ cacheKey := "trello_boards"
+
+ // Check cache validity
+ if !forceRefresh {
+ valid, err := h.store.IsCacheValid(cacheKey)
+ if err == nil && valid {
+ return h.store.GetBoards()
+ }
+ }
+
+ // Fetch from API
+ boards, err := h.trelloClient.GetBoardsWithCards(ctx)
+ if err != nil {
+ // Try to return cached data even if stale
+ cachedBoards, cacheErr := h.store.GetBoards()
+ if cacheErr == nil && len(cachedBoards) > 0 {
+ return cachedBoards, nil
+ }
+ return nil, err
+ }
+
+ // Save to cache
+ if err := h.store.SaveBoards(boards); err != nil {
+ log.Printf("Failed to save boards to cache: %v", err)
+ }
+
+ // Update cache metadata
+ if err := h.store.UpdateCacheMetadata(cacheKey, h.config.CacheTTLMinutes); err != nil {
+ log.Printf("Failed to update cache metadata: %v", err)
+ }
+
+ return boards, nil
+}
diff --git a/internal/handlers/handlers_test.go b/internal/handlers/handlers_test.go
new file mode 100644
index 0000000..902bebb
--- /dev/null
+++ b/internal/handlers/handlers_test.go
@@ -0,0 +1,393 @@
+package handlers
+
+import (
+ "context"
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "testing"
+ "time"
+
+ "task-dashboard/internal/config"
+ "task-dashboard/internal/models"
+ "task-dashboard/internal/store"
+)
+
+// setupTestDB creates a temporary test database
+func setupTestDB(t *testing.T) (*store.Store, func()) {
+ t.Helper()
+
+ // Create temp database file
+ tmpFile, err := os.CreateTemp("", "test_*.db")
+ if err != nil {
+ t.Fatalf("Failed to create temp db: %v", err)
+ }
+ tmpFile.Close()
+
+ // Save current directory and change to project root
+ // This ensures migrations can be found
+ originalDir, err := os.Getwd()
+ if err != nil {
+ t.Fatalf("Failed to get working directory: %v", err)
+ }
+
+ // Change to project root (2 levels up from internal/handlers)
+ if err := os.Chdir("../../"); err != nil {
+ t.Fatalf("Failed to change to project root: %v", err)
+ }
+
+ // Initialize store (this runs migrations)
+ db, err := store.New(tmpFile.Name())
+ if err != nil {
+ os.Chdir(originalDir)
+ os.Remove(tmpFile.Name())
+ t.Fatalf("Failed to initialize store: %v", err)
+ }
+
+ // Return to original directory
+ os.Chdir(originalDir)
+
+ // Return cleanup function
+ cleanup := func() {
+ db.Close()
+ os.Remove(tmpFile.Name())
+ }
+
+ return db, cleanup
+}
+
+// mockTodoistClient creates a mock Todoist client for testing
+type mockTodoistClient struct {
+ tasks []models.Task
+ err error
+}
+
+func (m *mockTodoistClient) GetTasks(ctx context.Context) ([]models.Task, error) {
+ if m.err != nil {
+ return nil, m.err
+ }
+ return m.tasks, nil
+}
+
+func (m *mockTodoistClient) GetProjects(ctx context.Context) (map[string]string, error) {
+ return map[string]string{}, nil
+}
+
+func (m *mockTodoistClient) CreateTask(ctx context.Context, content, projectID string, dueDate *time.Time, priority int) (*models.Task, error) {
+ return nil, nil
+}
+
+func (m *mockTodoistClient) CompleteTask(ctx context.Context, taskID string) error {
+ return nil
+}
+
+// mockTrelloClient creates a mock Trello client for testing
+type mockTrelloClient struct {
+ boards []models.Board
+ err error
+}
+
+func (m *mockTrelloClient) GetBoardsWithCards(ctx context.Context) ([]models.Board, error) {
+ if m.err != nil {
+ return nil, m.err
+ }
+ return m.boards, nil
+}
+
+func (m *mockTrelloClient) GetBoards(ctx context.Context) ([]models.Board, error) {
+ if m.err != nil {
+ return nil, m.err
+ }
+ return m.boards, nil
+}
+
+func (m *mockTrelloClient) GetCards(ctx context.Context, boardID string) ([]models.Card, error) {
+ return []models.Card{}, nil
+}
+
+func (m *mockTrelloClient) CreateCard(ctx context.Context, listID, name, description string, dueDate *time.Time) (*models.Card, error) {
+ return nil, nil
+}
+
+func (m *mockTrelloClient) UpdateCard(ctx context.Context, cardID string, updates map[string]interface{}) error {
+ return nil
+}
+
+// TestHandleGetTasks tests the HandleGetTasks handler
+func TestHandleGetTasks(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+
+ // Create test tasks
+ testTasks := []models.Task{
+ {
+ ID: "1",
+ Content: "Test task 1",
+ Description: "Description 1",
+ ProjectID: "proj1",
+ ProjectName: "Project 1",
+ Priority: 1,
+ Completed: false,
+ Labels: []string{"label1"},
+ URL: "https://todoist.com/task/1",
+ CreatedAt: time.Now(),
+ },
+ {
+ ID: "2",
+ Content: "Test task 2",
+ Description: "Description 2",
+ ProjectID: "proj2",
+ ProjectName: "Project 2",
+ Priority: 2,
+ Completed: true,
+ Labels: []string{"label2"},
+ URL: "https://todoist.com/task/2",
+ CreatedAt: time.Now(),
+ },
+ }
+
+ // Save tasks to database
+ if err := db.SaveTasks(testTasks); err != nil {
+ t.Fatalf("Failed to save test tasks: %v", err)
+ }
+
+ // Create handler with mock client
+ cfg := &config.Config{
+ CacheTTLMinutes: 5,
+ }
+ mockTodoist := &mockTodoistClient{}
+ h := &Handler{
+ store: db,
+ todoistClient: mockTodoist,
+ config: cfg,
+ }
+
+ // Create test request
+ req := httptest.NewRequest("GET", "/api/tasks", nil)
+ w := httptest.NewRecorder()
+
+ // Execute handler
+ h.HandleGetTasks(w, req)
+
+ // Check response
+ if w.Code != http.StatusOK {
+ t.Errorf("Expected status 200, got %d", w.Code)
+ }
+
+ // Parse response
+ var tasks []models.Task
+ if err := json.NewDecoder(w.Body).Decode(&tasks); err != nil {
+ t.Fatalf("Failed to decode response: %v", err)
+ }
+
+ // Verify tasks
+ if len(tasks) != 2 {
+ t.Errorf("Expected 2 tasks, got %d", len(tasks))
+ }
+}
+
+// TestHandleGetBoards tests the HandleGetBoards handler
+func TestHandleGetBoards(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+
+ // Create test boards
+ testBoards := []models.Board{
+ {
+ ID: "board1",
+ Name: "Test Board 1",
+ Cards: []models.Card{
+ {
+ ID: "card1",
+ Name: "Card 1",
+ ListID: "list1",
+ ListName: "To Do",
+ URL: "https://trello.com/c/card1",
+ },
+ },
+ },
+ {
+ ID: "board2",
+ Name: "Test Board 2",
+ Cards: []models.Card{
+ {
+ ID: "card2",
+ Name: "Card 2",
+ ListID: "list2",
+ ListName: "Done",
+ URL: "https://trello.com/c/card2",
+ },
+ },
+ },
+ }
+
+ // Save boards to database
+ if err := db.SaveBoards(testBoards); err != nil {
+ t.Fatalf("Failed to save test boards: %v", err)
+ }
+
+ // Create handler
+ cfg := &config.Config{
+ CacheTTLMinutes: 5,
+ }
+ h := &Handler{
+ store: db,
+ trelloClient: &mockTrelloClient{boards: testBoards},
+ config: cfg,
+ }
+
+ // Create test request
+ req := httptest.NewRequest("GET", "/api/boards", nil)
+ w := httptest.NewRecorder()
+
+ // Execute handler
+ h.HandleGetBoards(w, req)
+
+ // Check response
+ if w.Code != http.StatusOK {
+ t.Errorf("Expected status 200, got %d", w.Code)
+ }
+
+ // Parse response
+ var boards []models.Board
+ if err := json.NewDecoder(w.Body).Decode(&boards); err != nil {
+ t.Fatalf("Failed to decode response: %v", err)
+ }
+
+ // Verify boards
+ if len(boards) != 2 {
+ t.Errorf("Expected 2 boards, got %d", len(boards))
+ }
+
+ // Just verify we got boards back - cards may or may not be populated
+ // depending on how the store handles the board->card relationship
+}
+
+// TestHandleRefresh tests the HandleRefresh handler
+func TestHandleRefresh(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+
+ // Create mock clients
+ mockTodoist := &mockTodoistClient{
+ tasks: []models.Task{
+ {
+ ID: "1",
+ Content: "Test task",
+ },
+ },
+ }
+
+ mockTrello := &mockTrelloClient{
+ boards: []models.Board{
+ {
+ ID: "board1",
+ Name: "Test Board",
+ },
+ },
+ }
+
+ // Create handler
+ cfg := &config.Config{
+ CacheTTLMinutes: 5,
+ }
+ h := &Handler{
+ store: db,
+ todoistClient: mockTodoist,
+ trelloClient: mockTrello,
+ config: cfg,
+ }
+
+ // Create test request
+ req := httptest.NewRequest("POST", "/api/refresh", nil)
+ w := httptest.NewRecorder()
+
+ // Execute handler
+ h.HandleRefresh(w, req)
+
+ // Check response
+ if w.Code != http.StatusOK {
+ t.Errorf("Expected status 200, got %d", w.Code)
+ }
+
+ // Parse response - check that it returns aggregated data
+ var response models.DashboardData
+ if err := json.NewDecoder(w.Body).Decode(&response); err != nil {
+ // If it's not DashboardData, try a success response
+ t.Log("Response is not DashboardData format, checking alternative format")
+ }
+
+ // Just verify we got a 200 OK - the actual response format can vary
+ // The important thing is the handler doesn't error
+}
+
+// TestHandleGetNotes tests the HandleGetNotes handler
+func TestHandleGetNotes(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+
+ // Test with nil client should return empty array
+ cfg := &config.Config{
+ CacheTTLMinutes: 5,
+ }
+ h := &Handler{
+ store: db,
+ obsidianClient: nil,
+ config: cfg,
+ }
+
+ req := httptest.NewRequest("GET", "/api/notes", nil)
+ w := httptest.NewRecorder()
+
+ h.HandleGetNotes(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Errorf("Expected status 200, got %d", w.Code)
+ }
+
+ var notes []models.Note
+ if err := json.NewDecoder(w.Body).Decode(&notes); err != nil {
+ t.Fatalf("Failed to decode response: %v", err)
+ }
+
+ // Handler returns empty array when client is nil
+ if len(notes) != 0 {
+ t.Errorf("Expected 0 notes when client is nil, got %d", len(notes))
+ }
+}
+
+// TestHandleGetMeals tests the HandleGetMeals handler
+func TestHandleGetMeals(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+
+ // Test with nil client should return empty array
+ cfg := &config.Config{
+ CacheTTLMinutes: 5,
+ }
+ h := &Handler{
+ store: db,
+ planToEatClient: nil,
+ config: cfg,
+ }
+
+ req := httptest.NewRequest("GET", "/api/meals", nil)
+ w := httptest.NewRecorder()
+
+ h.HandleGetMeals(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Errorf("Expected status 200, got %d", w.Code)
+ }
+
+ var meals []models.Meal
+ if err := json.NewDecoder(w.Body).Decode(&meals); err != nil {
+ t.Fatalf("Failed to decode response: %v", err)
+ }
+
+ // Handler returns empty array when client is nil
+ if len(meals) != 0 {
+ t.Errorf("Expected 0 meals when client is nil, got %d", len(meals))
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2026-03-28 15:01:47 +0000