Implement KeepUpdated. Switch to Logrus logger. Relocate score-related functions.

.idea/runConfigurations/Redis.xml

@@ -3,7 +3,7 @@
     <deployment type="docker-image">
       <settings>
         <option name="imageTag" value="redis:alpine" />
-        <option name="command" value="redis-server --save 5 1 --loglevel warning" />
+        <option name="command" value="redis-server --save 5 1 --loglevel warning --notify-keyspace-events Ex" />
         <option name="containerName" value="redis-isc" />
         <option name="portBindings">
           <list>

auth.go

@@ -3,13 +3,13 @@ package main
 import (
 	"InfantrySkillCalculator/controllers"
 	"InfantrySkillCalculator/models"
+	"InfantrySkillCalculator/utils"
 	"errors"
 	"fmt"
 	"github.com/gin-gonic/gin"
 	"golang.org/x/crypto/bcrypt"
 	"gorm.io/gorm"
 	"internal/session"
-	"log"
 	"net/http"
 )
 
@@ -30,7 +30,7 @@ func getUserPassword(username string) (string, error) {
 
 	if err := models.DB.Where("username = ?", username).First(&user).Error; err != nil {
 		if !errors.Is(err, gorm.ErrRecordNotFound) {
-			log.Fatal(err)
+			utils.Logger.Fatal(err)
 		}
 		return "", err
 	}
@@ -90,7 +90,7 @@ func AdminAuthRequired() gin.HandlerFunc {
 
 func redirectToLogin(c *gin.Context) {
 	if err := session.InvalidateSession(c); err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	}
 	c.Redirect(http.StatusFound, "/login")
 	c.Abort()

controllers/cache_controller.go

@@ -3,9 +3,7 @@ package controllers
 import (
 	"InfantrySkillCalculator/models"
 	"InfantrySkillCalculator/utils"
-	"fmt"
 	"github.com/gin-gonic/gin"
-	"log"
 	"net/http"
 )
 
@@ -95,61 +93,33 @@ func DeleteAllCaches(c *gin.Context) {
 	}
 }
 
-// GetScoreByPlayerID GET /score/:player_id
+func UpdateCacheAfterExpiry(key string) {
-func GetScoreByPlayerID(c *gin.Context) {
+	utils.Logger.Println("[KeepUpdated] Cache expired: " + key)
-	var player models.Player
-	var playerId = utils.StringToUint(c.Param("player_id"))
 
+	playerId, err := models.PlayerCache.GetPlayerIdFromCacheKey(key)
+	if err != nil {
+		utils.Logger.Fatal(err)
+	}
+
+	var player models.Player
 	if err := models.DB.
-		Model(&models.Player{}).
+		Preload("Clan").
 		Where("id = ?", playerId).
 		First(&player).Error; err != nil {
 
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Player not found!"})
+		utils.Logger.Println("Failed to find player: " + err.Error())
-		return
 	}
 
-	game, err := GetActiveGame(c)
+	if player.Clan.KeepUpdated {
-	if err != nil {
+		score := CalcPlayerScore(player.Name, "BF2042")
-		c.JSON(http.StatusBadRequest, gin.H{"error": "No active game available!"})
-		return
-	}
-
-	score, err := models.PlayerCache.GetScore(player.ID, game.Tag)
-	if err != nil || score == -1 {
-		score = utils.CalcPlayerScore(player.Name, game.Tag)
 		if score == score && score != -1 { // not NaN
-			if err := models.PlayerCache.SetScore(player.ID, game.Tag, score); err != nil {
+			if err := models.PlayerCache.SetScore(player.ID, "BF2042", score); err != nil {
-				log.Fatal(err)
+				utils.Logger.Println("Failed to update cache: " + err.Error())
-			}
-		}
-	}
-
-	if score != score || score == -1 { // NaN
-		c.String(http.StatusOK, "<i class=\"bi bi-person-x-fill me-2 text-danger fs-5\" style=\"margin-left: 0.69rem;\"></i>")
-	} else if score != -1 {
-		c.String(http.StatusOK, fmt.Sprintf("%.2f", score))
 			} else {
-		c.JSON(http.StatusBadRequest, "Invalid request!")
+				utils.Logger.Println("[KeepUpdated] Updated cache for player " + player.Name)
-	}
+			}
-}
+		} else {
-
+			utils.Logger.Println("[KeepUpdated] Received NaN for player " + player.Name)
-// GetScoreByPlayerName POST /score/:player_name
+		}
-func GetScoreByPlayerName(c *gin.Context) {
-	playerName := c.Param("player_name")
-	game, err := GetActiveGame(c)
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "No active game available!"})
-		return
-	}
-
-	score := utils.CalcPlayerScore(playerName, game.Tag)
-
-	if score != score || score == -1 { // NaN
-		c.String(http.StatusNotFound, "Spieler nicht gefunden!")
-	} else if score != -1 {
-		c.String(http.StatusOK, fmt.Sprintf("%.2f", score))
-	} else {
-		c.String(http.StatusBadRequest, "Ungültige Abfrage!")
 	}
 }

controllers/clan_controller.go

@@ -7,7 +7,6 @@ import (
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
-	"log"
 	"net/http"
 )
 
@@ -68,10 +67,7 @@ func AddClan(c *gin.Context) {
 
 	c.JSON(http.StatusOK, clan)
 
-	_, err := fmt.Fprintf(utils.GinWriter, "Added clan '"+clan.Name+"' with tag '"+clan.Tag+"'\n")
+	utils.Logger.Infof("Added clan '%s' with tag '%s'", clan.Name, clan.Tag)
-	if err != nil {
-		log.Fatal(err)
-	}
 }
 
 // GetClanByID GET /clan/:id
@@ -108,10 +104,7 @@ func UpdateClanByID(c *gin.Context) {
 
 	c.JSON(http.StatusOK, nil)
 
-	_, err := fmt.Fprintf(utils.GinWriter, "Updated clan '"+input.Name+"' with tag '"+input.Tag+"'\n")
+	utils.Logger.Infof("Updated clan '%s' with tag '%s'", input.Name, input.Tag)
-	if err != nil {
-		log.Fatal(err)
-	}
 }
 
 // DeleteClanByID DELETE /clan/:id
@@ -126,10 +119,7 @@ func DeleteClanByID(c *gin.Context) {
 
 	c.JSON(http.StatusOK, true)
 
-	_, err := fmt.Fprintf(utils.GinWriter, "Deleted clan '"+clan.Name+"' with tag '"+clan.Tag+"'\n")
+	utils.Logger.Infof("Deleted clan '%s' with tag '%s'", clan.Name, clan.Tag)
-	if err != nil {
-		log.Fatal(err)
-	}
 }
 
 // DeleteAllClans DELETE /admin/clan

controllers/metrics_controller.go

@@ -5,14 +5,15 @@ import (
 	"InfantrySkillCalculator/utils"
 	"encoding/json"
 	"io"
-	"log"
 	"os"
 )
 
+var gameMetrics models.GameMetrics
+
 func LoadMetrics() {
 	f, err := os.Open("./config/metrics.json")
 	if err != nil {
-		log.Fatal("Failed to open metrics.json: ", err)
+		utils.Logger.Fatal("Failed to open metrics.json: ", err)
 	}
 	defer func(f *os.File) {
 		_ = f.Close()
@@ -20,13 +21,31 @@ func LoadMetrics() {
 
 	data, err := io.ReadAll(f)
 	if err != nil {
-		log.Fatal("Failed to read metrics.json: ", err)
+		utils.Logger.Fatal("Failed to read metrics.json: ", err)
 	}
 
 	var metrics models.GameMetrics
 	if err := json.Unmarshal(data, &metrics); err != nil {
-		log.Fatal("Failed to deserialize metrics.json: ", err)
+		utils.Logger.Fatal("Failed to deserialize metrics.json: ", err)
 	}
 
-	utils.GameMetrics = metrics
+	gameMetrics = metrics
+}
+
+func GetGameMetric(gameTag string) *models.GameMetric {
+	for _, metric := range gameMetrics.GameMetrics {
+		if metric.GameName == gameTag {
+			return &metric
+		}
+	}
+	return nil
+}
+
+func FindWeaponMetric(weaponMetrics []models.WeaponMetric, weaponCategory string) *models.WeaponMetric {
+	for _, metric := range weaponMetrics {
+		if metric.WeaponCategory == weaponCategory {
+			return &metric
+		}
+	}
+	return nil
 }

controllers/player_controller.go

@@ -8,7 +8,6 @@ import (
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 	"html/template"
-	"log"
 	"net/http"
 )
 
@@ -39,14 +38,14 @@ func GetPlayersByClanHTML(c *gin.Context) {
 		Find(&players).Error; err != nil {
 
 		c.String(http.StatusBadRequest, "")
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 		return
 	}
 
 	game, err := GetActiveGame(c)
 	if err != nil {
 		c.String(http.StatusBadRequest, "")
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 		return
 	}
 
@@ -58,7 +57,7 @@ func GetPlayersByClanHTML(c *gin.Context) {
 	scores, err := models.PlayerCache.GetScores(playerIDs, game.Tag)
 	if err != nil {
 		c.String(http.StatusBadRequest, "")
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	}
 
 	userRole := GetUserRoleByCtx(c)
@@ -84,7 +83,7 @@ func GetPlayersByClanHTML(c *gin.Context) {
 
 	err = utils.PlayerItemTemplate.Execute(c.Writer, data)
 	if err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	}
 }
 
@@ -107,10 +106,7 @@ func AddPlayer(c *gin.Context) {
 
 	c.JSON(http.StatusOK, player)
 
-	_, err := fmt.Fprintf(utils.GinWriter, "Added player '"+player.Name+"'\n")
+	utils.Logger.Infof("Added player '%s'", input.Name)
-	if err != nil {
-		log.Fatal(err)
-	}
 }
 
 // GetPlayerByID GET /player/:id
@@ -157,10 +153,7 @@ func UpdatePlayerByID(c *gin.Context) {
 
 	c.JSON(http.StatusOK, nil)
 
-	_, err := fmt.Fprintf(utils.GinWriter, "Updated player '"+input.Name+"'\n")
+	utils.Logger.Infof("Updated player '%s'", input.Name)
-	if err != nil {
-		log.Fatal(err)
-	}
 }
 
 // DeletePlayerByID DELETE /player/:id
@@ -175,10 +168,7 @@ func DeletePlayerByID(c *gin.Context) {
 
 	c.JSON(http.StatusOK, true)
 
-	_, err := fmt.Fprintf(utils.GinWriter, "Deleted player '"+player.Name+"'\n")
+	utils.Logger.Infof("Deleted player '%s'", player.Name)
-	if err != nil {
-		log.Fatal(err)
-	}
 }
 
 // DeleteAllPlayers DELETE /admin/player

controllers/score_controller.go

@@ -0,0 +1,171 @@
+package controllers
+
+import (
+	"InfantrySkillCalculator/models"
+	"InfantrySkillCalculator/utils"
+	"encoding/json"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"io"
+	"math"
+	"net/http"
+	"sort"
+)
+
+// GetScoreByPlayerID GET /score/:player_id
+func GetScoreByPlayerID(c *gin.Context) {
+	var player models.Player
+	var playerId = utils.StringToUint(c.Param("player_id"))
+
+	if err := models.DB.
+		Model(&models.Player{}).
+		Where("id = ?", playerId).
+		First(&player).Error; err != nil {
+
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Player not found!"})
+		return
+	}
+
+	game, err := GetActiveGame(c)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "No active game available!"})
+		return
+	}
+
+	score, err := models.PlayerCache.GetScore(player.ID, game.Tag)
+	if err != nil || score == -1 {
+		score = CalcPlayerScore(player.Name, game.Tag)
+		if score == score && score != -1 { // not NaN
+			if err := models.PlayerCache.SetScore(player.ID, game.Tag, score); err != nil {
+				utils.Logger.Fatal(err)
+			}
+		}
+	}
+
+	if score != score || score == -1 { // NaN
+		c.String(http.StatusOK, "<i class=\"bi bi-person-x-fill me-2 text-danger fs-5\" style=\"margin-left: 0.69rem;\"></i>")
+	} else if score != -1 {
+		c.String(http.StatusOK, fmt.Sprintf("%.2f", score))
+	} else {
+		c.JSON(http.StatusBadRequest, "Invalid request!")
+	}
+}
+
+// GetScoreByPlayerName POST /score/:player_name
+func GetScoreByPlayerName(c *gin.Context) {
+	playerName := c.Param("player_name")
+	game, err := GetActiveGame(c)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "No active game available!"})
+		return
+	}
+
+	score := CalcPlayerScore(playerName, game.Tag)
+
+	if score != score || score == -1 { // NaN
+		c.String(http.StatusNotFound, "Spieler nicht gefunden!")
+	} else if score != -1 {
+		c.String(http.StatusOK, fmt.Sprintf("%.2f", score))
+	} else {
+		c.String(http.StatusBadRequest, "Ungültige Abfrage!")
+	}
+}
+
+func CalcPlayerScore(playerName string, gameTag string) float32 {
+	if gameTag != "BF5" && gameTag != "BF2042" {
+		utils.Logger.Errorf("Invalid game tag '%s'", gameTag)
+		return -1
+	}
+
+	gameMetrics := GetGameMetric(gameTag)
+	if gameMetrics == nil {
+		utils.Logger.Errorf("No game metrics specified for '%s'", gameTag)
+		return -1
+	}
+
+	normalizeFactor := gameMetrics.NormalizeFactor
+	topWeaponCount := gameMetrics.TopWeaponCount
+
+	c := http.Client{}
+
+	var reqUri string
+	if gameTag == "BF5" {
+		reqUri = "https://api.gametools.network/bfv/weapons/?raw=false&format_values=false&name=" + playerName + "&platform=pc"
+	} else if gameTag == "BF2042" {
+		reqUri = "https://api.gametools.network/bf2042/stats/?raw=false&format_values=false&name=" + playerName + "&platform=pc"
+	}
+
+	req, err := http.NewRequest("GET", reqUri, nil)
+	if err != nil {
+		utils.Logger.Errorf("Failed to create request: %s", err)
+		return -1
+	}
+
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36")
+
+	res, err := c.Do(req)
+	if err != nil {
+		utils.Logger.Errorf("Failed to send request: %s", err)
+		return -1
+	}
+
+	defer func(Body io.ReadCloser) {
+		_ = Body.Close()
+	}(res.Body)
+	if res.StatusCode == 404 {
+		utils.Logger.Errorf("User '%s' does not exist!", playerName)
+		return -1
+	} else if res.StatusCode != 200 {
+		utils.Logger.Fatalf("Status code error: %d %s", res.StatusCode, res.Status)
+	}
+
+	var data models.TrackerWeaponJSON
+	var body, _ = io.ReadAll(res.Body)
+	if err := json.Unmarshal(body, &data); err != nil {
+		utils.Logger.Fatalf("Failed to deserialize tracker API response: %s", err)
+	}
+
+	sort.SliceStable(data.Weapons, func(i, j int) bool { return data.Weapons[i].Kills > data.Weapons[j].Kills })
+	var top []models.Weapon
+
+	for _, weapon := range data.Weapons {
+		if len(top) >= topWeaponCount {
+			break
+		}
+		if gameTag == "BF2042" && weapon.Kills < 100 {
+			break
+		}
+
+		acc := (float64(weapon.ShotsHit) / float64(weapon.ShotsFired)) * 100
+		kpm := weapon.KPM
+
+		weaponMetrics := FindWeaponMetric(gameMetrics.WeaponMetrics, weapon.Type)
+		if weaponMetrics == nil {
+			utils.Logger.Error("No weapon metrics specified for '" + gameTag + "', WType '" + weapon.Type + "'! Skipping...")
+			continue
+		}
+
+		accFactor := weaponMetrics.AccuracyFactor
+		kpmFactor := weaponMetrics.KpmFactor
+
+		acc /= accFactor
+		kpm /= kpmFactor
+		weapon.Accuracy = acc
+		weapon.KPM = kpm
+
+		top = append(top, weapon)
+	}
+
+	sumAcc := 0.0
+	sumKpm := 0.0
+
+	for _, w := range top {
+		sumAcc += w.Accuracy
+		sumKpm += w.KPM
+	}
+	accAvg := sumAcc / float64(len(top))
+	kpmAvg := sumKpm / float64(len(top))
+	score := math.Round(((accAvg*kpmAvg)/normalizeFactor)*100) / 100
+
+	return float32(score)
+}

controllers/user_controller.go

@@ -2,8 +2,8 @@ package controllers
 
 import (
 	"InfantrySkillCalculator/models"
+	"InfantrySkillCalculator/utils"
 	"github.com/gin-gonic/gin"
-	"log"
 	"session"
 )
 
@@ -11,7 +11,7 @@ func CreateUser(username string, hashedPassword string, enabled bool, usedCode s
 	user := models.User{Username: username, Password: hashedPassword, Enabled: enabled}
 	err := models.DB.Create(&user).Error
 	if err != nil {
-		log.Fatalf("Error while creating user: %v", err)
+		utils.Logger.Fatalf("Error while creating user: %v", err)
 	}
 
 	var code models.ActivationCode
@@ -20,19 +20,19 @@ func CreateUser(username string, hashedPassword string, enabled bool, usedCode s
 		Where("code = ?", usedCode).
 		First(&code).Error
 	if err != nil {
-		log.Fatalf("Error while getting activation code: %v", err)
+		utils.Logger.Fatalf("Error while getting activation code: %v", err)
 	}
 
 	code.UsedForUsername = username
 	err = models.DB.Save(&code).Error
 	if err != nil {
-		log.Fatalf("Error while updating activation code: %v", err)
+		utils.Logger.Fatalf("Error while updating activation code: %v", err)
 	}
 
 	user.UserRole = code.UserRole
 	err = models.DB.Save(&user).Error
 	if err != nil {
-		log.Fatalf("Error while updating user role: %v", err)
+		utils.Logger.Fatalf("Error while updating user role: %v", err)
 	}
 
 	var bf2042 models.Game
@@ -40,7 +40,7 @@ func CreateUser(username string, hashedPassword string, enabled bool, usedCode s
 		Where("tag = ?", "BF2042").
 		First(&bf2042).Error
 	if err != nil {
-		log.Fatalf("Error while getting game: %v", err)
+		utils.Logger.Fatalf("Error while getting game: %v", err)
 	}
 	userSettings := models.UserSettings{
 		Username:     username,
@@ -62,7 +62,7 @@ func GetUserRole(username string) models.Role {
 	var user models.User
 	err := models.DB.Where("username = ?", username).First(&user).Error
 	if err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	}
 	return user.UserRole
 }
@@ -79,7 +79,7 @@ func IsUserAdmin(username string) bool {
 	var user models.User
 	err := models.DB.Where("username = ?", username).First(&user).Error
 	if err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 		return false
 	}
 	return user.UserRole == models.AdminRole

go.mod

@@ -41,6 +41,7 @@ require (
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/sirupsen/logrus v1.9.3 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.11 // indirect
 	golang.org/x/arch v0.3.0 // indirect

go.sum

@@ -68,6 +68,8 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 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/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -91,6 +93,7 @@ golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0
 golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
 golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
 golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
 golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

internal/cache/cache.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/redis/go-redis/v9"
+	"log"
 	"strconv"
 	"time"
 )
@@ -14,10 +15,12 @@ var ctx = context.Background()
 type PlayerCache struct {
 	cache          *redis.Client
 	lifetime       time.Duration
+	expireSub      *redis.PubSub
+	expireCallback func(key string)
 }
 
-func NewPlayerCache(address string, lifetime time.Duration) *PlayerCache {
+func NewPlayerCache(address string, lifetime time.Duration, expireCallback func(key string)) *PlayerCache {
-	return &PlayerCache{
+	pc := &PlayerCache{
 		redis.NewClient(
 			&redis.Options{
 				Addr:     address,
@@ -25,7 +28,23 @@ func NewPlayerCache(address string, lifetime time.Duration) *PlayerCache {
 				DB:       0,
 			}),
 		lifetime,
+		nil,
+		expireCallback,
 	}
+	pc.expireSub = pc.cache.PSubscribe(ctx, "__keyevent@0__:expired")
+
+	go func() {
+		for {
+			msg, err := pc.expireSub.ReceiveMessage(ctx)
+			if err != nil {
+				log.Fatal(err)
+			} else {
+				pc.expireCallback(msg.Payload)
+			}
+		}
+	}()
+
+	return pc
 }
 
 func (pc *PlayerCache) Connect() error {
@@ -42,13 +61,13 @@ func (pc *PlayerCache) GetValue(key string) (string, error) {
 	}
 }
 
-func (pc *PlayerCache) SetValue(key string, value interface{}) error {
+func (pc *PlayerCache) SetValue(key string, value interface{}, lifetime time.Duration) error {
-	return pc.cache.Set(ctx, key, value, pc.lifetime).Err()
+	return pc.cache.Set(ctx, key, value, lifetime).Err()
 }
 
 func (pc *PlayerCache) SetScore(playerId uint, gameTag string, score float32) error {
 	key := getPlayerCacheKey(playerId, gameTag)
-	return pc.SetValue(key, score)
+	return pc.SetValue(key, score, pc.lifetime)
 }
 
 func (pc *PlayerCache) GetScore(playerId uint, gameTag string) (float32, error) {
@@ -104,3 +123,9 @@ func (pc *PlayerCache) PurgeCache() error {
 func getPlayerCacheKey(playerId uint, gameTag string) string {
 	return fmt.Sprintf("player:%d:game:%s", playerId, gameTag)
 }
+
+func (pc *PlayerCache) GetPlayerIdFromCacheKey(key string) (uint, error) {
+	var playerId uint
+	_, err := fmt.Sscanf(key, "player:%d:game:", &playerId)
+	return playerId, err
+}

main.go

@@ -6,13 +6,26 @@ import (
 	"InfantrySkillCalculator/utils"
 	"github.com/gin-gonic/gin"
 	_ "github.com/gorilla/sessions"
+	"github.com/sirupsen/logrus"
 	"html/template"
 	"io"
-	"log"
 	"os"
+	"session"
+	"strings"
+	"time"
 )
 
 func init() {
+	f, _ := os.OpenFile("isc_rest.log", os.O_RDWR|os.O_APPEND|os.O_CREATE, 0660)
+	ginWriter := io.MultiWriter(f, os.Stdout)
+	logger := logrus.New()
+	logger.SetOutput(ginWriter)
+	logger.SetFormatter(&logrus.TextFormatter{
+		ForceColors:   true,
+		FullTimestamp: true,
+	})
+	utils.Logger = logger
+
 	var err error
 	utils.MainPageTemplates, err = template.ParseFiles(
 		"./templates/index.html",
@@ -27,12 +40,12 @@ func init() {
 		"./templates/modals/add_player.html",
 		"./templates/modals/delete_player.html",
 		"./templates/modals/edit_player.html",
-		"./templates/modals/settings.html",
+		//"./templates/modals/settings.html",
 		"./templates/modals/full_calc.html",
 		"./templates/components/header.html",
 	)
 	if err != nil {
-		log.Fatal(err)
+		logger.Fatal(err)
 	}
 
 	utils.LoginPageTemplates, err = template.ParseFiles(
@@ -40,7 +53,7 @@ func init() {
 		"./templates/components/header.html",
 	)
 	if err != nil {
-		log.Fatal(err)
+		logger.Fatal(err)
 	}
 
 	utils.RegisterPageTemplates, err = template.ParseFiles(
@@ -48,19 +61,48 @@ func init() {
 		"./templates/components/header.html",
 	)
 	if err != nil {
-		log.Fatal(err)
+		logger.Fatal(err)
 	}
 
 	utils.PlayerItemTemplate, err = template.ParseFiles(
 		"./templates/shards/player_list_item.html",
 	)
 	if err != nil {
-		log.Fatal(err)
+		logger.Fatal(err)
 	}
 
 	controllers.LoadMetrics()
 }
 
+func customLogrusLogger(logger *logrus.Logger) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		start := time.Now()
+
+		c.Next()
+
+		elapsed := time.Since(start)
+
+		if c.Request.URL.Path == "/static" || c.Request.URL.Path == "/favicon.ico" ||
+			strings.Contains(c.Request.URL.Path, "_html") {
+			return
+		}
+
+		username, exists := session.GetUsername(c)
+		if !exists {
+			username = "Anonymous"
+		}
+
+		logger.Infof("[GIN] %3d | %10v | %15s | %15s | %-7s | %s",
+			c.Writer.Status(),
+			elapsed,
+			c.ClientIP(),
+			username,
+			c.Request.Method,
+			c.Request.RequestURI,
+		)
+	}
+}
+
 func main() {
 	if os.Getenv("GO_ENV") == "production" {
 		gin.SetMode(gin.ReleaseMode)
@@ -69,7 +111,7 @@ func main() {
 	router := gin.New()
 	err := router.SetTrustedProxies([]string{"127.0.0.1"})
 	if err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	}
 	router.LoadHTMLGlob("templates/**/*")
 	reader := router.Group("/")
@@ -80,37 +122,26 @@ func main() {
 	admin.Use(AdminAuthRequired())
 
 	models.ConnectDatabase()
-	models.ConnectCache(utils.PlayerCacheLifetime)
+	models.ConnectCache(utils.PlayerCacheLifetime, controllers.UpdateCacheAfterExpiry)
 
 	var code models.ActivationCode
 	if err := models.DB.First(&code).Error; err != nil {
 		firstCode := utils.GenerateActivationCode()
 		models.DB.Create(&models.ActivationCode{Code: firstCode, UserRole: models.AdminRole})
-		log.Println("Created first activation code with ADMIN role:\n" + firstCode)
+		utils.Logger.Println("Created first activation code with ADMIN role:\n" + firstCode)
 	}
 
 	router.Static("/static", "./static")
-	router.Static("/node_modules", "./node_modules")
 
-	f, _ := os.OpenFile("isc_rest.log", os.O_RDWR|os.O_APPEND|os.O_CREATE, 0660)
+	middlewares := []gin.HandlerFunc{
-	utils.GinWriter = io.MultiWriter(f, os.Stdout)
+		customLogrusLogger(utils.Logger),
-	logger := gin.LoggerWithWriter(utils.GinWriter, "/static/", "/node_modules/", "/favicon.ico")
-	router.Use(
-		logger,
 		gin.Recovery(),
-	)
+	}
-	reader.Use(
+
-		logger,
+	router.Use(middlewares...)
-		gin.Recovery(),
+	reader.Use(middlewares...)
-	)
+	author.Use(middlewares...)
-	author.Use(
+	admin.Use(middlewares...)
-		logger,
-		gin.Recovery(),
-	)
-	admin.Use(
-		logger,
-		gin.Recovery(),
-	)
 
 	router.GET("/login", loginPage)
 	router.POST("/login", loginPost)
@@ -151,6 +182,6 @@ func main() {
 	admin.DELETE("/purge_clans", controllers.DeleteAllClans)
 	admin.POST("/create_code", controllers.CreateCode)
 
-	log.Println("Running on 8000...")
+	utils.Logger.Println("Running on 8000...")
-	log.Fatal(router.Run(":8000"))
+	utils.Logger.Fatal(router.Run(":8000"))
 }

models/setup.go

@@ -1,11 +1,11 @@
 package models
 
 import (
+	"InfantrySkillCalculator/utils"
 	"cache"
 	"github.com/glebarez/sqlite"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
-	"log"
 	"os"
 	"time"
 )
@@ -26,49 +26,49 @@ func ConnectDatabase() {
 
 	err = database.AutoMigrate(&Clan{})
 	if err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	}
 	err = database.AutoMigrate(&Player{})
 	if err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	}
 	err = database.AutoMigrate(&User{})
 	if err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	}
 	err = database.AutoMigrate(&ActivationCode{})
 	if err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	}
 	err = database.AutoMigrate(&Game{})
 	if err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	} else {
 		var game Game
 		if err := database.First(&game).Error; err != nil {
 			database.Create(&Game{Name: "Battlefield V", Tag: "BFV"})
 			database.Create(&Game{Name: "Battlefield 2042", Tag: "BF2042"})
-			log.Println("Created first games")
+			utils.Logger.Println("Created first games")
 		}
 	}
 
 	err = database.AutoMigrate(&UserSettings{})
 	if err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	}
 
 	DB = database
 }
 
-func ConnectCache(playerCacheLifetime time.Duration) {
+func ConnectCache(playerCacheLifetime time.Duration, expireCallback func(key string)) {
 	address := os.Getenv("REDIS_ADDRESS")
 	if address == "" {
 		address = "127.0.0.1:6379"
 	}
 
-	PlayerCache = cache.NewPlayerCache(address, playerCacheLifetime)
+	PlayerCache = cache.NewPlayerCache(address, playerCacheLifetime, expireCallback)
 	if err := PlayerCache.Connect(); err != nil {
 		PlayerCache = nil
-		log.Fatal("Failed to connect to Redis! " + err.Error())
+		utils.Logger.Fatal("Failed to connect to Redis! " + err.Error())
 	}
 }

pages.go

@@ -4,7 +4,6 @@ import (
 	"InfantrySkillCalculator/controllers"
 	"InfantrySkillCalculator/utils"
 	"github.com/gin-gonic/gin"
-	"log"
 	"net/http"
 	"session"
 )
@@ -22,7 +21,7 @@ func mainPage(c *gin.Context) {
 
 	err := utils.MainPageTemplates.Execute(c.Writer, data)
 	if err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	}
 }
 
@@ -34,7 +33,7 @@ func loginPage(c *gin.Context) {
 
 	err := utils.LoginPageTemplates.Execute(c.Writer, nil)
 	if err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	}
 }
 
@@ -73,7 +72,7 @@ func registerPage(c *gin.Context) {
 
 	err := utils.RegisterPageTemplates.Execute(c.Writer, nil)
 	if err != nil {
-		log.Fatal(err)
+		utils.Logger.Fatal(err)
 	}
 }
 

utils/globals.go

@@ -1,14 +1,12 @@
 package utils
 
 import (
-	"InfantrySkillCalculator/models"
+	"github.com/sirupsen/logrus"
 	"html/template"
-	"io"
 	"time"
 )
 
-var GinWriter io.Writer = nil
+var Logger *logrus.Logger
-var GameMetrics models.GameMetrics
 var PlayerCacheLifetime = 24 * time.Hour
 
 var MainPageTemplates *template.Template

utils/score.go

@@ -1,129 +0,0 @@
-package utils
-
-import (
-	"InfantrySkillCalculator/models"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"math"
-	"net/http"
-	"sort"
-)
-
-func GetGameMetric(gameTag string) *models.GameMetric {
-	for _, metric := range GameMetrics.GameMetrics {
-		if metric.GameName == gameTag {
-			return &metric
-		}
-	}
-	return nil
-}
-
-func FindWeaponMetric(weaponMetrics []models.WeaponMetric, weaponCategory string) *models.WeaponMetric {
-	for _, metric := range weaponMetrics {
-		if metric.WeaponCategory == weaponCategory {
-			return &metric
-		}
-	}
-	return nil
-}
-
-func CalcPlayerScore(playerName string, gameTag string) float32 {
-	if gameTag != "BF5" && gameTag != "BF2042" {
-		_, _ = fmt.Fprintf(GinWriter, "UNSUPPORTED GAME: "+gameTag+"\n")
-		return -1
-	}
-
-	gameMetrics := GetGameMetric(gameTag)
-	if gameMetrics == nil {
-		_, _ = fmt.Fprintf(GinWriter, "No game metrics specified for '"+gameTag+"'\n")
-		return -1
-	}
-
-	normalizeFactor := gameMetrics.NormalizeFactor
-	topWeaponCount := gameMetrics.TopWeaponCount
-
-	c := http.Client{}
-
-	var reqUri string
-	if gameTag == "BF5" {
-		reqUri = "https://api.gametools.network/bfv/weapons/?raw=false&format_values=false&name=" + playerName + "&platform=pc"
-	} else if gameTag == "BF2042" {
-		reqUri = "https://api.gametools.network/bf2042/stats/?raw=false&format_values=false&name=" + playerName + "&platform=pc"
-	}
-
-	req, err := http.NewRequest("GET", reqUri, nil)
-	if err != nil {
-		_, _ = fmt.Fprintf(GinWriter, err.Error()+"\n")
-		return -1
-	}
-
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36")
-
-	res, err := c.Do(req)
-	if err != nil {
-		_, _ = fmt.Fprintf(GinWriter, err.Error()+"\n")
-		return -1
-	}
-
-	defer func(Body io.ReadCloser) {
-		_ = Body.Close()
-	}(res.Body)
-	if res.StatusCode == 404 {
-		_, _ = fmt.Fprintf(GinWriter, "User '"+playerName+"' does not exist!\n")
-		return -1
-	} else if res.StatusCode != 200 {
-		log.Fatalf("Status code error: %d %s", res.StatusCode, res.Status)
-	}
-
-	var data models.TrackerWeaponJSON
-	var body, _ = io.ReadAll(res.Body)
-	if err := json.Unmarshal(body, &data); err != nil {
-		log.Fatalf("Failed to deserialize tracker API response: %s", err)
-	}
-
-	sort.SliceStable(data.Weapons, func(i, j int) bool { return data.Weapons[i].Kills > data.Weapons[j].Kills })
-	var top []models.Weapon
-
-	for _, weapon := range data.Weapons {
-		if len(top) >= topWeaponCount {
-			break
-		}
-		if gameTag == "BF2042" && weapon.Kills < 100 {
-			break
-		}
-
-		acc := (float64(weapon.ShotsHit) / float64(weapon.ShotsFired)) * 100
-		kpm := weapon.KPM
-
-		weaponMetrics := FindWeaponMetric(gameMetrics.WeaponMetrics, weapon.Type)
-		if weaponMetrics == nil {
-			_, _ = fmt.Fprintf(GinWriter, "No weapon metrics specified for '"+gameTag+"', WType '"+weapon.Type+"'\n")
-			continue
-		}
-
-		accFactor := weaponMetrics.AccuracyFactor
-		kpmFactor := weaponMetrics.KpmFactor
-
-		acc /= accFactor
-		kpm /= kpmFactor
-		weapon.Accuracy = acc
-		weapon.KPM = kpm
-
-		top = append(top, weapon)
-	}
-
-	sumAcc := 0.0
-	sumKpm := 0.0
-
-	for _, w := range top {
-		sumAcc += w.Accuracy
-		sumKpm += w.KPM
-	}
-	accAvg := sumAcc / float64(len(top))
-	kpmAvg := sumKpm / float64(len(top))
-	score := math.Round(((accAvg*kpmAvg)/normalizeFactor)*100) / 100
-
-	return float32(score)
-}