Embed files into one package

Author: hiltar

main.go

@@ -1,15 +1,21 @@
 package main
 
 import (
+    "embed"
     "encoding/json"
     "fmt"
     "html/template"
+    "io/fs"
     "net/http"
     "os"
+    "path/filepath"
     "strconv"
     "time"
 )
 
+//go:embed static templates
+var content embed.FS
+
 // Fast represents a fasting record
 type Fast struct {
     StartTime     time.Time `json:"start_time"`
@@ -42,27 +48,34 @@ func loadData() (*AppData, error) {
     }
     file, err := os.Open(dataFile)
     if err != nil {
-        return nil, err
+        return nil, fmt.Errorf("opening data file: %w", err)
     }
     defer file.Close()
     var data AppData
     err = json.NewDecoder(file).Decode(&data)
     if err != nil {
-        return nil, err
+        return nil, fmt.Errorf("decoding data file: %w", err)
     }
     return &data, nil
 }
 
 // saveData writes the application data to the JSON file
 func saveData(data *AppData) error {
+    dir := filepath.Dir(dataFile)
+    if err := os.MkdirAll(dir, 0755); err != nil {
+        return fmt.Errorf("creating data directory: %w", err)
+    }
     file, err := os.Create(dataFile)
     if err != nil {
-        return err
+        return fmt.Errorf("creating data file: %w", err)
     }
     defer file.Close()
     encoder := json.NewEncoder(file)
     encoder.SetIndent("", "  ")
-    return encoder.Encode(data)
+    if err := encoder.Encode(data); err != nil {
+        return fmt.Errorf("encoding data: %w", err)
+    }
+    return nil
 }
 
 // homeHandler redirects to the profile page
@@ -74,11 +87,10 @@ func homeHandler(w http.ResponseWriter, r *http.Request) {
 func profileHandler(w http.ResponseWriter, r *http.Request) {
     data, err := loadData()
     if err != nil {
-        http.Error(w, "Error loading data", http.StatusInternalServerError)
+        http.Error(w, fmt.Sprintf("Error loading data: %v", err), http.StatusInternalServerError)
         return
     }
 
-    // Pagination logic
     const itemsPerPage = 5
     pageStr := r.URL.Query().Get("page")
     page, err := strconv.Atoi(pageStr)
@@ -109,45 +121,49 @@ func profileHandler(w http.ResponseWriter, r *http.Request) {
         HasNext:        page < totalPages,
     }
 
-    tmpl := template.New("profile.html").Funcs(template.FuncMap{
+    tmpl, err := template.New("profile.html").Funcs(template.FuncMap{
         "seq": func(start, end int) []int {
+            if end < start {
+                return []int{}
+            }
             s := make([]int, end-start+1)
             for i := range s {
                 s[i] = start + i
             }
             return s
         },
         "mod": func(a, b int) int {
+            if b == 0 {
+                return 0
+            }
             return a % b
         },
         "add": func(a, b int) int {
             return a + b
         },
-    })
-    tmpl, err = tmpl.ParseFiles("templates/profile.html")
+    }).ParseFS(content, "templates/profile.html")
     if err != nil {
-        http.Error(w, "Error parsing template", http.StatusInternalServerError)
+        http.Error(w, fmt.Sprintf("Error parsing template: %v", err), http.StatusInternalServerError)
         return
     }
     err = tmpl.Execute(w, templateData)
     if err != nil {
-        http.Error(w, "Error executing template", http.StatusInternalServerError)
+        http.Error(w, fmt.Sprintf("Error executing template: %v", err), http.StatusInternalServerError)
     }
 }
 
 // fastingHandler renders the Fasting tab
 func fastingHandler(w http.ResponseWriter, r *http.Request) {
     data, err := loadData()
     if err != nil {
-        http.Error(w, "Error loading data", http.StatusInternalServerError)
+        http.Error(w, fmt.Sprintf("Error loading data: %v", err), http.StatusInternalServerError)
         return
     }
-    t, err := template.ParseFiles("templates/fasting.html")
+    t, err := template.ParseFS(content, "templates/fasting.html")
     if err != nil {
-        http.Error(w, "Error parsing template", http.StatusInternalServerError)
+        http.Error(w, fmt.Sprintf("Error parsing template: %v", err), http.StatusInternalServerError)
         return
     }
-    // Pass error message from query parameter, if any
     type FastingTemplateData struct {
         *AppData
         ErrorMessage string
@@ -158,7 +174,7 @@ func fastingHandler(w http.ResponseWriter, r *http.Request) {
     }
     err = t.Execute(w, templateData)
     if err != nil {
-        http.Error(w, "Error executing template", http.StatusInternalServerError)
+        http.Error(w, fmt.Sprintf("Error executing template: %v", err), http.StatusInternalServerError)
     }
 }
 
@@ -176,7 +192,7 @@ func startFastHandler(w http.ResponseWriter, r *http.Request) {
     goalStr := r.FormValue("goal")
     var goal int
     if goalStr == "" {
-        goal = 0 // Allow empty input as 0
+        goal = 0
     } else {
         goal, err = strconv.Atoi(goalStr)
         if err != nil || goal < 0 {
@@ -199,7 +215,7 @@ func startFastHandler(w http.ResponseWriter, r *http.Request) {
     }
     err = saveData(data)
     if err != nil {
-        http.Redirect(w, r, "/fasting?error=Error saving data", http.StatusSeeOther)
+        http.Redirect(w, r, fmt.Sprintf("/fasting?error=Error saving data: %v", err), http.StatusSeeOther)
         return
     }
     http.Redirect(w, r, "/fasting", http.StatusSeeOther)
@@ -213,30 +229,37 @@ func endFastHandler(w http.ResponseWriter, r *http.Request) {
     }
     data, err := loadData()
     if err != nil {
-        http.Error(w, "Error loading data", http.StatusInternalServerError)
+        http.Error(w, fmt.Sprintf("Error loading data: %v", err), http.StatusInternalServerError)
         return
     }
     if data.CurrentFast == nil {
         http.Error(w, "No fast in progress", http.StatusBadRequest)
         return
     }
     duration := time.Since(data.CurrentFast.StartTime).Hours()
-    data.FastingHistory = append(data.FastingHistory, Fast{
+    completedFast := Fast{
         StartTime:     data.CurrentFast.StartTime,
+        GoalHours:     data.CurrentFast.GoalHours,
         DurationHours: duration,
-    })
+    }
+    data.FastingHistory = append([]Fast{completedFast}, data.FastingHistory...)
     data.CurrentFast = nil
     err = saveData(data)
     if err != nil {
-        http.Error(w, "Error saving data", http.StatusInternalServerError)
+        http.Error(w, fmt.Sprintf("Error saving data: %v", err), http.StatusInternalServerError)
         return
     }
     http.Redirect(w, r, "/fasting", http.StatusSeeOther)
 }
 
 func main() {
-    // Serve static files
-    http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
+    // Serve static files from embedded FS
+    staticFS, err := fs.Sub(content, "static")
+    if err != nil {
+        fmt.Println("Error creating static FS:", err)
+        os.Exit(1)
+    }
+    http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.FS(staticFS))))
 
     // Define routes
     http.HandleFunc("/", homeHandler)
@@ -247,7 +270,7 @@ func main() {
 
     // Start the server
     fmt.Println("Xerophagon starting on :5000...")
-    err := http.ListenAndServe(":5000", nil)
+    err = http.ListenAndServe(":5000", nil)
     if err != nil {
         fmt.Printf("Server failed: %v\n", err)
     }