Merge branch 'match_type_leaderboard' into develop

thordy · thordy · commit 60beecb9d0fc · 2025-04-06T09:40:57.000+02:00
diff --git a/cmd/oneseventy.go b/cmd/oneseventy.go
diff --git a/cmd/recalculate_badge.go b/cmd/recalculate_badge.go
@@ -11,6 +11,7 @@ var recalculateBadgeCmd = &cobra.Command{
 	Short: "Recalculate badge",
 	Long:  `Recalculate badges earned by each player`,
 	PersistentPreRun: func(cmd *cobra.Command, args []string) {
+		SetupConfig(cmd)
 		models.InitDB(models.GetMysqlConnectionString())
 	},
 }
diff --git a/cmd/recalculate_elo.go b/cmd/recalculate_elo.go
@@ -15,6 +15,7 @@ var recalculateEloCmd = &cobra.Command{
 	This will reset the elo for all players, and regenerate the elo changelog
 	Elo will be recalculated based on 'updated_at' timestamp of each match`,
 	Run: func(cmd *cobra.Command, args []string) {
+		SetupConfig(cmd)
 		models.InitDB(models.GetMysqlConnectionString())
 
 		dryRun, _ := cmd.Flags().GetBool("dry-run")
diff --git a/cmd/recalculate_statistics.go b/cmd/recalculate_statistics.go
@@ -15,6 +15,7 @@ var recalculateStatisticsCmd = &cobra.Command{
 	Short: "Recalculate statistics",
 	Long:  `Recalculate statistics for the given match type`,
 	PersistentPreRun: func(cmd *cobra.Command, args []string) {
+		SetupConfig(cmd)
 		models.InitDB(models.GetMysqlConnectionString())
 
 		since, _ = cmd.Flags().GetString("since")
diff --git a/cmd/root.go b/cmd/root.go
@@ -17,14 +17,18 @@ var rootCmd = &cobra.Command{
 	Short: "Backend API for kcapp frontend",
 	Long:  `kcapp-api is the backend API for kcapp dart scoring application frontend`,
 	PersistentPreRun: func(cmd *cobra.Command, args []string) {
-		configFileParam, err := cmd.Flags().GetString("config")
-		if err != nil {
-			panic(err)
-		}
-		InitConfig(&configFileParam)
+		SetupConfig(cmd)
 	},
 }
 
+func SetupConfig(cmd *cobra.Command) {
+	configFileParam, err := cmd.Flags().GetString("config")
+	if err != nil {
+		panic(err)
+	}
+	InitConfig(&configFileParam)
+}
+
 func InitConfig(configFile *string) {
 	viper.SetConfigName("config")
 	viper.SetConfigType("yaml")
diff --git a/cmd/serve.go b/cmd/serve.go
@@ -99,9 +99,11 @@ var serveCmd = &cobra.Command{
 		router.HandleFunc("/statistics/office/{from}/{to}", controllers.GetOfficeStatistics).Methods("GET")
 		router.HandleFunc("/statistics/office/{office_id}/{from}/{to}", controllers.GetOfficeStatistics).Methods("GET")
 		router.HandleFunc("/statistics/{dart}/hits", controllers.GetDartStatistics).Methods("GET")
-		router.HandleFunc("/statistics/x01/player/{legs}", controllers.GetPlayersLastXLegsStatistics).Methods("GET")
+		router.HandleFunc("/statistics/x01/player/", controllers.GetPlayersLastXLegsStatistics).Methods("GET")
 		router.HandleFunc("/statistics/{match_type}/{from}/{to}", controllers.GetStatistics).Methods("GET")
 
+		router.HandleFunc("/leaderboard/matchtypes", controllers.GetMatchTypeLeaderboard).Methods("GET")
+
 		router.HandleFunc("/owe", controllers.GetOwes).Methods("GET")
 		router.HandleFunc("/owe/payback", controllers.RegisterPayback).Methods("PUT")
 
diff --git a/controllers/leaderboard_controller.go b/controllers/leaderboard_controller.go
@@ -0,0 +1,21 @@
+package controllers
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+
+	"github.com/kcapp/api/data"
+)
+
+// GetMatchTypeLeaderboard will return leaderboard for each match type
+func GetMatchTypeLeaderboard(w http.ResponseWriter, r *http.Request) {
+	SetHeaders(w)
+	leaderboard, err := data.GetMatchTypeLeaderboard()
+	if err != nil {
+		log.Println("Unable to get match type leaderboards", err)
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	json.NewEncoder(w).Encode(leaderboard)
+}
diff --git a/controllers/player_controller.go b/controllers/player_controller.go
@@ -642,14 +642,51 @@ func UpdatePlayer(w http.ResponseWriter, r *http.Request) {
 func GetPlayerProgression(w http.ResponseWriter, r *http.Request) {
 	SetHeaders(w)
 	params := mux.Vars(r)
-	id, err := strconv.Atoi(params["id"])
+	playerID, err := strconv.Atoi(params["id"])
 	if err != nil {
 		log.Println("Invalid id parameter")
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 
-	stats, err := data.GetPlayerProgression(id)
+	// Get query parameters
+	bucketSizeStr := r.URL.Query().Get("bucket_size")
+	startingScoreStr := r.URL.Query().Get("starting_score")
+	oneVOneOnlyStr := r.URL.Query().Get("1v1_only")
+	officialOnlyStr := r.URL.Query().Get("official_only")
+
+	// Set default values
+	bucketSize := 50
+	var startingScore *int
+	oneVOneOnly := false
+	officialOnly := false
+
+	if bucketSizeStr != "" {
+		var err error
+		bucketSize, err = strconv.Atoi(bucketSizeStr)
+		if err != nil {
+			http.Error(w, "Invalid bucket_size", http.StatusBadRequest)
+			return
+		}
+	}
+
+	if startingScoreStr != "" {
+		var score int
+		score, err := strconv.Atoi(startingScoreStr)
+		if err == nil {
+			startingScore = &score
+		}
+	}
+
+	if oneVOneOnlyStr != "" {
+		oneVOneOnly = oneVOneOnlyStr == "true"
+	}
+
+	if officialOnlyStr != "" {
+		officialOnly = officialOnlyStr == "true"
+	}
+
+	stats, err := data.GetPlayerProgression(playerID, bucketSize, startingScore, oneVOneOnly, officialOnly)
 	if err != nil {
 		log.Println("Unable to get player progression", err)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
diff --git a/data/leaderboard.go b/data/leaderboard.go
@@ -0,0 +1,26 @@
+package data
+
+import "github.com/kcapp/api/models"
+
+// GetMatchTypeLeaderboard will return leaderboard statistics for each match type
+func GetMatchTypeLeaderboard() (map[int][]*models.MatchTypeLeaderboard, error) {
+	rows, err := models.DB.Query(`CALL get_leaderboard_per_match_type(5);`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	leaderboard := make(map[int][]*models.MatchTypeLeaderboard)
+	for rows.Next() {
+		mtl := new(models.MatchTypeLeaderboard)
+		err := rows.Scan(&mtl.MatchTypeID, &mtl.PlayerID, &mtl.LegID, &mtl.DartsThrown, &mtl.Score)
+		if err != nil {
+			return nil, err
+		}
+		if _, ok := leaderboard[mtl.MatchTypeID]; !ok {
+			leaderboard[mtl.MatchTypeID] = make([]*models.MatchTypeLeaderboard, 0)
+		}
+		leaderboard[mtl.MatchTypeID] = append(leaderboard[mtl.MatchTypeID], mtl)
+	}
+	return leaderboard, nil
+}
diff --git a/data/leg.go b/data/leg.go
@@ -160,8 +160,8 @@ func FinishLeg(legID int, currentPlayer int, winnerID null.Int) error {
 		}
 		for playerID, stats := range statisticsMap {
 			_, err = tx.Exec(`
-				INSERT INTO statistics_shootout(leg_id, player_id, score, ppd, 60s_plus, 100s_plus, 140s_plus, 180s)
-				VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, legID, playerID, stats.Score, stats.PPD, stats.Score60sPlus,
+				INSERT INTO statistics_shootout(leg_id, player_id, score, ppd, darts_thrown, 60s_plus, 100s_plus, 140s_plus, 180s)
+				VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, legID, playerID, stats.Score, stats.PPD, stats.DartsThrown, stats.Score60sPlus,
 				stats.Score100sPlus, stats.Score140sPlus, stats.Score180s)
 			if err != nil {
 				tx.Rollback()
diff --git a/data/statistics_shootout.go b/data/statistics_shootout.go
@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"fmt"
 
+	"github.com/guregu/null"
 	"github.com/kcapp/api/models"
 )
 
@@ -223,6 +224,7 @@ func CalculateShootoutStatistics(legID int) (map[int]*models.StatisticsShootout,
 		stats := new(models.StatisticsShootout)
 		statisticsMap[player.PlayerID] = stats
 		stats.Score = player.CurrentScore
+		stats.DartsThrown = null.IntFrom(0)
 	}
 
 	for _, visit := range visits {
@@ -240,6 +242,7 @@ func CalculateShootoutStatistics(legID int) (map[int]*models.StatisticsShootout,
 		} else if visitScore == 180 {
 			stats.Score180s++
 		}
+		stats.DartsThrown = null.IntFrom(stats.DartsThrown.Int64 + 3)
 	}
 
 	for playerID, stats := range statisticsMap {
@@ -258,8 +261,8 @@ func RecalculateShootoutStatistics(legs []int) ([]string, error) {
 			return nil, err
 		}
 		for playerID, stat := range stats {
-			queries = append(queries, fmt.Sprintf(`UPDATE statistics_shootout SET score = %d, ppd = %f, 60s_plus = %d, 100s_plus = %d, 140s_plus = %d, 180s = %d WHERE leg_id = %d AND player_id = %d;`,
-				stat.Score, stat.PPD, stat.Score60sPlus, stat.Score100sPlus, stat.Score140sPlus, stat.Score180s, legID, playerID))
+			queries = append(queries, fmt.Sprintf(`UPDATE statistics_shootout SET score = %d, ppd = %f, darts_thrown = %d, 60s_plus = %d, 100s_plus = %d, 140s_plus = %d, 180s = %d WHERE leg_id = %d AND player_id = %d;`,
+				stat.Score, stat.PPD, stat.DartsThrown.Int64, stat.Score60sPlus, stat.Score100sPlus, stat.Score140sPlus, stat.Score180s, legID, playerID))
 		}
 	}
 	return queries, nil
diff --git a/data/statistics_x01.go b/data/statistics_x01.go
@@ -363,54 +363,33 @@ func GetPlayersX01PreviousStatistics(ids []int, startingScores ...int) ([]*model
 }
 
 // GetPlayerProgression will get progression of statistics over time for the given player
-func GetPlayerProgression(id int) (map[string]*models.StatisticsX01, error) {
-	rows, err := models.DB.Query(`
-		SELECT
-			s.player_id AS 'player_id',
-			SUM(s.ppd_score) / SUM(s.darts_thrown) AS 'ppd',
-			SUM(s.first_nine_ppd) / COUNT(s.player_id) AS 'first_nine_ppd',
-			(SUM(s.ppd_score) / SUM(s.darts_thrown)) * 3 AS 'three_dart_avg',
-			SUM(s.first_nine_ppd) / COUNT(s.player_id) * 3 AS 'first_nine_three_dart_avg',
-			SUM(s.60s_plus) AS '60s_plus',
-			SUM(s.100s_plus) AS '100s_plus',
-			SUM(s.140s_plus) AS '140s_plus',
-			SUM(s.180s) AS '180s',
-			SUM(s.accuracy_20) / COUNT(s.accuracy_20) AS 'accuracy_20s',
-			SUM(s.accuracy_19) / COUNT(s.accuracy_19) AS 'accuracy_19s',
-			SUM(s.overall_accuracy) / COUNT(s.overall_accuracy) AS 'accuracy_overall',
-			COUNT(s.checkout_percentage) / SUM(s.checkout_attempts) * 100 AS 'checkout_percentage',
-			MAX(s.checkout) AS 'checkout',
-			DATE(m.updated_at) AS 'date'
-		FROM statistics_x01 s
-			JOIN leg l ON l.id = s.leg_id
-			JOIN matches m ON m.id = l.match_id
-		WHERE s.player_id = ?
-			AND m.match_type_id = 1
-			AND m.is_finished = 1 AND m.is_abandoned = 0
-		GROUP BY YEAR(m.updated_at), WEEK(m.updated_at)
-		ORDER BY date DESC`, id)
+func GetPlayerProgression(playerID int, bucketSize int, startingScore *int, oneVOneOnly bool, officialOnly bool) ([]*models.PlayerX01Progression, error) {
+	rows, err := models.DB.Query(`CALL get_player_x01_statistics_per_leg_bucket(?, ?, ?, ?, ?)`,
+		playerID, bucketSize, &startingScore, oneVOneOnly, officialOnly)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
 
-	statisticsMap := make(map[string]*models.StatisticsX01)
+	progression := make([]*models.PlayerX01Progression, 0)
 	for rows.Next() {
-		var date string
-		s := new(models.StatisticsX01)
-		err := rows.Scan(&s.PlayerID, &s.PPD, &s.FirstNinePPD, &s.ThreeDartAvg, &s.FirstNineThreeDartAvg, &s.Score60sPlus,
-			&s.Score100sPlus, &s.Score140sPlus, &s.Score180s, &s.Accuracy20, &s.Accuracy19, &s.AccuracyOverall, &s.CheckoutPercentage,
-			&s.Checkout, &date)
+		p := new(models.PlayerX01Progression)
+		p.Statistics = new(models.StatisticsX01)
+		err := rows.Scan(&p.PlayerID, &p.Bucket, &p.FirstLegID, &p.LastLegID, &p.LegsInBucket, &p.StartDate, &p.EndDate,
+			&p.Statistics.PPD, &p.Statistics.FirstNinePPD,
+			&p.Statistics.ThreeDartAvg, &p.Statistics.FirstNineThreeDartAvg, &p.Statistics.Score60sPlus,
+			&p.Statistics.Score100sPlus, &p.Statistics.Score140sPlus, &p.Statistics.Score180s, &p.Statistics.Accuracy20,
+			&p.Statistics.Accuracy19, &p.Statistics.AccuracyOverall, &p.Statistics.CheckoutPercentage, &p.Statistics.Checkout)
 		if err != nil {
 			return nil, err
 		}
-		statisticsMap[date] = s
+		progression = append(progression, p)
 	}
 	if err = rows.Err(); err != nil {
 		return nil, err
 	}
 
-	return statisticsMap, nil
+	return progression, nil
 }
 
 // GetX01StatisticsForPlayer will return X01 statistics for the given player
@@ -1016,7 +995,7 @@ func GetPlayerBadgeStatistics(ids []int, legID *int) (map[int]*models.PlayerBadg
 
 // GetPlayersLastXLegsStatistics will return statistics for the last X legs for all players
 func GetPlayersLastXLegsStatistics() ([]*models.StatisticsX01, error) {
-	rows, err := models.DB.Query(`CALL get_player_last_x_legs_statistics((SELECT leaderboard_last_legs_count FROM match_default LIMIT 1))`)
+	rows, err := models.DB.Query(`CALL get_players_last_x_legs_statistics(0, (SELECT leaderboard_last_legs_count FROM match_default LIMIT 1), (SELECT leaderboard_active_period_weeks FROM match_default LIMIT 1))`)
 	if err != nil {
 		return nil, err
 	}
diff --git a/models/badge.go b/models/badge.go
@@ -207,11 +207,12 @@ func (b BadgeVersatilePlayer) Levels() []int {
 
 var LeaderboardBadges = []LeaderboardBadge{
 	BadgeKingslayer{ID: 48},
+	BadgeStillReigning{ID: 49},
 }
 
 type LeaderboardBadge interface {
 	GetID() int
-	// Validate returns bool, player.ID
+	// Validate returns bool, winner.playerID, looser.playerID
 	Validate(match *Match, matchStatistics []*StatisticsX01, leaderboard []*StatisticsX01) (bool, *int, *int)
 }
 
@@ -282,6 +283,43 @@ func (b BadgeKingslayer) Validate(match *Match, matchStatistics []*StatisticsX01
 	return true, &kingslayer, king
 }
 
+type BadgeStillReigning struct{ ID int }
+
+func (b BadgeStillReigning) GetID() int {
+	return b.ID
+}
+func (b BadgeStillReigning) Validate(match *Match, matchStatistics []*StatisticsX01, leaderboard []*StatisticsX01) (bool, *int, *int) {
+	if !match.IsX01() || !match.MatchMode.IsChallenge {
+		return false, nil, nil
+	}
+	if len(match.Players) != 2 {
+		return false, nil, nil
+	}
+	if len(leaderboard) == 0 {
+		return false, nil, nil
+	}
+
+	// Get the current king in the correct office
+	var king *int
+	var kingOfKings *int
+	if len(leaderboard) > 0 {
+		kingOfKings = &leaderboard[0].PlayerID
+		king = kingOfKings
+	}
+	if match.OfficeID.Valid {
+		for _, stat := range leaderboard {
+			if stat.OfficeID.Int64 == match.OfficeID.Int64 {
+				king = &stat.PlayerID
+				break
+			}
+		}
+	}
+	if match.WinnerID.Int64 == int64(*king) || match.WinnerID.Int64 == int64(*kingOfKings) {
+		return true, king, match.GetLooser()
+	}
+	return false, nil, nil
+}
+
 var MatchBadges = []MatchBadge{
 	BadgeJustAQuickie{ID: 37},
 	BadgeAroundTheWorld{ID: 38},
diff --git a/models/leaderboard.go b/models/leaderboard.go
@@ -0,0 +1,12 @@
+package models
+
+import "github.com/guregu/null"
+
+// MatchTypeLeaderboard struct to hold leaderboard data for a specific match type
+type MatchTypeLeaderboard struct {
+	MatchTypeID int      `json:"match_type_id"`
+	PlayerID    int      `json:"player_id"`
+	LegID       int      `json:"leg_id"`
+	DartsThrown null.Int `json:"darts_thrown"`
+	Score       int      `json:"score"`
+}
diff --git a/models/match.go b/models/match.go
@@ -346,6 +346,18 @@ func (m Match) IsX01() bool {
 	return m.MatchType.ID == X01
 }
 
+// GetLooser will return the looser player ID
+func (m Match) GetLooser() *int {
+	if m.WinnerID.Valid {
+		for _, player := range m.Players {
+			if player != int(m.WinnerID.Int64) {
+				return &player
+			}
+		}
+	}
+	return nil
+}
+
 // GetLooserStanding returns the standing of the looser of the match
 func (mm MatchMetadata) GetLooserStanding() int {
 	if mm.LooserOutcomeStanding.Valid {
diff --git a/models/statistics_shootout.go b/models/statistics_shootout.go
@@ -14,6 +14,7 @@ type StatisticsShootout struct {
 	OfficeID      null.Int        `json:"office_id,omitempty"`
 	Score         int             `json:"score"`
 	PPD           float32         `json:"ppd"`
+	DartsThrown   null.Int        `json:"darts_thrown"`
 	Score60sPlus  int             `json:"scores_60s_plus"`
 	Score100sPlus int             `json:"scores_100s_plus"`
 	Score140sPlus int             `json:"scores_140s_plus"`
diff --git a/models/statistics_x01.go b/models/statistics_x01.go

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ var recalculateBadgeCmd = &cobra.Command{`
`11`	`11`	`Short: "Recalculate badge",`
`12`	`12`	Long: `Recalculate badges earned by each player`,
`13`	`13`	`PersistentPreRun: func(cmd *cobra.Command, args []string) {`
	`14`	`+ SetupConfig(cmd)`
`14`	`15`	`models.InitDB(models.GetMysqlConnectionString())`
`15`	`16`	`},`
`16`	`17`	`}`