cclohmar
5f5f2be75b
- Added Edit button on open event cards in dashboard
- EditEvent handler returns dashboard.html with pre-filled form
- UpdateEvent handler (PUT /events/{id}) saves new currency + rate
- UpdateEvent in db.go updates base_currency and exchange_rate
- Form auto-switches between create (POST) and edit (PUT) mode
- Reuses the same conversion sample pattern as event creation
329 lines
12 KiB
Go
329 lines
12 KiB
Go
// Package handlers provides HTTP request handlers for ExpenseFlow.
|
|
//
|
|
// This file implements event management endpoints including dashboard
|
|
// listing, event creation, reopening, and expense viewing.
|
|
package handlers
|
|
|
|
import (
|
|
"database/sql"
|
|
"log"
|
|
"net/http"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/cclohmar/ReceiptNext/internal/database"
|
|
"github.com/cclohmar/ReceiptNext/internal/utils"
|
|
"github.com/go-chi/chi/v5"
|
|
)
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// EventHandler
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// EventHandler groups HTTP handlers related to event management.
|
|
// It depends on a shared *sql.DB handle for database operations.
|
|
type EventHandler struct {
|
|
DB *sql.DB
|
|
}
|
|
|
|
// NewEventHandler creates a new EventHandler with the given database handle.
|
|
func NewEventHandler(db *sql.DB) *EventHandler {
|
|
return &EventHandler{DB: db}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GET /dashboard — Dashboard
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Dashboard renders the main dashboard page showing all events belonging
|
|
// to the authenticated user, along with the new event creation form.
|
|
func (h *EventHandler) Dashboard(w http.ResponseWriter, r *http.Request) {
|
|
userID := getUserID(r)
|
|
if userID == "" {
|
|
log.Printf("ERROR [%s] handlers: Dashboard: missing user ID", time.Now().Format(time.RFC3339))
|
|
http.Error(w, "Unauthorized", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
|
|
events, err := database.GetEventsByUser(h.DB, userID)
|
|
if err != nil {
|
|
log.Printf("ERROR [%s] handlers: Dashboard: GetEventsByUser: %v",
|
|
time.Now().Format(time.RFC3339), err)
|
|
http.Error(w, "Failed to load events", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
tmpl := getTemplate("dashboard.html")
|
|
|
|
data := map[string]interface{}{
|
|
"Events": events,
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
if err := tmpl.Execute(w, data); err != nil {
|
|
log.Printf("ERROR [%s] handlers: Dashboard: execute template: %v",
|
|
time.Now().Format(time.RFC3339), err)
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// POST /events — CreateEvent
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// CreateEvent handles the creation of a new event for the authenticated user.
|
|
// It reads the event name from the form, generates a UUID, persists the
|
|
// event, and redirects to the dashboard via HX-Redirect.
|
|
func (h *EventHandler) CreateEvent(w http.ResponseWriter, r *http.Request) {
|
|
userID := getUserID(r)
|
|
if userID == "" {
|
|
log.Printf("ERROR [%s] handlers: CreateEvent: missing user ID", time.Now().Format(time.RFC3339))
|
|
http.Error(w, "Unauthorized", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
|
|
name := r.FormValue("name")
|
|
if name == "" {
|
|
log.Printf("ERROR [%s] handlers: CreateEvent: missing event name", time.Now().Format(time.RFC3339))
|
|
http.Error(w, "Event name is required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
baseCurrency := r.FormValue("base_currency")
|
|
if baseCurrency == "" {
|
|
baseCurrency = "USD"
|
|
}
|
|
|
|
// Compute exchange rate from user-provided sample:
|
|
// e.g. receipt=1000 KES, claimed=7.73 USD → rate = 7.73 / 1000 = 0.00773
|
|
exchangeRate := 1.0
|
|
sampleReceipt := r.FormValue("sample_receipt_amount")
|
|
sampleClaim := r.FormValue("sample_claim_amount")
|
|
if sampleReceipt != "" && sampleClaim != "" {
|
|
sampleReceiptVal, err1 := strconv.ParseFloat(sampleReceipt, 64)
|
|
sampleClaimVal, err2 := strconv.ParseFloat(sampleClaim, 64)
|
|
if err1 == nil && err2 == nil && sampleReceiptVal > 0 && sampleClaimVal > 0 {
|
|
exchangeRate = sampleClaimVal / sampleReceiptVal
|
|
log.Printf("INFO [%s] handlers: CreateEvent: computed rate %.6f from sample %s %s → %.2f %s",
|
|
time.Now().Format(time.RFC3339), exchangeRate,
|
|
r.FormValue("sample_receipt_currency"), sampleReceipt, sampleClaimVal, baseCurrency)
|
|
}
|
|
}
|
|
|
|
id := utils.NewUUID()
|
|
if err := database.CreateEvent(h.DB, id, userID, name, baseCurrency, exchangeRate); err != nil {
|
|
log.Printf("ERROR [%s] handlers: CreateEvent: %v",
|
|
time.Now().Format(time.RFC3339), err)
|
|
http.Error(w, "Failed to create event", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("HX-Redirect", "/dashboard")
|
|
w.WriteHeader(http.StatusOK)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// PUT /events/{id}/reopen — ReopenEvent
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// ReopenEvent sets an event's status back to "open" and returns an HTMX
|
|
// fragment replacing the event's status badge with a green "open" badge.
|
|
// It verifies that the requesting user owns the event.
|
|
func (h *EventHandler) ReopenEvent(w http.ResponseWriter, r *http.Request) {
|
|
eventID := chi.URLParam(r, "id")
|
|
if eventID == "" {
|
|
log.Printf("ERROR [%s] handlers: ReopenEvent: missing event ID",
|
|
time.Now().Format(time.RFC3339))
|
|
http.Error(w, "Missing event ID", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
userID := getUserID(r)
|
|
if userID == "" {
|
|
log.Printf("ERROR [%s] handlers: ReopenEvent: missing user ID",
|
|
time.Now().Format(time.RFC3339))
|
|
http.Error(w, "Unauthorized", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
|
|
event, err := database.GetEventByID(h.DB, eventID)
|
|
if err != nil {
|
|
log.Printf("ERROR [%s] handlers: ReopenEvent: GetEventByID(%s): %v",
|
|
time.Now().Format(time.RFC3339), eventID, err)
|
|
http.Error(w, "Failed to retrieve event", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if event == nil {
|
|
log.Printf("ERROR [%s] handlers: ReopenEvent: event %s not found",
|
|
time.Now().Format(time.RFC3339), eventID)
|
|
http.Error(w, "Event not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
if event.UserID != userID {
|
|
log.Printf("ERROR [%s] handlers: ReopenEvent: ownership mismatch for event %s",
|
|
time.Now().Format(time.RFC3339), eventID)
|
|
http.Error(w, "Forbidden", http.StatusForbidden)
|
|
return
|
|
}
|
|
|
|
if err := database.UpdateEventStatus(h.DB, eventID, "open"); err != nil {
|
|
log.Printf("ERROR [%s] handlers: ReopenEvent: UpdateEventStatus(%s): %v",
|
|
time.Now().Format(time.RFC3339), eventID, err)
|
|
http.Error(w, "Failed to reopen event", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Redirect to dashboard so the full page renders with updated status.
|
|
w.Header().Set("HX-Redirect", "/dashboard")
|
|
w.WriteHeader(http.StatusOK)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GET /events/{id}/expenses — ViewEventExpenses
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// ViewEventExpenses displays the expense collection view for a specific event.
|
|
// It verifies event ownership, sets the current_event_id cookie, and renders
|
|
// the event_expenses.html template with the event and its expense list.
|
|
func (h *EventHandler) ViewEventExpenses(w http.ResponseWriter, r *http.Request) {
|
|
eventID := chi.URLParam(r, "id")
|
|
if eventID == "" {
|
|
log.Printf("ERROR [%s] handlers: ViewEventExpenses: missing event ID",
|
|
time.Now().Format(time.RFC3339))
|
|
http.Error(w, "Missing event ID", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
userID := getUserID(r)
|
|
if userID == "" {
|
|
log.Printf("ERROR [%s] handlers: ViewEventExpenses: missing user ID",
|
|
time.Now().Format(time.RFC3339))
|
|
http.Error(w, "Unauthorized", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
|
|
event, err := database.GetEventByID(h.DB, eventID)
|
|
if err != nil {
|
|
log.Printf("ERROR [%s] handlers: ViewEventExpenses: GetEventByID(%s): %v",
|
|
time.Now().Format(time.RFC3339), eventID, err)
|
|
http.Error(w, "Failed to retrieve event", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if event == nil {
|
|
log.Printf("ERROR [%s] handlers: ViewEventExpenses: event %s not found",
|
|
time.Now().Format(time.RFC3339), eventID)
|
|
http.Error(w, "Event not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
if event.UserID != userID {
|
|
log.Printf("ERROR [%s] handlers: ViewEventExpenses: ownership mismatch for event %s",
|
|
time.Now().Format(time.RFC3339), eventID)
|
|
http.Error(w, "Forbidden", http.StatusForbidden)
|
|
return
|
|
}
|
|
|
|
expenses, err := database.GetExpensesByEvent(h.DB, eventID)
|
|
if err != nil {
|
|
log.Printf("ERROR [%s] handlers: ViewEventExpenses: GetExpensesByEvent(%s): %v",
|
|
time.Now().Format(time.RFC3339), eventID, err)
|
|
http.Error(w, "Failed to load expenses", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Set the current_event_id cookie so subsequent expense operations
|
|
// (SaveExpense, UploadReceipt) know which event to associate with.
|
|
setCurrentEventID(w, eventID)
|
|
|
|
tmpl := getTemplate("event_expenses.html")
|
|
|
|
totalClaim := 0.0
|
|
for _, exp := range expenses {
|
|
if exp.ConvertedAmount > 0 {
|
|
totalClaim += exp.ConvertedAmount
|
|
}
|
|
}
|
|
|
|
// Normalize ImagePath for all expenses (old DB entries may have storage/ prefix).
|
|
for i := range expenses {
|
|
expenses[i].ImagePath = normalizeImagePath(expenses[i].ImagePath)
|
|
}
|
|
|
|
data := map[string]interface{}{
|
|
"Event": event,
|
|
"Expenses": expenses,
|
|
"TotalClaim": totalClaim,
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
if err := tmpl.Execute(w, data); err != nil {
|
|
log.Printf("ERROR [%s] handlers: ViewEventExpenses: execute template: %v",
|
|
time.Now().Format(time.RFC3339), err)
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GET /events/{id}/edit — EditEvent
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// EditEvent returns the event edit form pre-filled with current event data.
|
|
func (h *EventHandler) EditEvent(w http.ResponseWriter, r *http.Request) {
|
|
eventID := chi.URLParam(r, "id")
|
|
event, err := database.GetEventByID(h.DB, eventID)
|
|
if err != nil || event == nil || event.UserID != getUserID(r) {
|
|
http.Error(w, "Forbidden", http.StatusForbidden)
|
|
return
|
|
}
|
|
|
|
tmpl := getTemplate("dashboard.html")
|
|
data := map[string]interface{}{
|
|
"Event": event,
|
|
"Editing": true,
|
|
"Events": []database.Event{},
|
|
"BaseCurrency": event.BaseCurrency,
|
|
"ExchangeRate": event.ExchangeRate,
|
|
"LastSampleRcpt": "",
|
|
"LastSampleClm": "",
|
|
}
|
|
if err := tmpl.Execute(w, data); err != nil {
|
|
log.Printf("ERROR [%s] handlers: EditEvent: execute template: %v",
|
|
time.Now().Format(time.RFC3339), err)
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// PUT /events/{id} — UpdateEvent
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// UpdateEvent updates the event's base currency and exchange rate.
|
|
func (h *EventHandler) UpdateEvent(w http.ResponseWriter, r *http.Request) {
|
|
eventID := chi.URLParam(r, "id")
|
|
event, err := database.GetEventByID(h.DB, eventID)
|
|
if err != nil || event == nil || event.UserID != getUserID(r) {
|
|
http.Error(w, "Forbidden", http.StatusForbidden)
|
|
return
|
|
}
|
|
|
|
baseCurrency := r.FormValue("base_currency")
|
|
if baseCurrency == "" {
|
|
baseCurrency = "USD"
|
|
}
|
|
|
|
exchangeRate := 1.0
|
|
sampleReceipt := r.FormValue("sample_receipt_amount")
|
|
sampleClaim := r.FormValue("sample_claim_amount")
|
|
if sampleReceipt != "" && sampleClaim != "" {
|
|
sampleReceiptVal, err1 := strconv.ParseFloat(sampleReceipt, 64)
|
|
sampleClaimVal, err2 := strconv.ParseFloat(sampleClaim, 64)
|
|
if err1 == nil && err2 == nil && sampleReceiptVal > 0 && sampleClaimVal > 0 {
|
|
exchangeRate = sampleClaimVal / sampleReceiptVal
|
|
}
|
|
}
|
|
|
|
if err := database.UpdateEvent(h.DB, eventID, baseCurrency, exchangeRate); err != nil {
|
|
log.Printf("ERROR [%s] handlers: UpdateEvent: %v", time.Now().Format(time.RFC3339), err)
|
|
http.Error(w, "Failed to update event", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("HX-Redirect", "/dashboard")
|
|
w.WriteHeader(http.StatusOK)
|
|
}
|