feat: add round win limit handling in ScoreService and ScoreRepository

Author: Tolfx

internal/model/score.go

@@ -38,6 +38,7 @@ type Match struct {
 	RosterAwayID  int  `gorm:"column:away_team_id"`
 	RosterHomeID  int  `gorm:"column:home_team_id"`
 	WinLimit      int  `gorm:"column:win_limit"`
+	RoundWinLimit int  `gorm:"column:round_win_limit"`
 }
 
 // TableName overrides the table name for Match

internal/repository/score_repository.go

@@ -80,3 +80,49 @@ func (r *ScoreRepository) UpdateMatchStatus(matchID, status int) error {
 
 	return nil
 }
+
+// HasTeamReachedRoundWinLimit checks whether either team reached the configured round win limit
+func (r *ScoreRepository) HasTeamReachedRoundWinLimit(matchID int) (bool, error) {
+	var match model.Match
+	matchQuery := r.db.Select("round_win_limit", "home_team_id", "away_team_id").Where("id = ?", matchID).First(&match)
+	if matchQuery.Error != nil {
+		return false, fmt.Errorf("failed to fetch match info: %w", matchQuery.Error)
+	}
+
+	validWinners := make(map[int]struct{})
+	if match.RosterHomeID != 0 {
+		validWinners[match.RosterHomeID] = struct{}{}
+	}
+	if match.RosterAwayID != 0 {
+		validWinners[match.RosterAwayID] = struct{}{}
+	}
+
+	if match.RoundWinLimit <= 0 || len(validWinners) == 0 {
+		return false, nil
+	}
+
+	var rounds []model.MatchRound
+	roundsQuery := r.db.Select("winner_id").Where("match_id = ?", matchID).Find(&rounds)
+	if roundsQuery.Error != nil {
+		return false, fmt.Errorf("failed to fetch match rounds: %w", roundsQuery.Error)
+	}
+
+	wins := make(map[int]int)
+	for _, round := range rounds {
+		if round.WinnerID == nil {
+			continue
+		}
+
+		winnerID := *round.WinnerID
+		if _, ok := validWinners[winnerID]; !ok {
+			continue
+		}
+
+		wins[winnerID]++
+		if wins[winnerID] >= match.RoundWinLimit {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}

internal/service/score_service.go

@@ -52,25 +52,44 @@ func (s *ScoreService) ProcessScoreData(scoreData *model.ScoreData) error {
 		// Continue processing even if this check fails
 	}
 
-	// If all rounds are done, update match status to completed (status 3)
-	if allDone {
-		err = s.repo.UpdateMatchStatus(scoreData.MatchID, 3)
-		if err != nil {
-			logger.Log.Error("Failed to update match status", zap.Error(err))
-			return fmt.Errorf("error updating match status: %w", err)
+	shouldComplete := allDone
+	completionReason := "all rounds completed"
+	if !shouldComplete {
+		reachedLimit, checkErr := s.repo.HasTeamReachedRoundWinLimit(scoreData.MatchID)
+		if checkErr != nil {
+			logger.Log.Error("Failed to determine if round win limit was reached", zap.Error(checkErr))
+		} else if reachedLimit {
+			shouldComplete = true
+			completionReason = "round win limit reached"
 		}
+	}
 
-		// Update scores again after marking match as complete
-		if err := s.updateScores(scoreData.MatchID); err != nil {
-			logger.Log.Error("Failed to update scores via external API after completion", zap.Error(err))
-			return fmt.Errorf("error updating scores: %w", err)
+	if shouldComplete {
+		logger.Log.Info("Marking match as completed", zap.Int("matchID", scoreData.MatchID), zap.String("reason", completionReason))
+		if err := s.completeMatch(scoreData.MatchID); err != nil {
+			return err
 		}
 	}
 
 	logger.Log.Info("Successfully processed score data", zap.Int("matchID", scoreData.MatchID), zap.Int("roundID", scoreData.RoundID))
 	return nil
 }
 
+// completeMatch finalizes a match by setting its status and notifying the league site
+func (s *ScoreService) completeMatch(matchID int) error {
+	if err := s.repo.UpdateMatchStatus(matchID, 3); err != nil {
+		logger.Log.Error("Failed to update match status", zap.Error(err), zap.Int("matchID", matchID))
+		return fmt.Errorf("error updating match status: %w", err)
+	}
+
+	if err := s.updateScores(matchID); err != nil {
+		logger.Log.Error("Failed to update scores via external API after completion", zap.Error(err), zap.Int("matchID", matchID))
+		return fmt.Errorf("error updating scores: %w", err)
+	}
+
+	return nil
+}
+
 // updateScores calls the external API to update scores
 func (s *ScoreService) updateScores(matchID int) error {
 	updateScoresURL := fmt.Sprintf("https://udl.tf/leagues/matches/%d/update_scores", matchID)