Complete tasks 4.1-4.2: Page management service and HTTP endpoints

- Implemented PageService with full CRUD operations - Added GetPages, CreatePage, UpdatePage, DeletePage, ReorderPages methods - Cascade deletion of widgets when page is deleted - Prevention of last page deletion - Created page HTTP endpoints (GET, POST, PUT, DELETE, reorder) - HTMX-friendly HTML fragment responses - Comprehensive unit tests for service and handlers - Updated dashboard to use PageService and create default pages
2026-02-19 00:08:05 -05:00
parent 9f07b0c6f9
commit 299ac03939
16 changed files with 1572 additions and 31 deletions
--- a/internal/handlers/dashboard_handler.go
+++ b/internal/handlers/dashboard_handler.go
@@ -7,21 +7,26 @@ import (
 	"path/filepath"

 	"custom-start-page/internal/middleware"
+	"custom-start-page/internal/models"
+	"custom-start-page/internal/services"
 )

 // DashboardHandler handles dashboard-related HTTP requests
 type DashboardHandler struct {
-	templates *template.Template
+	pageService services.PageServiceInterface
+	templates   *template.Template
 }

 // NewDashboardHandler creates a new dashboard handler
-func NewDashboardHandler() *DashboardHandler {
+func NewDashboardHandler(pageService services.PageServiceInterface) *DashboardHandler {
 	// Parse templates
 	templates := template.Must(template.ParseGlob(filepath.Join("templates", "*.html")))
 	template.Must(templates.ParseGlob(filepath.Join("templates", "layouts", "*.html")))
+	template.Must(templates.ParseGlob(filepath.Join("templates", "partials", "*.html")))
 	
 	return &DashboardHandler{
-		templates: templates,
+		pageService: pageService,
+		templates:   templates,
 	}
 }

@@ -35,14 +40,23 @@ func (h *DashboardHandler) HandleDashboard(w http.ResponseWriter, r *http.Reques
 		return
 	}

-	// TODO: Fetch user's pages from database
-	// For now, we'll use mock data
-	pages := []map[string]interface{}{
-		{
-			"ID":     "default-page",
-			"Name":   "Home",
-			"Active": true,
-		},
+	// Fetch user's pages from database
+	pages, err := h.pageService.GetPages(r.Context(), userID)
+	if err != nil {
+		log.Printf("Failed to get pages: %v", err)
+		http.Error(w, "Failed to load pages", http.StatusInternalServerError)
+		return
+	}
+
+	// If user has no pages, create default "Home" page
+	if len(pages) == 0 {
+		defaultPage, err := h.pageService.CreateDefaultPage(r.Context(), userID)
+		if err != nil {
+			log.Printf("Failed to create default page: %v", err)
+			http.Error(w, "Failed to create default page", http.StatusInternalServerError)
+			return
+		}
+		pages = []*models.Page{defaultPage}
 	}

 	// Render dashboard template
--- a/internal/handlers/dashboard_handler_test.go
+++ b/internal/handlers/dashboard_handler_test.go
@@ -6,10 +6,67 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"testing"
+	"time"

 	"custom-start-page/internal/middleware"
+	"custom-start-page/internal/models"
 )

+// mockPageService is a mock implementation of PageService for testing
+type mockPageService struct {
+	pages []*models.Page
+	err   error
+}
+
+func (m *mockPageService) GetPages(ctx context.Context, userID string) ([]*models.Page, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	return m.pages, nil
+}
+
+func (m *mockPageService) CreatePage(ctx context.Context, userID, name string) (*models.Page, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	page := &models.Page{
+		ID:        "new-page-id",
+		UserID:    userID,
+		Name:      name,
+		Order:     len(m.pages),
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+	m.pages = append(m.pages, page)
+	return page, nil
+}
+
+func (m *mockPageService) CreateDefaultPage(ctx context.Context, userID string) (*models.Page, error) {
+	return m.CreatePage(ctx, userID, "Home")
+}
+
+func (m *mockPageService) UpdatePage(ctx context.Context, userID, pageID, name string) (*models.Page, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	for _, page := range m.pages {
+		if page.ID == pageID && page.UserID == userID {
+			page.Name = name
+			page.UpdatedAt = time.Now()
+			return page, nil
+		}
+	}
+	return nil, nil
+}
+
+func (m *mockPageService) DeletePage(ctx context.Context, userID, pageID string) error {
+	return m.err
+}
+
+func (m *mockPageService) ReorderPages(ctx context.Context, userID string, pageOrder []string) error {
+	return m.err
+}
+
 // createMockDashboardTemplate creates a simple mock template for testing
 func createMockDashboardTemplate() *template.Template {
 	tmpl := template.New("dashboard.html")
@@ -21,8 +78,21 @@ func createMockDashboardTemplate() *template.Template {
 func TestHandleDashboard_WithAuthenticatedUser(t *testing.T) {
 	// Setup
 	mockTemplate := createMockDashboardTemplate()
+	mockPages := []*models.Page{
+		{
+			ID:        "page-1",
+			UserID:    "test-user-123",
+			Name:      "Home",
+			Order:     0,
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+		},
+	}
+	mockService := &mockPageService{pages: mockPages}
+	
 	handler := &DashboardHandler{
-		templates: mockTemplate,
+		pageService: mockService,
+		templates:   mockTemplate,
 	}

 	// Create request with user ID in context
@@ -50,8 +120,11 @@ func TestHandleDashboard_WithAuthenticatedUser(t *testing.T) {
 func TestHandleDashboard_WithoutUserID(t *testing.T) {
 	// Setup
 	mockTemplate := createMockDashboardTemplate()
+	mockService := &mockPageService{}
+	
 	handler := &DashboardHandler{
-		templates: mockTemplate,
+		pageService: mockService,
+		templates:   mockTemplate,
 	}

 	// Create request without user ID in context
--- a/internal/handlers/page_handler.go
+++ b/internal/handlers/page_handler.go
@@ -0,0 +1,275 @@
+package handlers
+
+import (
+	"encoding/json"
+	"html/template"
+	"log"
+	"net/http"
+	"path/filepath"
+
+	"custom-start-page/internal/middleware"
+	"custom-start-page/internal/services"
+)
+
+// PageHandler handles page-related HTTP requests
+type PageHandler struct {
+	pageService services.PageServiceInterface
+	templates   *template.Template
+}
+
+// NewPageHandler creates a new page handler
+func NewPageHandler(pageService services.PageServiceInterface) *PageHandler {
+	// Parse templates
+	templates := template.Must(template.ParseGlob(filepath.Join("templates", "*.html")))
+	template.Must(templates.ParseGlob(filepath.Join("templates", "layouts", "*.html")))
+	template.Must(templates.ParseGlob(filepath.Join("templates", "partials", "*.html")))
+
+	return &PageHandler{
+		pageService: pageService,
+		templates:   templates,
+	}
+}
+
+// HandleGetPage returns the widget grid HTML fragment for a specific page
+// GET /pages/:id
+func (h *PageHandler) HandleGetPage(w http.ResponseWriter, r *http.Request) {
+	// Get user ID from context
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	// Get page ID from URL path
+	pageID := r.PathValue("id")
+	if pageID == "" {
+		http.Error(w, "Page ID is required", http.StatusBadRequest)
+		return
+	}
+
+	// TODO: Fetch widgets for this page
+	// For now, return empty widget grid
+	data := map[string]interface{}{
+		"PageID":  pageID,
+		"UserID":  userID,
+		"Widgets": []interface{}{},
+	}
+
+	if err := h.templates.ExecuteTemplate(w, "widget-grid.html", data); err != nil {
+		log.Printf("Failed to render widget grid template: %v", err)
+		http.Error(w, "Internal server error", http.StatusInternalServerError)
+	}
+}
+
+// HandleCreatePage creates a new page and returns updated page tabs HTML
+// POST /pages
+func (h *PageHandler) HandleCreatePage(w http.ResponseWriter, r *http.Request) {
+	// Get user ID from context
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	// Parse form data
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
+		return
+	}
+
+	pageName := r.FormValue("name")
+	if pageName == "" {
+		http.Error(w, "Page name is required", http.StatusBadRequest)
+		return
+	}
+
+	// Validate page name length
+	if len(pageName) < 1 || len(pageName) > 50 {
+		http.Error(w, "Page name must be between 1 and 50 characters", http.StatusBadRequest)
+		return
+	}
+
+	// Create the page
+	_, err := h.pageService.CreatePage(r.Context(), userID, pageName)
+	if err != nil {
+		log.Printf("Failed to create page: %v", err)
+		http.Error(w, "Failed to create page", http.StatusInternalServerError)
+		return
+	}
+
+	// Get all pages to render updated tabs
+	pages, err := h.pageService.GetPages(r.Context(), userID)
+	if err != nil {
+		log.Printf("Failed to get pages: %v", err)
+		http.Error(w, "Failed to get pages", http.StatusInternalServerError)
+		return
+	}
+
+	// Render page tabs partial
+	data := map[string]interface{}{
+		"Pages": pages,
+	}
+
+	if err := h.templates.ExecuteTemplate(w, "page-tabs.html", data); err != nil {
+		log.Printf("Failed to render page tabs template: %v", err)
+		http.Error(w, "Internal server error", http.StatusInternalServerError)
+	}
+}
+
+// HandleUpdatePage updates a page and returns updated page tab HTML
+// PUT /pages/:id
+func (h *PageHandler) HandleUpdatePage(w http.ResponseWriter, r *http.Request) {
+	// Get user ID from context
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	// Get page ID from URL path
+	pageID := r.PathValue("id")
+	if pageID == "" {
+		http.Error(w, "Page ID is required", http.StatusBadRequest)
+		return
+	}
+
+	// Parse form data
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
+		return
+	}
+
+	pageName := r.FormValue("name")
+	if pageName == "" {
+		http.Error(w, "Page name is required", http.StatusBadRequest)
+		return
+	}
+
+	// Validate page name length
+	if len(pageName) < 1 || len(pageName) > 50 {
+		http.Error(w, "Page name must be between 1 and 50 characters", http.StatusBadRequest)
+		return
+	}
+
+	// Update the page
+	page, err := h.pageService.UpdatePage(r.Context(), userID, pageID, pageName)
+	if err != nil {
+		log.Printf("Failed to update page: %v", err)
+		http.Error(w, "Failed to update page", http.StatusInternalServerError)
+		return
+	}
+
+	// Render single page tab partial
+	data := map[string]interface{}{
+		"Page": page,
+	}
+
+	if err := h.templates.ExecuteTemplate(w, "page-tab.html", data); err != nil {
+		log.Printf("Failed to render page tab template: %v", err)
+		http.Error(w, "Internal server error", http.StatusInternalServerError)
+	}
+}
+
+// HandleDeletePage deletes a page and returns updated page tabs HTML
+// DELETE /pages/:id
+func (h *PageHandler) HandleDeletePage(w http.ResponseWriter, r *http.Request) {
+	// Get user ID from context
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	// Get page ID from URL path
+	pageID := r.PathValue("id")
+	if pageID == "" {
+		http.Error(w, "Page ID is required", http.StatusBadRequest)
+		return
+	}
+
+	// Delete the page
+	err := h.pageService.DeletePage(r.Context(), userID, pageID)
+	if err != nil {
+		if err.Error() == "cannot delete the last page" {
+			http.Error(w, "Cannot delete the last page. You must have at least one page.", http.StatusBadRequest)
+			return
+		}
+		log.Printf("Failed to delete page: %v", err)
+		http.Error(w, "Failed to delete page", http.StatusInternalServerError)
+		return
+	}
+
+	// Get all pages to render updated tabs
+	pages, err := h.pageService.GetPages(r.Context(), userID)
+	if err != nil {
+		log.Printf("Failed to get pages: %v", err)
+		http.Error(w, "Failed to get pages", http.StatusInternalServerError)
+		return
+	}
+
+	// Render page tabs partial
+	data := map[string]interface{}{
+		"Pages": pages,
+	}
+
+	if err := h.templates.ExecuteTemplate(w, "page-tabs.html", data); err != nil {
+		log.Printf("Failed to render page tabs template: %v", err)
+		http.Error(w, "Internal server error", http.StatusInternalServerError)
+	}
+}
+
+// HandleReorderPages reorders pages and returns updated page tabs HTML
+// POST /pages/reorder
+func (h *PageHandler) HandleReorderPages(w http.ResponseWriter, r *http.Request) {
+	// Get user ID from context
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	// Parse form data
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
+		return
+	}
+
+	// Get page order from form
+	orderJSON := r.FormValue("order")
+	if orderJSON == "" {
+		http.Error(w, "Page order is required", http.StatusBadRequest)
+		return
+	}
+
+	var pageOrder []string
+	if err := json.Unmarshal([]byte(orderJSON), &pageOrder); err != nil {
+		http.Error(w, "Invalid page order format", http.StatusBadRequest)
+		return
+	}
+
+	// Reorder pages
+	err := h.pageService.ReorderPages(r.Context(), userID, pageOrder)
+	if err != nil {
+		log.Printf("Failed to reorder pages: %v", err)
+		http.Error(w, "Failed to reorder pages", http.StatusInternalServerError)
+		return
+	}
+
+	// Get all pages to render updated tabs
+	pages, err := h.pageService.GetPages(r.Context(), userID)
+	if err != nil {
+		log.Printf("Failed to get pages: %v", err)
+		http.Error(w, "Failed to get pages", http.StatusInternalServerError)
+		return
+	}
+
+	// Render page tabs partial
+	data := map[string]interface{}{
+		"Pages": pages,
+	}
+
+	if err := h.templates.ExecuteTemplate(w, "page-tabs.html", data); err != nil {
+		log.Printf("Failed to render page tabs template: %v", err)
+		http.Error(w, "Internal server error", http.StatusInternalServerError)
+	}
+}
--- a/internal/handlers/page_handler_test.go
+++ b/internal/handlers/page_handler_test.go
@@ -0,0 +1,251 @@
+package handlers
+
+import (
+	"context"
+	"html/template"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+
+	"custom-start-page/internal/middleware"
+)
+
+// createMockPageTemplate creates a simple mock template for testing
+func createMockPageTemplate() *template.Template {
+	tmpl := template.New("base")
+	
+	// Define page-tabs template
+	template.Must(tmpl.New("page-tabs.html").Parse(`{{define "page-tabs.html"}}{{range .Pages}}<button>{{.Name}}</button>{{end}}{{end}}`))
+	
+	// Define widget-grid template
+	template.Must(tmpl.New("widget-grid.html").Parse(`{{define "widget-grid.html"}}<div>Widgets for page {{.PageID}}</div>{{end}}`))
+	
+	// Define page-tab template
+	template.Must(tmpl.New("page-tab.html").Parse(`{{define "page-tab.html"}}<button>{{.Page.Name}}</button>{{end}}`))
+	
+	return tmpl
+}
+
+// TestHandleGetPage tests retrieving a page's widget grid
+func TestHandleGetPage(t *testing.T) {
+	// Setup
+	mockTemplate := createMockPageTemplate()
+	mockService := &mockPageService{}
+	
+	handler := &PageHandler{
+		pageService: mockService,
+		templates:   mockTemplate,
+	}
+
+	// Create request with user ID in context
+	req := httptest.NewRequest(http.MethodGet, "/pages/page-1", nil)
+	req.SetPathValue("id", "page-1")
+	ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	// Execute
+	handler.HandleGetPage(w, req)
+
+	// Assert
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", w.Code)
+	}
+
+	body := w.Body.String()
+	if !strings.Contains(body, "page-1") {
+		t.Errorf("Expected response to contain page ID, got: %s", body)
+	}
+}
+
+// TestHandleCreatePage tests creating a new page
+func TestHandleCreatePage(t *testing.T) {
+	// Setup
+	mockTemplate := createMockPageTemplate()
+	mockService := &mockPageService{}
+	
+	handler := &PageHandler{
+		pageService: mockService,
+		templates:   mockTemplate,
+	}
+
+	// Create form data
+	form := url.Values{}
+	form.Add("name", "New Page")
+	
+	// Create request with user ID in context
+	req := httptest.NewRequest(http.MethodPost, "/pages", strings.NewReader(form.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	// Execute
+	handler.HandleCreatePage(w, req)
+
+	// Assert
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", w.Code)
+	}
+
+	// Verify page was created
+	if len(mockService.pages) != 1 {
+		t.Errorf("Expected 1 page to be created, got %d", len(mockService.pages))
+	}
+	
+	if mockService.pages[0].Name != "New Page" {
+		t.Errorf("Expected page name 'New Page', got '%s'", mockService.pages[0].Name)
+	}
+}
+
+// TestHandleCreatePage_InvalidName tests creating a page with invalid name
+func TestHandleCreatePage_InvalidName(t *testing.T) {
+	// Setup
+	mockTemplate := createMockPageTemplate()
+	mockService := &mockPageService{}
+	
+	handler := &PageHandler{
+		pageService: mockService,
+		templates:   mockTemplate,
+	}
+
+	// Test empty name
+	form := url.Values{}
+	form.Add("name", "")
+	
+	req := httptest.NewRequest(http.MethodPost, "/pages", strings.NewReader(form.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	handler.HandleCreatePage(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("Expected status 400 for empty name, got %d", w.Code)
+	}
+
+	// Test name too long
+	form = url.Values{}
+	form.Add("name", strings.Repeat("a", 51))
+	
+	req = httptest.NewRequest(http.MethodPost, "/pages", strings.NewReader(form.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	ctx = context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w = httptest.NewRecorder()
+
+	handler.HandleCreatePage(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("Expected status 400 for name too long, got %d", w.Code)
+	}
+}
+
+// TestHandleUpdatePage tests updating a page
+func TestHandleUpdatePage(t *testing.T) {
+	// Setup
+	mockTemplate := createMockPageTemplate()
+	mockService := &mockPageService{}
+	
+	// Create initial page
+	_, _ = mockService.CreatePage(context.Background(), "test-user-123", "Old Name")
+	
+	handler := &PageHandler{
+		pageService: mockService,
+		templates:   mockTemplate,
+	}
+
+	// Create form data
+	form := url.Values{}
+	form.Add("name", "Updated Name")
+	
+	// Create request with user ID in context
+	req := httptest.NewRequest(http.MethodPut, "/pages/new-page-id", strings.NewReader(form.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.SetPathValue("id", "new-page-id")
+	ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	// Execute
+	handler.HandleUpdatePage(w, req)
+
+	// Assert
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", w.Code)
+	}
+
+	// Verify page was updated
+	if mockService.pages[0].Name != "Updated Name" {
+		t.Errorf("Expected page name 'Updated Name', got '%s'", mockService.pages[0].Name)
+	}
+}
+
+// TestHandleDeletePage tests deleting a page
+func TestHandleDeletePage(t *testing.T) {
+	// Setup
+	mockTemplate := createMockPageTemplate()
+	mockService := &mockPageService{}
+	
+	// Create two pages
+	_, _ = mockService.CreatePage(context.Background(), "test-user-123", "Page 1")
+	_, _ = mockService.CreatePage(context.Background(), "test-user-123", "Page 2")
+	
+	handler := &PageHandler{
+		pageService: mockService,
+		templates:   mockTemplate,
+	}
+
+	// Create request with user ID in context
+	req := httptest.NewRequest(http.MethodDelete, "/pages/page-1", nil)
+	req.SetPathValue("id", "page-1")
+	ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	// Execute
+	handler.HandleDeletePage(w, req)
+
+	// Assert
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", w.Code)
+	}
+}
+
+// TestHandleReorderPages tests reordering pages
+func TestHandleReorderPages(t *testing.T) {
+	// Setup
+	mockTemplate := createMockPageTemplate()
+	mockService := &mockPageService{}
+	
+	// Create pages
+	_, _ = mockService.CreatePage(context.Background(), "test-user-123", "Page 1")
+	_, _ = mockService.CreatePage(context.Background(), "test-user-123", "Page 2")
+	
+	handler := &PageHandler{
+		pageService: mockService,
+		templates:   mockTemplate,
+	}
+
+	// Create form data with JSON array
+	form := url.Values{}
+	form.Add("order", `["page-2", "page-1"]`)
+	
+	// Create request with user ID in context
+	req := httptest.NewRequest(http.MethodPost, "/pages/reorder", strings.NewReader(form.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	// Execute
+	handler.HandleReorderPages(w, req)
+
+	// Assert
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", w.Code)
+	}
+}