Logging auf console eingebaut

backend/.env.example

@@ -0,0 +1,51 @@
+# Bamort Server Konfiguration
+
+# ======================
+# Server Einstellungen
+# ======================
+PORT=8180
+SERVER_PORT=8180
+
+# ======================
+# Umgebung
+# ======================
+# Optionen: development, production, test
+ENVIRONMENT=development
+# Alternative:
+# GO_ENV=development
+
+# ======================
+# Logging Konfiguration
+# ======================
+# Debug-Modus (true/false oder 1/0)
+DEBUG=true
+
+# Log-Level (DEBUG, INFO, WARN, ERROR)
+LOG_LEVEL=DEBUG
+
+# ======================
+# Datenbank Konfiguration
+# ======================
+# DATABASE_URL=postgresql://user:password@localhost:5432/bamort_db
+
+# ======================
+# Beispiel-Konfigurationen
+# ======================
+
+# Development:
+# ENVIRONMENT=development
+# DEBUG=true
+# LOG_LEVEL=DEBUG
+# PORT=8180
+
+# Production:
+# ENVIRONMENT=production
+# DEBUG=false
+# LOG_LEVEL=INFO
+# PORT=8180
+
+# Testing:
+# ENVIRONMENT=test
+# DEBUG=true
+# LOG_LEVEL=WARN
+# PORT=8181

backend/.env.production

@@ -0,0 +1,26 @@
+# Bamort Server Konfiguration - Produktionsumgebung
+# Diese Datei sollte für die Produktionsumgebung verwendet werden
+
+# ======================
+# Server Einstellungen
+# ======================
+PORT=8180
+
+# ======================
+# Umgebung
+# ======================
+ENVIRONMENT=production
+
+# ======================
+# Logging Konfiguration
+# ======================
+# Debug-Modus (deaktiviert für Produktion)
+DEBUG=false
+
+# Log-Level (nur wichtige Nachrichten in Produktion)
+LOG_LEVEL=INFO
+
+# ======================
+# Datenbank Konfiguration
+# ======================
+# DATABASE_URL=postgresql://user:password@prod-host:5432/bamort_prod_db

backend/.gitignore

@@ -28,3 +28,13 @@ coverage
 *.sw?
 
 *.tsbuildinfo
+
+# Environment variables
+.env.local
+.env.production.local
+.env.test.local
+
+# Binaries
+main
+bamort
+*.exe

backend/LOGGING.md

@@ -0,0 +1,190 @@
+# Bamort Logging System
+
+## Überblick
+
+Das Bamort Logging System bietet konfigurierbare Debug- und Standard-Logs, die über Umgebungsvariablen oder .env-Dateien gesteuert werden können.
+
+## Konfiguration
+
+### .env-Dateien
+
+Das System lädt automatisch `.env` und `.env.local` Dateien aus dem Projektverzeichnis, falls vorhanden.
+
+**Priorität der Konfigurationsquellen:**
+1. Bereits gesetzte Umgebungsvariablen (höchste Priorität)
+2. .env.local Datei
+3. .env Datei
+4. Standard-Werte (niedrigste Priorität)
+
+**Beispiel .env-Datei:**
+```bash
+# Bamort Server Konfiguration
+ENVIRONMENT=development
+DEBUG=true
+LOG_LEVEL=DEBUG
+PORT=8180
+DATABASE_URL=postgresql://user:pass@localhost:5432/bamort
+```
+
+### Umgebungsvariablen
+
+### Debug-Modus
+```bash
+# Debug-Modus aktivieren
+DEBUG=true
+
+# oder
+DEBUG=1
+```
+
+### Log-Level
+```bash
+# Verfügbare Log-Level: DEBUG, INFO, WARN, ERROR
+LOG_LEVEL=DEBUG
+LOG_LEVEL=INFO
+LOG_LEVEL=WARN
+LOG_LEVEL=ERROR
+```
+
+### Environment
+```bash
+# Umgebung definieren
+ENVIRONMENT=development  # Aktiviert automatisch Debug-Modus
+ENVIRONMENT=production   # Deaktiviert Debug-Modus standardmäßig
+
+# oder
+GO_ENV=development
+GO_ENV=production
+```
+
+### Server-Port
+```bash
+# Server-Port konfigurieren
+PORT=8180
+# oder
+SERVER_PORT=8180
+```
+
+## Verwendung im Code
+
+### Import
+```go
+import "bamort/logger"
+```
+
+### Logging-Funktionen
+```go
+// Debug-Messages (nur sichtbar wenn Debug-Modus aktiviert)
+logger.Debug("Debug-Information: %s", variable)
+logger.Debugf("Debug mit Printf-Syntax: %d", number)
+
+// Info-Messages
+logger.Info("Server gestartet auf Port %s", port)
+logger.Infof("Benutzer %s angemeldet", username)
+
+// Warning-Messages
+logger.Warn("Warnung: %s", warningMessage)
+logger.Warnf("Performance-Warnung: %dms", duration)
+
+// Error-Messages
+logger.Error("Fehler beim Laden der Datenbank: %s", err.Error())
+logger.Errorf("HTTP-Fehler %d: %s", statusCode, message)
+```
+
+### Programmgesteuerte Konfiguration
+```go
+import (
+    "bamort/logger"
+    "bamort/config"
+)
+
+// Konfiguration laden
+cfg := config.LoadConfig()
+
+// Debug-Modus setzen
+logger.SetDebugMode(true)
+
+// Minimales Log-Level setzen
+logger.SetMinLogLevel(logger.DEBUG)
+
+// Debug-Status prüfen
+if logger.IsDebugEnabled() {
+    // Nur ausführen wenn Debug aktiv
+}
+```
+
+## Beispiel-Konfigurationen
+
+### Development
+```bash
+export ENVIRONMENT=development
+export DEBUG=true
+export LOG_LEVEL=DEBUG
+export PORT=8180
+```
+
+### Production
+```bash
+export ENVIRONMENT=production
+export DEBUG=false
+export LOG_LEVEL=INFO
+export PORT=8180
+```
+
+### Testing
+```bash
+export ENVIRONMENT=test
+export DEBUG=true
+export LOG_LEVEL=WARN
+export PORT=8181
+```
+
+## Log-Format
+
+```
+[2025-08-10 15:04:05] DEBUG: Debug-Nachricht hier
+[2025-08-10 15:04:05] INFO: Info-Nachricht hier
+[2025-08-10 15:04:05] WARN: Warning-Nachricht hier
+[2025-08-10 15:04:05] ERROR: Error-Nachricht hier
+```
+
+## Docker-Konfiguration
+
+### Dockerfile
+```dockerfile
+# Für Development
+ENV ENVIRONMENT=development
+ENV DEBUG=true
+ENV LOG_LEVEL=DEBUG
+
+# Für Production
+ENV ENVIRONMENT=production
+ENV DEBUG=false
+ENV LOG_LEVEL=INFO
+```
+
+### docker-compose.yml
+```yaml
+version: '3.8'
+services:
+  bamort-api:
+    environment:
+      - ENVIRONMENT=development
+      - DEBUG=true
+      - LOG_LEVEL=DEBUG
+      - PORT=8180
+```
+
+## Best Practices
+
+1. **Debug-Messages**: Verwenden Sie Debug-Messages für detaillierte Informationen, die nur während der Entwicklung relevant sind.
+
+2. **Info-Messages**: Verwenden Sie Info-Messages für wichtige Ereignisse wie Server-Start, Benutzeraktionen, etc.
+
+3. **Warning-Messages**: Verwenden Sie Warn-Messages für potentielle Probleme, die nicht zum Absturz führen.
+
+4. **Error-Messages**: Verwenden Sie Error-Messages für tatsächliche Fehler und Exceptions.
+
+5. **Performance**: Debug-Messages werden automatisch gefiltert, wenn der Debug-Modus deaktiviert ist, daher keine Performance-Einbußen in der Produktion.
+
+6. **Sensitive Daten**: Niemals Passwörter, Token oder andere sensitive Daten loggen, besonders nicht in höheren Log-Levels.

backend/character/handlers.go

@@ -3,6 +3,7 @@ package character
 import (
 	"bamort/database"
 	"bamort/gsmaster"
+	"bamort/logger"
 	"bamort/models"
 	"strconv"
 	"strings"
@@ -23,16 +24,25 @@ type LearnRequestStruct struct {
 }
 
 func respondWithError(c *gin.Context, status int, message string) {
+	logger.Warn("HTTP Fehler %d: %s", status, message)
 	c.JSON(status, gin.H{"error": message})
 }
 
 func ListCharacters(c *gin.Context) {
+	logger.Debug("ListCharacters aufgerufen")
+
 	var characters []models.Char
 	var listOfChars []models.CharList
+
+	logger.Debug("Lade Charaktere aus der Datenbank...")
 	if err := database.DB.Find(&characters).Error; err != nil {
+		logger.Error("Fehler beim Laden der Charaktere: %s", err.Error())
 		respondWithError(c, http.StatusInternalServerError, "Failed to retrieve characters")
 		return
 	}
+
+	logger.Debug("Gefundene Charaktere: %d", len(characters))
+
 	for i := range characters {
 		listOfChars = append(listOfChars, models.CharList{
 			BamortBase: models.BamortBase{
@@ -45,6 +55,8 @@ func ListCharacters(c *gin.Context) {
 			Owner: "test",
 		})
 	}
+
+	logger.Info("Charakterliste erfolgreich geladen: %d Charaktere", len(listOfChars))
 	c.JSON(http.StatusOK, listOfChars)
 }
 

backend/cmd/main.go

@@ -2,9 +2,11 @@ package main
 
 import (
 	"bamort/character"
+	"bamort/config"
 	"bamort/database"
 	"bamort/gsmaster"
 	"bamort/importer"
+	"bamort/logger"
 	"bamort/maintenance"
 	"bamort/router"
 
@@ -18,24 +20,66 @@ import (
 // @BasePath /
 // @schemes http
 func main() {
+	// Konfiguration laden
+	cfg := config.LoadConfig()
+
+	// Logger konfigurieren
+	logger.SetDebugMode(cfg.DebugMode)
+	if cfg.LogLevel == "DEBUG" {
+		logger.SetMinLogLevel(logger.DEBUG)
+	} else if cfg.LogLevel == "WARN" {
+		logger.SetMinLogLevel(logger.WARN)
+	} else if cfg.LogLevel == "ERROR" {
+		logger.SetMinLogLevel(logger.ERROR)
+	} else {
+		logger.SetMinLogLevel(logger.INFO)
+	}
+
+	logger.Info("Bamort Server wird gestartet...")
+	logger.Debug("Debug-Modus ist aktiviert")
+	logger.Info("Environment: %s", cfg.Environment)
+	logger.Info("Server Port: %s", cfg.ServerPort)
+
+	// Gin-Modus basierend auf Environment setzen
+	if cfg.IsProduction() {
+		gin.SetMode(gin.ReleaseMode)
+		logger.Info("Gin läuft im Release-Modus")
+	} else {
+		gin.SetMode(gin.DebugMode)
+		logger.Debug("Gin läuft im Debug-Modus")
+	}
+
+	// Datenbank verbinden
+	logger.Debug("Verbinde mit Datenbank...")
 	database.ConnectDatabase()
-	//database.DB.AutoMigrate(&models.User{}, &models.Character{}) // Add other models here
+	logger.Info("Datenbankverbindung erfolgreich")
 
 	// Migrate Audit-Log table
+	logger.Debug("Führe Audit-Log Migration durch...")
 	if err := character.MigrateAuditLog(); err != nil {
+		logger.Error("Fehler bei Audit-Log Migration: %s", err.Error())
 		panic("Failed to migrate audit log table: " + err.Error())
 	}
+	logger.Debug("Audit-Log Migration erfolgreich")
 
 	r := gin.Default()
 	router.SetupGin(r)
 
-	// Routes
+	// Routes registrieren
+	logger.Debug("Registriere API-Routen...")
 	protected := router.BaseRouterGrp(r)
 	// Register your module routes
 	gsmaster.RegisterRoutes(protected)
 	character.RegisterRoutes(protected)
 	maintenance.RegisterRoutes(protected)
 	importer.RegisterRoutes(protected)
+	logger.Info("API-Routen erfolgreich registriert")
 
-	r.Run(":8180") // Start server on port 8080
+	// Server starten
+	serverAddress := cfg.GetServerAddress()
+	logger.Info("Server startet auf Adresse: %s", serverAddress)
+	if err := r.Run(serverAddress); err != nil {
+		logger.Error("Fehler beim Starten des Servers: %s", err.Error())
+		panic(err)
+	}
 }

backend/config/config.go

@@ -0,0 +1,167 @@
+package config
+
+import (
+	"bufio"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// Config enthält alle Anwendungskonfigurationen
+type Config struct {
+	// Server Konfiguration
+	ServerPort string
+
+	// Database Konfiguration
+	DatabaseURL string
+
+	// Logging Konfiguration
+	DebugMode bool
+	LogLevel  string
+
+	// Environment
+	Environment string
+}
+
+// defaultConfig gibt die Standard-Konfiguration zurück
+func defaultConfig() *Config {
+	return &Config{
+		ServerPort:  "8180",
+		DatabaseURL: "",
+		DebugMode:   false,
+		LogLevel:    "INFO",
+		Environment: "production",
+	}
+}
+
+// LoadConfig lädt die Konfiguration aus Umgebungsvariablen
+func LoadConfig() *Config {
+	// Lade .env-Datei falls vorhanden
+	loadEnvFile()
+
+	config := defaultConfig()
+
+	// Server Port
+	if port := os.Getenv("PORT"); port != "" {
+		config.ServerPort = port
+	}
+	if port := os.Getenv("SERVER_PORT"); port != "" {
+		config.ServerPort = port
+	}
+
+	// Database
+	if dbURL := os.Getenv("DATABASE_URL"); dbURL != "" {
+		config.DatabaseURL = dbURL
+	}
+
+	// Debug Mode
+	if debug := os.Getenv("DEBUG"); debug != "" {
+		config.DebugMode = strings.ToLower(debug) == "true" || debug == "1"
+	}
+
+	// Log Level
+	if logLevel := os.Getenv("LOG_LEVEL"); logLevel != "" {
+		config.LogLevel = strings.ToUpper(logLevel)
+	}
+
+	// Environment
+	if env := os.Getenv("ENVIRONMENT"); env != "" {
+		config.Environment = strings.ToLower(env)
+	}
+	if env := os.Getenv("GO_ENV"); env != "" {
+		config.Environment = strings.ToLower(env)
+	}
+
+	// Automatisch Debug-Modus für Development-Environment aktivieren
+	if config.Environment == "development" || config.Environment == "dev" {
+		config.DebugMode = true
+		if config.LogLevel == "INFO" {
+			config.LogLevel = "DEBUG"
+		}
+	}
+
+	return config
+}
+
+// loadEnvFile lädt eine .env-Datei falls vorhanden
+func loadEnvFile() {
+	envFiles := []string{".env", ".env.local"}
+
+	for _, envFile := range envFiles {
+		if _, err := os.Stat(envFile); err == nil {
+			loadEnvFileContent(envFile)
+		}
+	}
+}
+
+// loadEnvFileContent lädt den Inhalt einer .env-Datei
+func loadEnvFileContent(filename string) {
+	file, err := os.Open(filename)
+	if err != nil {
+		return
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+
+		// Überspringe leere Zeilen und Kommentare
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		// Teile die Zeile in Key=Value auf
+		parts := strings.SplitN(line, "=", 2)
+		if len(parts) != 2 {
+			continue
+		}
+
+		key := strings.TrimSpace(parts[0])
+		value := strings.TrimSpace(parts[1])
+
+		// Entferne Anführungszeichen falls vorhanden
+		value = strings.Trim(value, `"'`)
+
+		// Setze die Umgebungsvariable nur, wenn sie noch nicht gesetzt ist
+		if os.Getenv(key) == "" {
+			os.Setenv(key, value)
+		}
+	}
+}
+
+// IsDevelopment prüft, ob die Anwendung im Development-Modus läuft
+func (c *Config) IsDevelopment() bool {
+	return c.Environment == "development" || c.Environment == "dev"
+}
+
+// IsProduction prüft, ob die Anwendung im Production-Modus läuft
+func (c *Config) IsProduction() bool {
+	return c.Environment == "production" || c.Environment == "prod"
+}
+
+// GetServerAddress gibt die vollständige Server-Adresse zurück
+func (c *Config) GetServerAddress() string {
+	return ":" + c.ServerPort
+}
+
+// GetBoolEnv ist eine Hilfsfunktion zum Laden von Boolean-Umgebungsvariablen
+func GetBoolEnv(key string, defaultValue bool) bool {
+	if value := os.Getenv(key); value != "" {
+		if parsed, err := strconv.ParseBool(value); err == nil {
+			return parsed
+		}
+		return strings.ToLower(value) == "true" || value == "1"
+	}
+	return defaultValue
+}
+
+// GetIntEnv ist eine Hilfsfunktion zum Laden von Integer-Umgebungsvariablen
+func GetIntEnv(key string, defaultValue int) int {
+	if value := os.Getenv(key); value != "" {
+		if parsed, err := strconv.Atoi(value); err == nil {
+			return parsed
+		}
+	}
+	return defaultValue
+}

backend/config/config_test.go

@@ -0,0 +1,192 @@
+package config
+
+import (
+	"os"
+	"testing"
+)
+
+func TestLoadEnvFile(t *testing.T) {
+	// Test-Datei erstellen
+	envContent := `# Test .env file
+DEBUG=true
+LOG_LEVEL=DEBUG
+PORT=9999
+# Comment line should be ignored
+
+ENVIRONMENT=test
+DATABASE_URL="postgresql://test:test@localhost:5432/test"
+QUOTED_VALUE='single quotes'
+`
+
+	// Temporäre .env-Datei erstellen
+	err := os.WriteFile(".env.test", []byte(envContent), 0644)
+	if err != nil {
+		t.Fatalf("Fehler beim Erstellen der Test-.env-Datei: %v", err)
+	}
+	defer os.Remove(".env.test")
+
+	// Ursprüngliche Umgebungsvariablen sichern
+	originalDebug := os.Getenv("DEBUG")
+	originalLogLevel := os.Getenv("LOG_LEVEL")
+	originalPort := os.Getenv("PORT")
+	originalEnv := os.Getenv("ENVIRONMENT")
+	originalDB := os.Getenv("DATABASE_URL")
+	originalQuoted := os.Getenv("QUOTED_VALUE")
+
+	// Umgebungsvariablen zurücksetzen
+	os.Unsetenv("DEBUG")
+	os.Unsetenv("LOG_LEVEL")
+	os.Unsetenv("PORT")
+	os.Unsetenv("ENVIRONMENT")
+	os.Unsetenv("DATABASE_URL")
+	os.Unsetenv("QUOTED_VALUE")
+
+	// Test-Datei laden
+	loadEnvFileContent(".env.test")
+
+	// Tests
+	tests := []struct {
+		key      string
+		expected string
+	}{
+		{"DEBUG", "true"},
+		{"LOG_LEVEL", "DEBUG"},
+		{"PORT", "9999"},
+		{"ENVIRONMENT", "test"},
+		{"DATABASE_URL", "postgresql://test:test@localhost:5432/test"},
+		{"QUOTED_VALUE", "single quotes"},
+	}
+
+	for _, test := range tests {
+		if value := os.Getenv(test.key); value != test.expected {
+			t.Errorf("Für %s: erwartet '%s', erhalten '%s'", test.key, test.expected, value)
+		}
+	}
+
+	// Ursprüngliche Werte wiederherstellen
+	if originalDebug != "" {
+		os.Setenv("DEBUG", originalDebug)
+	} else {
+		os.Unsetenv("DEBUG")
+	}
+	if originalLogLevel != "" {
+		os.Setenv("LOG_LEVEL", originalLogLevel)
+	} else {
+		os.Unsetenv("LOG_LEVEL")
+	}
+	if originalPort != "" {
+		os.Setenv("PORT", originalPort)
+	} else {
+		os.Unsetenv("PORT")
+	}
+	if originalEnv != "" {
+		os.Setenv("ENVIRONMENT", originalEnv)
+	} else {
+		os.Unsetenv("ENVIRONMENT")
+	}
+	if originalDB != "" {
+		os.Setenv("DATABASE_URL", originalDB)
+	} else {
+		os.Unsetenv("DATABASE_URL")
+	}
+	if originalQuoted != "" {
+		os.Setenv("QUOTED_VALUE", originalQuoted)
+	} else {
+		os.Unsetenv("QUOTED_VALUE")
+	}
+}
+
+func TestEnvVariablesPrecedence(t *testing.T) {
+	// Test, dass bereits gesetzte Umgebungsvariablen Vorrang haben
+	envContent := `DEBUG=false
+LOG_LEVEL=ERROR`
+
+	// Temporäre .env-Datei erstellen
+	err := os.WriteFile(".env.precedence", []byte(envContent), 0644)
+	if err != nil {
+		t.Fatalf("Fehler beim Erstellen der Test-.env-Datei: %v", err)
+	}
+	defer os.Remove(".env.precedence")
+
+	// Umgebungsvariable vorher setzen
+	os.Setenv("DEBUG", "true")
+	os.Setenv("LOG_LEVEL", "INFO")
+
+	// .env-Datei laden
+	loadEnvFileContent(".env.precedence")
+
+	// Tests - bereits gesetzte Werte sollten nicht überschrieben werden
+	if debug := os.Getenv("DEBUG"); debug != "true" {
+		t.Errorf("DEBUG sollte 'true' bleiben, aber ist '%s'", debug)
+	}
+
+	if logLevel := os.Getenv("LOG_LEVEL"); logLevel != "INFO" {
+		t.Errorf("LOG_LEVEL sollte 'INFO' bleiben, aber ist '%s'", logLevel)
+	}
+
+	// Cleanup
+	os.Unsetenv("DEBUG")
+	os.Unsetenv("LOG_LEVEL")
+}
+
+func TestLoadConfigWithEnvFile(t *testing.T) {
+	// Test-Konfiguration mit .env-Datei
+	envContent := `ENVIRONMENT=development
+DEBUG=true
+LOG_LEVEL=DEBUG
+PORT=7777
+DATABASE_URL=test://localhost/testdb`
+
+	// Temporäre .env-Datei erstellen
+	err := os.WriteFile(".env", []byte(envContent), 0644)
+	if err != nil {
+		t.Fatalf("Fehler beim Erstellen der .env-Datei: %v", err)
+	}
+	defer os.Remove(".env")
+
+	// Alle relevanten Umgebungsvariablen zurücksetzen
+	originalVars := map[string]string{
+		"ENVIRONMENT":  os.Getenv("ENVIRONMENT"),
+		"DEBUG":        os.Getenv("DEBUG"),
+		"LOG_LEVEL":    os.Getenv("LOG_LEVEL"),
+		"PORT":         os.Getenv("PORT"),
+		"DATABASE_URL": os.Getenv("DATABASE_URL"),
+	}
+
+	for key := range originalVars {
+		os.Unsetenv(key)
+	}
+
+	// Konfiguration laden
+	config := LoadConfig()
+
+	// Tests
+	if config.Environment != "development" {
+		t.Errorf("Environment: erwartet 'development', erhalten '%s'", config.Environment)
+	}
+
+	if !config.DebugMode {
+		t.Error("DebugMode sollte true sein")
+	}
+
+	if config.LogLevel != "DEBUG" {
+		t.Errorf("LogLevel: erwartet 'DEBUG', erhalten '%s'", config.LogLevel)
+	}
+
+	if config.ServerPort != "7777" {
+		t.Errorf("ServerPort: erwartet '7777', erhalten '%s'", config.ServerPort)
+	}
+
+	if config.DatabaseURL != "test://localhost/testdb" {
+		t.Errorf("DatabaseURL: erwartet 'test://localhost/testdb', erhalten '%s'", config.DatabaseURL)
+	}
+
+	// Ursprüngliche Werte wiederherstellen
+	for key, value := range originalVars {
+		if value != "" {
+			os.Setenv(key, value)
+		} else {
+			os.Unsetenv(key)
+		}
+	}
+}

backend/demo_env.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+echo "=== Bamort .env Konfiguration Demo ==="
+echo ""
+
+# Erstelle verschiedene .env-Dateien für Demo
+echo "# Development .env" > .env.dev.demo
+echo "ENVIRONMENT=development" >> .env.dev.demo
+echo "DEBUG=true" >> .env.dev.demo
+echo "LOG_LEVEL=DEBUG" >> .env.dev.demo
+echo "PORT=8180" >> .env.dev.demo
+echo "" >> .env.dev.demo
+
+echo "# Production .env" > .env.prod.demo
+echo "ENVIRONMENT=production" >> .env.prod.demo
+echo "DEBUG=false" >> .env.prod.demo
+echo "LOG_LEVEL=INFO" >> .env.prod.demo
+echo "PORT=8080" >> .env.prod.demo
+echo "" >> .env.prod.demo
+
+echo "1. Development-Konfiguration (.env.dev.demo):"
+cat .env.dev.demo
+echo ""
+
+echo "2. Production-Konfiguration (.env.prod.demo):"
+cat .env.prod.demo
+echo ""
+
+echo "3. Test mit Development-Konfiguration:"
+cp .env.dev.demo .env
+echo "Building and testing with development config..."
+go run cmd/logging_demo.go 2>/dev/null | head -10
+echo ""
+
+echo "4. Test mit Production-Konfiguration:"
+cp .env.prod.demo .env
+echo "Building and testing with production config..."
+go run cmd/logging_demo.go 2>/dev/null | head -10
+echo ""
+
+echo "5. Test mit Umgebungsvariablen-Override:"
+echo "Setze DEBUG=false als Umgebungsvariable (sollte .env überschreiben)"
+DEBUG=false go run cmd/logging_demo.go 2>/dev/null | head -10
+echo ""
+
+# Cleanup
+rm -f .env.dev.demo .env.prod.demo
+
+echo "=== Demo beendet ==="
+echo ""
+echo "Tipp: Kopiere .env.example nach .env und passe sie an deine Bedürfnisse an:"
+echo "cp .env.example .env"

backend/logger/logger.go

@@ -0,0 +1,156 @@
+package logger
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"strings"
+	"time"
+)
+
+// LogLevel definiert die verschiedenen Log-Level
+type LogLevel int
+
+const (
+	DEBUG LogLevel = iota
+	INFO
+	WARN
+	ERROR
+)
+
+// String gibt eine String-Repräsentation des Log-Levels zurück
+func (l LogLevel) String() string {
+	switch l {
+	case DEBUG:
+		return "DEBUG"
+	case INFO:
+		return "INFO"
+	case WARN:
+		return "WARN"
+	case ERROR:
+		return "ERROR"
+	default:
+		return "UNKNOWN"
+	}
+}
+
+// Logger struct enthält die Konfiguration
+type Logger struct {
+	debugEnabled bool
+	minLevel     LogLevel
+	logger       *log.Logger
+}
+
+// Globaler Logger
+var defaultLogger *Logger
+
+// init initialisiert den Standard-Logger
+func init() {
+	defaultLogger = &Logger{
+		debugEnabled: getDebugModeFromEnv(),
+		minLevel:     getMinLogLevelFromEnv(),
+		logger:       log.New(os.Stdout, "", 0), // Kein Standard-Prefix, wir verwenden unseren eigenen
+	}
+}
+
+// getDebugModeFromEnv liest den Debug-Modus aus Umgebungsvariablen
+func getDebugModeFromEnv() bool {
+	debugMode := os.Getenv("DEBUG")
+	return strings.ToLower(debugMode) == "true" || debugMode == "1"
+}
+
+// getMinLogLevelFromEnv liest das minimale Log-Level aus Umgebungsvariablen
+func getMinLogLevelFromEnv() LogLevel {
+	levelStr := strings.ToUpper(os.Getenv("LOG_LEVEL"))
+	switch levelStr {
+	case "DEBUG":
+		return DEBUG
+	case "INFO":
+		return INFO
+	case "WARN":
+		return WARN
+	case "ERROR":
+		return ERROR
+	default:
+		if getDebugModeFromEnv() {
+			return DEBUG
+		}
+		return INFO
+	}
+}
+
+// SetDebugMode aktiviert oder deaktiviert den Debug-Modus
+func SetDebugMode(enabled bool) {
+	defaultLogger.debugEnabled = enabled
+	if enabled && defaultLogger.minLevel > DEBUG {
+		defaultLogger.minLevel = DEBUG
+	}
+}
+
+// SetMinLogLevel setzt das minimale Log-Level
+func SetMinLogLevel(level LogLevel) {
+	defaultLogger.minLevel = level
+}
+
+// IsDebugEnabled gibt zurück, ob der Debug-Modus aktiviert ist
+func IsDebugEnabled() bool {
+	return defaultLogger.debugEnabled && defaultLogger.minLevel <= DEBUG
+}
+
+// logMessage ist die interne Funktion zum Loggen von Nachrichten
+func logMessage(level LogLevel, format string, args ...interface{}) {
+	if level < defaultLogger.minLevel {
+		return
+	}
+
+	// Für Debug-Messages zusätzlich prüfen, ob Debug-Modus aktiviert ist
+	if level == DEBUG && !defaultLogger.debugEnabled {
+		return
+	}
+
+	timestamp := time.Now().Format("2006-01-02 15:04:05")
+	message := fmt.Sprintf(format, args...)
+	logLine := fmt.Sprintf("[%s] %s: %s", timestamp, level.String(), message)
+
+	defaultLogger.logger.Println(logLine)
+}
+
+// Debug loggt Debug-Nachrichten (nur wenn Debug-Modus aktiviert)
+func Debug(format string, args ...interface{}) {
+	logMessage(DEBUG, format, args...)
+}
+
+// Info loggt Info-Nachrichten
+func Info(format string, args ...interface{}) {
+	logMessage(INFO, format, args...)
+}
+
+// Warn loggt Warn-Nachrichten
+func Warn(format string, args ...interface{}) {
+	logMessage(WARN, format, args...)
+}
+
+// Error loggt Error-Nachrichten
+func Error(format string, args ...interface{}) {
+	logMessage(ERROR, format, args...)
+}
+
+// Debugf ist ein Alias für Debug (für Kompatibilität)
+func Debugf(format string, args ...interface{}) {
+	Debug(format, args...)
+}
+
+// Infof ist ein Alias für Info (für Kompatibilität)
+func Infof(format string, args ...interface{}) {
+	Info(format, args...)
+}
+
+// Warnf ist ein Alias für Warn (für Kompatibilität)
+func Warnf(format string, args ...interface{}) {
+	Warn(format, args...)
+}
+
+// Errorf ist ein Alias für Error (für Kompatibilität)
+func Errorf(format string, args ...interface{}) {
+	Error(format, args...)
+}

backend/logger/logger_test.go

@@ -0,0 +1,123 @@
+package logger
+
+import (
+	"os"
+	"testing"
+)
+
+func TestLogLevels(t *testing.T) {
+	// Test String-Representation der Log-Levels
+	tests := []struct {
+		level    LogLevel
+		expected string
+	}{
+		{DEBUG, "DEBUG"},
+		{INFO, "INFO"},
+		{WARN, "WARN"},
+		{ERROR, "ERROR"},
+	}
+
+	for _, test := range tests {
+		if test.level.String() != test.expected {
+			t.Errorf("Expected %s, got %s", test.expected, test.level.String())
+		}
+	}
+}
+
+func TestDebugModeFromEnv(t *testing.T) {
+	// Test verschiedene Umgebungsvariablen-Werte
+	tests := []struct {
+		envValue string
+		expected bool
+	}{
+		{"true", true},
+		{"TRUE", true},
+		{"True", true},
+		{"1", true},
+		{"false", false},
+		{"FALSE", false},
+		{"False", false},
+		{"0", false},
+		{"", false},
+		{"invalid", false},
+	}
+
+	for _, test := range tests {
+		os.Setenv("DEBUG", test.envValue)
+		result := getDebugModeFromEnv()
+		if result != test.expected {
+			t.Errorf("For DEBUG=%s, expected %v, got %v", test.envValue, test.expected, result)
+		}
+	}
+
+	// Cleanup
+	os.Unsetenv("DEBUG")
+}
+
+func TestMinLogLevelFromEnv(t *testing.T) {
+	// Test verschiedene LOG_LEVEL Werte
+	tests := []struct {
+		envValue string
+		expected LogLevel
+	}{
+		{"DEBUG", DEBUG},
+		{"debug", DEBUG},
+		{"INFO", INFO},
+		{"info", INFO},
+		{"WARN", WARN},
+		{"warn", WARN},
+		{"ERROR", ERROR},
+		{"error", ERROR},
+		{"invalid", INFO}, // Default zu INFO
+		{"", INFO},        // Default zu INFO
+	}
+
+	// DEBUG-Modus deaktivieren für diese Tests
+	os.Setenv("DEBUG", "false")
+
+	for _, test := range tests {
+		os.Setenv("LOG_LEVEL", test.envValue)
+		result := getMinLogLevelFromEnv()
+		if result != test.expected {
+			t.Errorf("For LOG_LEVEL=%s, expected %v, got %v", test.envValue, test.expected, result)
+		}
+	}
+
+	// Test: Wenn DEBUG=true und kein LOG_LEVEL gesetzt, sollte DEBUG returned werden
+	os.Setenv("DEBUG", "true")
+	os.Unsetenv("LOG_LEVEL")
+	result := getMinLogLevelFromEnv()
+	if result != DEBUG {
+		t.Errorf("When DEBUG=true and no LOG_LEVEL set, expected DEBUG, got %v", result)
+	}
+
+	// Cleanup
+	os.Unsetenv("DEBUG")
+	os.Unsetenv("LOG_LEVEL")
+}
+
+func TestSetDebugMode(t *testing.T) {
+	// Test Debug-Modus aktivieren
+	SetDebugMode(true)
+	if !IsDebugEnabled() {
+		t.Error("Debug mode should be enabled")
+	}
+
+	// Test Debug-Modus deaktivieren
+	SetDebugMode(false)
+	if IsDebugEnabled() {
+		t.Error("Debug mode should be disabled")
+	}
+}
+
+func TestSetMinLogLevel(t *testing.T) {
+	// Test verschiedene Log-Level setzen
+	levels := []LogLevel{DEBUG, INFO, WARN, ERROR}
+
+	for _, level := range levels {
+		SetMinLogLevel(level)
+		if defaultLogger.minLevel != level {
+			t.Errorf("Expected min log level %v, got %v", level, defaultLogger.minLevel)
+		}
+	}
+}