Merge pull request 'Closed issue #8 and Created A command to clear the db from entries that are 40 days old or older. The DB now lies in an external volume so the redeploy wont hurt it' (#10) from dev into main

Reviewed-on: #10

.dockerignore

@@ -0,0 +1,4 @@
+.git
+bot.db
+vendor
+.env

.env.example

@@ -0,0 +1 @@
+DISCORD_TOKEN="Ein Discord Token"

.gitea/workflows/test.yaml

@@ -0,0 +1,21 @@
+name: Bot Unit Tests
+
+on:
+  push:
+    branches: [ "main", "master", "dev" ]
+  pull_request:
+    branches: [ "main", "master" ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.25'
+          check-latest: false
+          cache: true
+      - name: Run Tests
+        run: go test ./... -v

.gitignore

@@ -1,2 +1,2 @@
 .env
-bot.db
+*.db

Dockerfile

@@ -0,0 +1,31 @@
+# STAGE 1: Build
+FROM golang:1.25-bookworm AS builder
+
+# Arbeitsverzeichnis im Container
+WORKDIR /app
+
+# Erst Abhängigkeiten kopieren (für besseres Caching)
+COPY go.mod go.sum ./
+RUN go mod download
+
+# Restlichen Code kopieren
+COPY . .
+
+# Statisch kompilieren (wichtig für alpine)
+RUN CGO_ENABLED=0 GOOS=linux go build -o bot main.go
+
+# STAGE 2: Run
+FROM alpine:latest
+
+# Zertifikate für Discord (HTTPS) installieren
+RUN apk --no-cache add ca-certificates
+
+WORKDIR /root/
+
+# Nur die Binary vom Builder kopieren
+COPY --from=builder /app/bot .
+# Falls du eine .env lokal nutzt (auf dem Server meist via Environment im Stack)
+# COPY .env . 
+
+# Startbefehl
+CMD ["./bot"]

db_management/db_management.go

@@ -2,6 +2,8 @@ package db_management
 
 import (
 	"database/sql"
+	"log"
+	"os"
 	"time"
 
 	_ "modernc.org/sqlite"
@@ -12,7 +14,12 @@ var DB *sql.DB
 func InitDB() {
 	var err error
 	// Öffnet bot.db im aktuellen Verzeichnis
-	DB, err = sql.Open("sqlite", "./bot.db")
+	dbPath := os.Getenv("DB_PATH")
+	if dbPath == "" {
+		dbPath = "./bot.db"
+	}
+
+	DB, err = sql.Open("sqlite", dbPath)
 	if err != nil {
 		panic(err)
 	}
@@ -31,14 +38,18 @@ func InitDB() {
 }
 
 func SaveSession(userID string, seconds int) {
-	query := `INSERT INTO voice_sessions (user_id, seconds, created_at) VALUES (?, ?, ?)`
+	query := `
+	INSERT INTO voice_sessions (user_id, seconds, created_at)
+	VALUES (?, ?, ?)
+	`
+
 	DB.Exec(query, userID, seconds, time.Now())
 }
 
 func GetUserStats(userID string) int {
 	var total sql.NullInt64 // NullInt64 fängt NULL-Ergebnisse ab
 	query := `SELECT SUM(seconds) FROM voice_sessions 
-              WHERE user_id = ? AND created_at > date('now', '-30 days')`
+              WHERE user_id = ? AND created_at > datetime('now', '-30 days')`
 
 	err := DB.QueryRow(query, userID).Scan(&total)
 	if err != nil || !total.Valid {
@@ -46,3 +57,53 @@ func GetUserStats(userID string) int {
 	}
 	return int(total.Int64)
 }
+
+type UserStats struct {
+	UserID  string
+	Seconds int
+}
+
+func GetTopUsers(limit int) []UserStats {
+	query := `
+	SELECT user_id, SUM(seconds) as total
+	FROM voice_sessions
+	WHERE created_at > datetime('now', '-30 days')
+	GROUP BY user_id
+	ORDER BY total DESC
+	LIMIT ?
+	`
+
+	rows, err := DB.Query(query, limit)
+	if err != nil {
+		return nil
+	}
+	defer rows.Close()
+
+	var result []UserStats
+
+	for rows.Next() {
+		var u UserStats
+		err := rows.Scan(&u.UserID, &u.Seconds)
+		if err != nil {
+			continue
+		}
+		result = append(result, u)
+	}
+
+	return result
+}
+
+func CleanupOldEntries() {
+	query := `DELETE FROM voice_sessions WHERE created_at < datetime('now', '-40 days)`
+
+	result, err := DB.Exec(query)
+	if err != nil {
+		log.Printf("Fehler beim DB-Cleanup: %v", err)
+		return
+	}
+
+	rowsAffected, _ := result.RowsAffected()
+	if rowsAffected > 0 {
+		log.Printf("DB Cleanup erfolgreich: %d alte Einträge gelöscht.", rowsAffected)
+	}
+}

docker-compose.yaml

@@ -0,0 +1,43 @@
+version: '3.8'
+
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    image: discord_vc_bot:latest
+    pull_policy: build
+    container_name: docker_vc_bot
+    restart: unless-stopped
+
+    volumes:
+      - discord_db:/app/data  
+
+    environment:
+      - DB_PATH=/app/data/bot.db  
+      - DISCORD_TOKEN=${DISCORD_TOKEN}
+
+    deploy:
+      resources:
+        limits:
+          cpus: '0.50'
+          memory: 256M
+        reservations:
+          memory: 64M
+
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+
+    networks:
+      - discord_backend_net
+
+networks:
+  discord_backend_net:
+    driver: bridge
+
+volumes:
+  discord_db:
+    external: true  

go.mod

@@ -1,6 +1,6 @@
 module heydeman/vc-stat-bot-discord
 
-go 1.26.1
+go 1.25.0
 
 require (
 	github.com/bwmarrin/discordgo v0.29.0
@@ -18,6 +18,7 @@ require (
 	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/robfig/cron/v3 v3.0.1 // indirect
 	golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b // indirect
 	golang.org/x/sys v0.42.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect

go.sum

@@ -22,6 +22,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
+github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b h1:7mWr3k41Qtv8XlltBkDkl8LoP3mpSgBW8BUoxtEdbXg=

main.go

@@ -10,15 +10,22 @@ import (
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/joho/godotenv"
+	"github.com/robfig/cron/v3"
 
-	// WICHTIG: Pfad entspricht deiner go.mod
 	"heydeman/vc-stat-bot-discord/db_management"
 )
 
-var startTimes = make(map[string]time.Time)
+var sessions = make(map[string]*Session)
+
+type Session struct {
+	Start    time.Time
+	PausedAt *time.Time
+	Paused   bool
+	Accum    time.Duration
+}
 
 func main() {
-	_ = godotenv.Load() // Ignoriert Fehler, falls keine .env existiert (nutzt dann System-Vars)
+	_ = godotenv.Load()
 
 	db_management.InitDB()
 
@@ -32,71 +39,267 @@ func main() {
 		log.Fatal(err)
 	}
 
-	discord.AddHandler(messageCreate)
+	// Handler & Intents
+	discord.AddHandler(interactionCreate)
 	discord.AddHandler(voiceUpdate)
-
+	discord.Identify.Intents = discordgo.IntentsGuilds | discordgo.IntentsGuildVoiceStates
-	discord.Identify.Intents = discordgo.IntentsGuildMessages |
-		discordgo.IntentsMessageContent |
-		discordgo.IntentsGuildVoiceStates
 
 	err = discord.Open()
 	if err != nil {
 		log.Fatal("Error opening connection:", err)
 	}
 
-	fmt.Println("Bot läuft stabil auf Hetzner. Drücke CTRL+C zum Beenden.")
+	registerCommands(discord)
 
+	// ==========================================
+	// 🕒 CRON SCHEDULER SETUP
+	// ==========================================
+	c := cron.New()
+
+	// Alle 5 Minuten: Aktuellen Stand in die DB schieben
+	_, _ = c.AddFunc("*/5 * * * *", func() {
+		fmt.Println("🔄 Cron Auto-Save: Speichere Zwischenstände...")
+		for uid, sess := range sessions {
+			processAndSave(uid, sess)
+		}
+	})
+
+	// Jeden Tag um 00:00 Uhr: Alte Daten (40+ Tage) löschen
+	_, _ = c.AddFunc("0 0 * * *", func() {
+		fmt.Println("🧹 Cron Cleanup: Lösche Daten älter als 40 Tage...")
+		db_management.CleanupOldEntries()
+	})
+
+	c.Start()
+	defer c.Stop()
+
+	fmt.Println("Bot läuft stabil. CTRL+C zum Beenden.")
+
+	// Shutdown Handling
 	stop := make(chan os.Signal, 1)
 	signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)
 	<-stop
 
-	// Graceful Shutdown: Alle aktuell aktiven Sessions noch schnell speichern
+	fmt.Println("Speichere aktive Sessions vor Shutdown...")
-	fmt.Println("Speichere aktive Sessions vor dem Beenden...")
+	// Beim Beenden alles wegschreiben, was noch im RAM ist
-	for uid, start := range startTimes {
+	for uid, sess := range sessions {
-		db_management.SaveSession(uid, int(time.Since(start).Seconds()))
+		processAndSave(uid, sess)
 	}
 
 	discord.Close()
 }
 
-func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
+func registerCommands(s *discordgo.Session) {
-	if m.Author.Bot {
+
+	// /stats
+	_, err := s.ApplicationCommandCreate(s.State.User.ID, "", &discordgo.ApplicationCommand{
+		Name:        "stats",
+		Description: "Zeigt die 30-Tage Statistik eines Users",
+		Options: []*discordgo.ApplicationCommandOption{
+			{
+				Type:        discordgo.ApplicationCommandOptionUser,
+				Name:        "user",
+				Description: "Optional: anderer User",
+				Required:    false,
+			},
+		},
+	})
+	if err != nil {
+		log.Println("Fehler bei /stats:", err)
+	}
+
+	// /top
+	_, err = s.ApplicationCommandCreate(s.State.User.ID, "", &discordgo.ApplicationCommand{
+		Name:        "top",
+		Description: "Top 10 User nach Zeit (30 Tage)",
+	})
+	if err != nil {
+		log.Println("Fehler bei /top:", err)
+	}
+}
+
+func interactionCreate(s *discordgo.Session, i *discordgo.InteractionCreate) {
+
+	if i.Type != discordgo.InteractionApplicationCommand {
 		return
 	}
 
-	if m.Content == "!stats" {
+	switch i.ApplicationCommandData().Name {
-		totalSeconds := db_management.GetUserStats(m.Author.ID)
+
+	// =====================
+	// /stats
+	// =====================
+	case "stats":
+
+		user := i.Member.User
+
+		if len(i.ApplicationCommandData().Options) > 0 {
+			opt := i.ApplicationCommandData().Options[0]
+			if opt.Name == "user" {
+				user = opt.UserValue(s)
+			}
+		}
+
+		totalSeconds := db_management.GetUserStats(user.ID)
 		duration := time.Duration(totalSeconds) * time.Second
 
-		msg := fmt.Sprintf("📊 **30-Tage Statistik für %s**\nVerbrachte Zeit: `%s`",
+		name := user.GlobalName
-			m.Author.GlobalName, formatDuration(duration))
+		if name == "" {
-		s.ChannelMessageSend(m.ChannelID, msg)
+			name = user.Username
+		}
+
+		msg := fmt.Sprintf(
+			"📊 **30-Tage Statistik für %s**\nZeit: `%s`",
+			name,
+			formatDuration(duration),
+		)
+
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: msg,
+			},
+		})
+
+	// =====================
+	// /top
+	// =====================
+	case "top":
+
+		topUsers := db_management.GetTopUsers(10)
+
+		if len(topUsers) == 0 {
+			s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Content: "Keine Daten vorhanden.",
+				},
+			})
+			return
+		}
+
+		msg := "🏆 **Top 10 (30 Tage)**\n\n"
+
+		for i, user := range topUsers {
+			duration := time.Duration(user.Seconds) * time.Second
+
+			msg += fmt.Sprintf(
+				"**%d.** <@%s> — `%s`\n",
+				i+1,
+				user.UserID,
+				formatDuration(duration),
+			)
+		}
+
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: msg,
+			},
+		})
 	}
 }
 
+const excludedChannelID = "1232031563391172649"
+
 func voiceUpdate(s *discordgo.Session, v *discordgo.VoiceStateUpdate) {
+
 	uid := v.UserID
 
-	// User betritt Sprachkanal
+	// =========================
-	if v.ChannelID != "" {
+	// ❌ Pause Bedingungen
-		if _, ok := startTimes[uid]; !ok {
+	// =========================
-			startTimes[uid] = time.Now()
+	if v.ChannelID == excludedChannelID || v.SelfMute || v.Mute || v.SelfDeaf || v.Deaf {
+
+		if sess, ok := sessions[uid]; ok && !sess.Paused {
+
+			now := time.Now()
+			elapsed := now.Sub(sess.Start)
+
+			sess.Accum += elapsed
+			sess.PausedAt = &now
+			sess.Paused = true
 		}
 		return
 	}
 
-	// User verlässt Sprachkanal (v.ChannelID == "")
+	// =========================
-	if v.ChannelID == "" {
+	// ▶ Resume (User wieder aktiv)
-		if start, ok := startTimes[uid]; ok {
+	// =========================
-			db_management.SaveSession(uid, int(time.Since(start).Seconds()))
+	if v.ChannelID != "" {
-			delete(startTimes, uid)
+
+		sess, ok := sessions[uid]
+
+		if !ok {
+			// neue Session
+			sessions[uid] = &Session{
+				Start:  time.Now(),
+				Paused: false,
+			}
+			return
 		}
+
+		// wenn pausiert → weiterlaufen lassen
+		if sess.Paused {
+			sess.Start = time.Now()
+			sess.Paused = false
+			sess.PausedAt = nil
+		}
+
+		return
+	}
+
+	// =========================
+	// ❌ User verlässt Voice
+	// =========================
+	if sess, ok := sessions[uid]; ok {
+
+		total := sess.Accum
+
+		if !sess.Paused {
+			total += time.Since(sess.Start)
+		}
+
+		db_management.SaveSession(uid, int(total.Seconds()))
+		delete(sessions, uid)
 	}
 }
-
 func formatDuration(d time.Duration) string {
 	h := int(d.Hours())
 	m := int(d.Minutes()) % 60
 	s := int(d.Seconds()) % 60
 	return fmt.Sprintf("%dh %dm %ds", h, m, s)
 }
+
+func autoSaveSessions() {
+	ticker := time.NewTicker(5 * time.Minute)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		fmt.Println("Auto-Save")
+
+		for uid, sess := range sessions {
+			processAndSave(uid, sess)
+		}
+	}
+}
+
+// Hilfsfunktion, die die Zeit berechnet, speichert und den Timer resettet
+func processAndSave(uid string, sess *Session) {
+	var totalToSave time.Duration
+
+	totalToSave += sess.Accum
+
+	if !sess.Paused {
+		totalToSave += time.Since(sess.Start)
+	}
+
+	if totalToSave.Seconds() >= 1 {
+		db_management.SaveSession(uid, int(totalToSave.Seconds()))
+
+		sess.Accum = 0
+		if !sess.Paused {
+			sess.Start = time.Now()
+		}
+	}
+}