Add PDF reports, file uploads, admin auth, and comprehensive tests

Features:
- PDF service for generating task reports with ReportLab-style formatting
- Storage service for file uploads (local and S3-compatible)
- Admin authentication middleware with JWT support
- Admin user model and repository

Infrastructure:
- Updated Docker configuration for admin panel builds
- Email service enhancements for task notifications
- Updated router with admin and file upload routes
- Environment configuration updates

Tests:
- Unit tests for handlers (auth, residence, task)
- Unit tests for models (user, residence, task)
- Unit tests for repositories (user, residence, task)
- Unit tests for services (residence, task)
- Integration test setup
- Test utilities for mocking database and services

Database:
- Admin user seed data
- Updated test data seeds

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

internal/handlers/task_handler.go

@@ -2,10 +2,14 @@ package handlers
 
 import (
 	"errors"
+	"mime/multipart"
 	"net/http"
 	"strconv"
+	"strings"
+	"time"
 
 	"github.com/gin-gonic/gin"
+	"github.com/shopspring/decimal"
 
 	"github.com/treytartt/mycrib-api/internal/dto/requests"
 	"github.com/treytartt/mycrib-api/internal/middleware"
@@ -15,12 +19,16 @@ import (
 
 // TaskHandler handles task-related HTTP requests
 type TaskHandler struct {
-	taskService *services.TaskService
+	taskService    *services.TaskService
+	storageService *services.StorageService
 }
 
 // NewTaskHandler creates a new task handler
-func NewTaskHandler(taskService *services.TaskService) *TaskHandler {
-	return &TaskHandler{taskService: taskService}
+func NewTaskHandler(taskService *services.TaskService, storageService *services.StorageService) *TaskHandler {
+	return &TaskHandler{
+		taskService:    taskService,
+		storageService: storageService,
+	}
 }
 
 // ListTasks handles GET /api/tasks/
@@ -288,6 +296,30 @@ func (h *TaskHandler) UnarchiveTask(c *gin.Context) {
 
 // === Task Completions ===
 
+// GetTaskCompletions handles GET /api/tasks/:id/completions/
+func (h *TaskHandler) GetTaskCompletions(c *gin.Context) {
+	user := c.MustGet(middleware.AuthUserKey).(*models.User)
+	taskID, err := strconv.ParseUint(c.Param("id"), 10, 32)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid task ID"})
+		return
+	}
+
+	response, err := h.taskService.GetCompletionsByTask(uint(taskID), user.ID)
+	if err != nil {
+		switch {
+		case errors.Is(err, services.ErrTaskNotFound):
+			c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		case errors.Is(err, services.ErrTaskAccessDenied):
+			c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
+		default:
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		}
+		return
+	}
+	c.JSON(http.StatusOK, response)
+}
+
 // ListCompletions handles GET /api/task-completions/
 func (h *TaskHandler) ListCompletions(c *gin.Context) {
 	user := c.MustGet(middleware.AuthUserKey).(*models.User)
@@ -324,12 +356,78 @@ func (h *TaskHandler) GetCompletion(c *gin.Context) {
 }
 
 // CreateCompletion handles POST /api/task-completions/
+// Supports both JSON and multipart form data (for image uploads)
 func (h *TaskHandler) CreateCompletion(c *gin.Context) {
 	user := c.MustGet(middleware.AuthUserKey).(*models.User)
 	var req requests.CreateTaskCompletionRequest
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
+
+	contentType := c.GetHeader("Content-Type")
+
+	// Check if this is a multipart form request (image upload)
+	if strings.HasPrefix(contentType, "multipart/form-data") {
+		// Parse multipart form
+		if err := c.Request.ParseMultipartForm(32 << 20); err != nil { // 32MB max
+			c.JSON(http.StatusBadRequest, gin.H{"error": "failed to parse multipart form: " + err.Error()})
+			return
+		}
+
+		// Parse task_id (required)
+		taskIDStr := c.PostForm("task_id")
+		if taskIDStr == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "task_id is required"})
+			return
+		}
+		taskID, err := strconv.ParseUint(taskIDStr, 10, 32)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "invalid task_id"})
+			return
+		}
+		req.TaskID = uint(taskID)
+
+		// Parse notes (optional)
+		req.Notes = c.PostForm("notes")
+
+		// Parse actual_cost (optional)
+		if costStr := c.PostForm("actual_cost"); costStr != "" {
+			cost, err := decimal.NewFromString(costStr)
+			if err == nil {
+				req.ActualCost = &cost
+			}
+		}
+
+		// Parse completed_at (optional)
+		if completedAtStr := c.PostForm("completed_at"); completedAtStr != "" {
+			if t, err := time.Parse(time.RFC3339, completedAtStr); err == nil {
+				req.CompletedAt = &t
+			}
+		}
+
+		// Handle image upload (look for "images" or "image" or "photo" field)
+		var imageFile interface{}
+		for _, fieldName := range []string{"images", "image", "photo"} {
+			if file, err := c.FormFile(fieldName); err == nil {
+				imageFile = file
+				break
+			}
+		}
+
+		if imageFile != nil {
+			file := imageFile.(*multipart.FileHeader)
+			if h.storageService != nil {
+				result, err := h.storageService.Upload(file, "completions")
+				if err != nil {
+					c.JSON(http.StatusBadRequest, gin.H{"error": "failed to upload image: " + err.Error()})
+					return
+				}
+				req.PhotoURL = result.URL
+			}
+		}
+	} else {
+		// Standard JSON request
+		if err := c.ShouldBindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
 	}
 
 	response, err := h.taskService.CreateCompletion(&req, user.ID)