Merge pull request #14 from Tanq16/featurenew

Config File and Settings from UI

Author: Tanq16

README.md

@@ -36,9 +36,9 @@ So, I created this project, which I use in my home lab to track my expenses. Thi
 - Multi-architecture Docker container with support for persistent storage
 - REST API for expense management
 - Single-user focused (mainly for a home lab deployment)
-- CSV export of all expense data from the UI
-- Custom categories via environment variable (`EXPENSE_CATEGORIES`) with sensible defaults
-- Custom currency symbol in the frontend via environment variable (`CURRENCY`)
+- CSV and JSON export of all expense data from the UI
+- Custom categories via app settings or environment variable (`EXPENSE_CATEGORIES`)
+- Custom currency symbol in the frontend via app settings environment variable (`CURRENCY`)
 
 ### Visualization
 
@@ -50,6 +50,7 @@ So, I created this project, which I use in my home lab to track my expenses. Thi
     - This is where you can view individual expenses chronologically and delete them
     - You can use the browser's search to find a name if needed
 3. Month-by-month navigation
+4. Settings page for setting custom categories, currency, and export data as CSV or JSON
 
 ### Progressive Web App (PWA)
 
@@ -180,26 +181,30 @@ curl http://localhost:8080/expenses
 
 ### Config Options
 
+The primary config is stored in the data directory in the `config.json` file. A pre-defined configuration is automatically initialized. The currency in use and the categories can be customized from the `/settings` endpoint within the UI.
+
 ##### Currency Settings
 
-ExpenseOwl supports multiple currencies through the CURRENCY environment variable. If not specified, it defaults to USD ($). For example, to run with Euro, use the following environment variable:
+ExpenseOwl supports multiple currencies through the CURRENCY environment variable. If not specified, it defaults to USD ($). All available options are shown in the UI settings page.
+
+Alternatively, an environment variable can also be used to set the currency. This is useful for containerized deployments where non-sensitive configuration can remain as deployment templates. For example, to use Euro:
 
 ```bash
 CURRENCY=eur ./expenseowl
 ```
 
-Similarly, the environment variable can be set in a compose stack or using `-e` in the command line with a Docker command. The full list of supported currencies is in [this file](https://github.com/Tanq16/ExpenseOwl/blob/main/internal/config/config.go#L27).
+The environment variable can be set in a compose stack or using `-e` in the command line with a Docker command.
 
 ##### Category Settings
 
-ExpenseOwl also supports custom categories, which can be specified through environment variables like so:
+ExpenseOwl also supports custom categories. A default set is pre-loaded in the config for ease of use and can be easily changed within the UI.
+
+Alternatively, like currency, categories can also be specified in an environment variable like so:
 
 ```bash
 EXPENSE_CATEGORIES="Rent,Food,Transport,Fun,Bills" ./expenseowl
 ```
 
-Similarly, it can be specified in a Docker compose stack of a Docker CLI command with the `-e` flag. Refer to the examples shown above in the README.
-
 # Contributing
 
 Contributions are welcome; please ensure they align with the project's philosophy of simplicity. The project's core principle is maintaining user-facing simplicity by strictly using the current [tech stack](#technology-stack). It is intended for home lab use, i.e., a self-hosted first approach (containerized use). Consider the following:

cmd/expenseowl/main.go

@@ -26,8 +26,10 @@ func runServer(dataPath string) {
 	http.HandleFunc("/expense", handler.AddExpense)
 	http.HandleFunc("/expenses", handler.GetExpenses)
 	http.HandleFunc("/table", handler.ServeTableView)
+	http.HandleFunc("/settings", handler.ServeSettingsPage)
 	http.HandleFunc("/expense/delete", handler.DeleteExpense)
-	http.HandleFunc("/export", handler.ExportCSV)
+	http.HandleFunc("/export/json", handler.ExportJSON)
+	http.HandleFunc("/export/csv", handler.ExportCSV)
 	http.HandleFunc("/manifest.json", handler.ServeManifest)
 	http.HandleFunc("/sw.js", handler.ServeServiceWorker)
 	http.HandleFunc("/pwa/", handler.ServePWAIcon)

internal/api/handlers.go

@@ -67,7 +67,7 @@ func (h *Handler) EditCategories(w http.ResponseWriter, r *http.Request) {
 		log.Printf("HTTP ERROR: Failed to decode request body: %v\n", err)
 		return
 	}
-	h.config.Categories = categories
+	h.config.UpdateCategories(categories)
 	writeJSON(w, http.StatusOK, map[string]string{"status": "success"})
 	log.Println("HTTP: Updated categories")
 }
@@ -84,7 +84,7 @@ func (h *Handler) EditCurrency(w http.ResponseWriter, r *http.Request) {
 		log.Printf("HTTP ERROR: Failed to decode request body: %v\n", err)
 		return
 	}
-	h.config.Currency = currency
+	h.config.UpdateCurrency(currency)
 	writeJSON(w, http.StatusOK, map[string]string{"status": "success"})
 	log.Println("HTTP: Updated currency")
 }
@@ -152,6 +152,20 @@ func (h *Handler) ServeTableView(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func (h *Handler) ServeSettingsPage(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		log.Println("HTTP ERROR: Method not allowed")
+		return
+	}
+	w.Header().Set("Content-Type", "text/html")
+	if err := web.ServeTemplate(w, "settings.html"); err != nil {
+		http.Error(w, "Failed to serve template", http.StatusInternalServerError)
+		log.Printf("HTTP ERROR: Failed to serve template: %v\n", err)
+		return
+	}
+}
+
 func (h *Handler) DeleteExpense(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodDelete {
 		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
@@ -254,6 +268,31 @@ func (h *Handler) ExportCSV(w http.ResponseWriter, r *http.Request) {
 	log.Println("HTTP: Exported expenses to CSV")
 }
 
+func (h *Handler) ExportJSON(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		log.Println("HTTP ERROR: Method not allowed")
+		return
+	}
+	expenses, err := h.storage.GetAllExpenses()
+	if err != nil {
+		writeJSON(w, http.StatusInternalServerError, ErrorResponse{Error: "Failed to retrieve expenses"})
+		log.Printf("HTTP ERROR: Failed to retrieve expenses: %v\n", err)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("Content-Disposition", "attachment; filename=expenses.json")
+	// Pretty print the JSON data for better readability
+	jsonData, err := json.MarshalIndent(expenses, "", "    ")
+	if err != nil {
+		http.Error(w, "Failed to marshal JSON data", http.StatusInternalServerError)
+		log.Printf("HTTP ERROR: Failed to marshal JSON data: %v\n", err)
+		return
+	}
+	w.Write(jsonData)
+	log.Println("HTTP: Exported expenses to JSON")
+}
+
 func writeJSON(w http.ResponseWriter, status int, v interface{}) {
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(status)

internal/config/config.go

@@ -1,11 +1,13 @@
 package config
 
 import (
+	"encoding/json"
 	"errors"
 	"log"
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -14,6 +16,12 @@ type Config struct {
 	StoragePath string
 	Categories  []string
 	Currency    string
+	mu          sync.RWMutex
+}
+
+type FileConfig struct {
+	Categories []string `json:"categories"`
+	Currency   string   `json:"currency"`
 }
 
 var defaultCategories = []string{
@@ -81,32 +89,110 @@ func (e *Expense) Validate() error {
 }
 
 func NewConfig(dataPath string) *Config {
-	categories := defaultCategories
+	finalPath := ""
+	if dataPath == "data" {
+		finalPath = filepath.Join(".", "data")
+	} else {
+		finalPath = filepath.Clean(dataPath)
+	}
+	if err := os.MkdirAll(finalPath, 0755); err != nil {
+		log.Printf("Error creating data directory: %v", err)
+	}
+	log.Printf("Using data directory: %s\n", finalPath)
+	cfg := &Config{
+		ServerPort:  "8080",
+		StoragePath: finalPath,
+		Categories:  defaultCategories,
+		Currency:    "$", // Default to USD
+	}
+	configPath := filepath.Join(finalPath, "config.json")
+	if fileConfig, err := loadConfigFile(configPath); err == nil {
+		cfg.Categories = fileConfig.Categories
+		cfg.Currency = fileConfig.Currency
+		log.Println("Loaded configuration from file")
+	}
 	if envCategories := os.Getenv("EXPENSE_CATEGORIES"); envCategories != "" {
-		categories = strings.Split(envCategories, ",")
+		categories := strings.Split(envCategories, ",")
 		for i := range categories {
 			categories[i] = strings.TrimSpace(categories[i])
 		}
+		cfg.Categories = categories
+		log.Println("Using custom categories from environment variables")
 	}
-	log.Println("Using custom categories from environment variables")
-	currency := "$" // Default to USD
 	if envCurrency := strings.ToLower(os.Getenv("CURRENCY")); envCurrency != "" {
 		if symbol, exists := currencySymbols[envCurrency]; exists {
-			currency = symbol
+			cfg.Currency = symbol
 		}
+		log.Println("Using custom currency from environment variables")
 	}
-	log.Println("Using custom currency from environment variables")
-	finalPath := ""
-	if dataPath == "data" {
-		finalPath = filepath.Join(".", "data")
-	} else {
-		finalPath = filepath.Clean(dataPath)
+	cfg.SaveConfig()
+	return cfg
+}
+
+func loadConfigFile(filePath string) (*FileConfig, error) {
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil, err
 	}
-	log.Printf("Using data directory: %s\n", finalPath)
-	return &Config{
-		ServerPort:  "8080",
-		StoragePath: finalPath,
-		Categories:  categories,
-		Currency:    currency,
+	var config FileConfig
+	if err := json.Unmarshal(data, &config); err != nil {
+		return nil, err
+	}
+	return &config, nil
+}
+
+func (c *Config) SaveConfig() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	filePath := filepath.Join(c.StoragePath, "config.json")
+	fileConfig := FileConfig{
+		Categories: c.Categories,
+		Currency:   c.Currency,
+	}
+	data, err := json.MarshalIndent(fileConfig, "", "    ")
+	if err != nil {
+		return err
 	}
+	return os.WriteFile(filePath, data, 0644)
 }
+
+func (c *Config) UpdateCategories(categories []string) error {
+	c.mu.Lock()
+	c.Categories = categories
+	c.mu.Unlock()
+	return c.SaveConfig()
+}
+
+func (c *Config) UpdateCurrency(currencyCode string) error {
+	c.mu.Lock()
+	if symbol, exists := currencySymbols[strings.ToLower(currencyCode)]; exists {
+		c.Currency = symbol
+	} else {
+		c.mu.Unlock()
+		return errors.New("invalid currency code")
+	}
+	c.mu.Unlock()
+	return c.SaveConfig()
+}
+
+// func (c *Config) GetCategories() []string {
+// 	c.mu.RLock()
+// 	defer c.mu.RUnlock()
+// 	categories := make([]string, len(c.Categories))
+// 	copy(categories, c.Categories)
+// 	return categories
+// }
+
+// func (c *Config) GetCurrency() string {
+// 	c.mu.RLock()
+// 	defer c.mu.RUnlock()
+// 	return c.Currency
+// }
+
+// func GetCurrencySymbolMap() map[string]string {
+// 	symbolMap := make(map[string]string)
+// 	for k, v := range currencySymbols {
+// 		symbolMap[k] = v
+// 	}
+// 	return symbolMap
+// }

internal/web/templates/index.html

@@ -31,8 +31,8 @@ <h1 align="center">ExpenseOwl</h1>
                 <a href="/table" class="view-button" data-tooltip="Table View">
                     <i class="fa-solid fa-table"></i>
                 </a>
-                <a href="/export" class="view-button" download="expenses.csv" data-tooltip="All expenses to CSV">
-                    <i class="fa-solid fa-file-csv"></i>
+                <a href="/settings" class="view-button" data-tooltip="Settings">
+                    <i class="fa-solid fa-gear"></i>
                 </a>
             </div>
         </header>
@@ -114,7 +114,7 @@ <h1 align="center">ExpenseOwl</h1>
             if (postfixCurrencies.has(currencySymbol)) {
                 return `${formattedAmount} ${currencySymbol}`;
             }
-            return `${currencySymbol}${formattedAmount}`;
+            return `${currencySymbol} ${formattedAmount}`;
         }
 
         function calculateCategoryBreakdown(expenses) {