Fixing empty scores are count on classification.

softwaremagico · softwaremagico · commit 3675b0549e52 · 2025-11-12T21:31:17.000+01:00
diff --git a/backend/kendo-tournament-core/src/main/java/com/softwaremagico/kt/core/controller/AchievementController.java b/backend/kendo-tournament-core/src/main/java/com/softwaremagico/kt/core/controller/AchievementController.java
@@ -818,10 +818,10 @@ private List<Achievement> generateTerminatorAchievement(Tournament tournament) {
         duels.forEach(duel -> competitors.addAll(duel.getCompetitors()));
 
         duels.forEach(duel -> {
-            if (duel.getCompetitor1Score().size() < Duel.POINTS_TO_WIN) {
+            if (duel.getCompetitor1ScoreValue() < Duel.POINTS_TO_WIN) {
                 competitors.remove(duel.getCompetitor1());
             }
-            if (duel.getCompetitor2Score().size() < Duel.POINTS_TO_WIN) {
+            if (duel.getCompetitor2ScoreValue() < Duel.POINTS_TO_WIN) {
                 competitors.remove(duel.getCompetitor2());
             }
         });
@@ -876,19 +876,19 @@ private List<Achievement> generateJuggernautAchievement(Tournament tournament) {
 
         duels.forEach(duel -> {
             //Max score competitor 1.
-            if (duel.getCompetitor1Score().size() < Duel.POINTS_TO_WIN) {
+            if (duel.getCompetitor1ScoreValue() < Duel.POINTS_TO_WIN) {
                 competitors.remove(duel.getCompetitor1());
             }
             //No hits against him
-            if (!duel.getCompetitor2Score().isEmpty()) {
+            if (duel.getCompetitor2ScoreValue() > 0) {
                 competitors.remove(duel.getCompetitor1());
             }
             //Max score competitor 2.
-            if (duel.getCompetitor2Score().size() < Duel.POINTS_TO_WIN) {
+            if (duel.getCompetitor2ScoreValue() < Duel.POINTS_TO_WIN) {
                 competitors.remove(duel.getCompetitor2());
             }
             //No hits against him
-            if (!duel.getCompetitor1Score().isEmpty()) {
+            if (duel.getCompetitor1ScoreValue() > 0) {
                 competitors.remove(duel.getCompetitor2());
             }
         });
diff --git a/backend/kendo-tournament-core/src/main/java/com/softwaremagico/kt/core/controller/FightController.java b/backend/kendo-tournament-core/src/main/java/com/softwaremagico/kt/core/controller/FightController.java
@@ -274,4 +274,10 @@ public List<FightDTO> getBy(Participant participant) {
         return convertAll(getProvider().getBy(Collections.singletonList(participant)));
     }
 
+    public boolean scoresGoesFromCompetitorsNameToCenter(int tournamentId) {
+        return getProvider().scoresGoesFromCompetitorsNameToCenter(tournamentProvider.get(tournamentId)
+                .orElseThrow(() -> new TournamentNotFoundException(getClass(), "No tournament found with id '" + tournamentId + "',",
+                        ExceptionType.INFO)));
+    }
+
 }
diff --git a/backend/kendo-tournament-core/src/main/java/com/softwaremagico/kt/core/controller/models/FightDTO.java b/backend/kendo-tournament-core/src/main/java/com/softwaremagico/kt/core/controller/models/FightDTO.java
@@ -183,9 +183,9 @@ public Integer getDrawDuels(ParticipantDTO competitor) {
     public Integer getScore(ParticipantDTO competitor) {
         int score = 0;
         score += getDuels().stream().filter(duel ->
-                (Objects.equals(duel.getCompetitor1(), competitor))).mapToInt(duel -> duel.getCompetitor1Score().size()).sum();
+                (Objects.equals(duel.getCompetitor1(), competitor))).mapToInt(DuelDTO::getCompetitor1ScoreValue).sum();
         score += getDuels().stream().filter(duel ->
-                (Objects.equals(duel.getCompetitor2(), competitor))).mapToInt(duel -> duel.getCompetitor2Score().size()).sum();
+                (Objects.equals(duel.getCompetitor2(), competitor))).mapToInt(DuelDTO::getCompetitor2ScoreValue).sum();
         return score;
     }
 
@@ -200,11 +200,11 @@ public Integer getScore(TeamDTO team) {
     }
 
     public Integer getScoreTeam1() {
-        return getDuels().stream().mapToInt(duel -> duel.getCompetitor1Score().size()).sum();
+        return getDuels().stream().mapToInt(DuelDTO::getCompetitor1ScoreValue).sum();
     }
 
     public Integer getScoreTeam2() {
-        return getDuels().stream().mapToInt(duel -> duel.getCompetitor2Score().size()).sum();
+        return getDuels().stream().mapToInt(DuelDTO::getCompetitor2ScoreValue).sum();
     }
 
     public Integer getDuelsWon(ParticipantDTO competitor) {
diff --git a/backend/kendo-tournament-core/src/main/java/com/softwaremagico/kt/core/providers/FightProvider.java b/backend/kendo-tournament-core/src/main/java/com/softwaremagico/kt/core/providers/FightProvider.java
@@ -28,6 +28,7 @@
 import com.softwaremagico.kt.persistence.entities.Tournament;
 import com.softwaremagico.kt.persistence.repositories.FightRepository;
 import com.softwaremagico.kt.persistence.repositories.GroupRepository;
+import com.softwaremagico.kt.persistence.values.Score;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -161,4 +162,31 @@ public List<Fight> findByTournamentAndShiaijo(Tournament tournament, int shiaijo
         return getRepository().findByTournamentAndShiaijo(tournament, shiaijo);
     }
 
+    public boolean scoresGoesFromCompetitorsNameToCenter(Tournament tournament) {
+        final List<Fight> fights = getRepository().findByTournament(tournament);
+        for (Fight fight : fights) {
+            if (fight.getDuels() != null) {
+                for (Duel duel : fight.getDuels()) {
+                    if (scoresGoesFromCompetitorsNameToCenter(duel.getCompetitor1Score())) {
+                        return true;
+                    }
+                    if (scoresGoesFromCompetitorsNameToCenter(duel.getCompetitor2Score())) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean scoresGoesFromCompetitorsNameToCenter(List<Score> scores) {
+        if (scores.size() == 1) {
+            return false;
+        }
+        //Scores are set at index 1 before index 0;
+        return (scores.size() > 1
+                && scores.get(0) == null
+                && scores.get(1) != null && scores.get(1) != Score.EMPTY);
+    }
+
 }
diff --git a/backend/kendo-tournament-persistence/src/main/java/com/softwaremagico/kt/persistence/entities/Duel.java b/backend/kendo-tournament-persistence/src/main/java/com/softwaremagico/kt/persistence/entities/Duel.java
@@ -46,6 +46,7 @@
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 
 @Entity
diff --git a/backend/kendo-tournament-persistence/src/main/java/com/softwaremagico/kt/persistence/entities/Fight.java b/backend/kendo-tournament-persistence/src/main/java/com/softwaremagico/kt/persistence/entities/Fight.java
@@ -209,9 +209,9 @@ public void generateDuels(String createdBy) {
     public Integer getScore(Participant competitor) {
         int score = 0;
         score += getDuels().stream().filter(duel ->
-                (Objects.equals(duel.getCompetitor1(), competitor))).mapToInt(duel -> duel.getCompetitor1Score().size()).sum();
+                (Objects.equals(duel.getCompetitor1(), competitor))).mapToInt(Duel::getCompetitor1ScoreValue).sum();
         score += getDuels().stream().filter(duel ->
-                (Objects.equals(duel.getCompetitor2(), competitor))).mapToInt(duel -> duel.getCompetitor2Score().size()).sum();
+                (Objects.equals(duel.getCompetitor2(), competitor))).mapToInt(Duel::getCompetitor2ScoreValue).sum();
         return score;
     }
 
@@ -272,11 +272,11 @@ public Integer getScore(Team team) {
     }
 
     public Integer getScoreTeam1() {
-        return getDuels().stream().mapToInt(duel -> duel.getCompetitor1Score().stream().filter(Objects::nonNull).toList().size()).sum();
+        return getDuels().stream().mapToInt(Duel::getCompetitor1ScoreValue).sum();
     }
 
     public Integer getScoreTeam2() {
-        return getDuels().stream().mapToInt(duel -> duel.getCompetitor2Score().stream().filter(Objects::nonNull).toList().size()).sum();
+        return getDuels().stream().mapToInt(Duel::getCompetitor2ScoreValue).sum();
     }
 }
 
diff --git a/backend/kendo-tournament-rest/src/main/java/com/softwaremagico/kt/rest/services/FightServices.java b/backend/kendo-tournament-rest/src/main/java/com/softwaremagico/kt/rest/services/FightServices.java
@@ -202,4 +202,14 @@ public List<FightDTO> getByCompetitor(@Parameter(description = "Id of the compet
     }
 
 
+    @PreAuthorize("hasAnyAuthority(@securityService.viewerPrivilege, @securityService.editorPrivilege, @securityService.adminPrivilege,"
+            + " @securityService.participantPrivilege)")
+    @Operation(summary = "Checks if the scores are added from the competitor's name, to the center of the sheet.", security = @SecurityRequirement(name = "bearerAuth"))
+    @GetMapping(value = "/scores-from-name-to-center/tournaments/{tournamentId}", produces = MediaType.APPLICATION_JSON_VALUE)
+    public boolean scoresGoesFromCompetitorsNameToCenter(@Parameter(description = "Id of an existing tournament", required = true)
+                                                         @PathVariable("tournamentId") Integer tournamentId,
+                                                         HttpServletRequest request) {
+        return getController().scoresGoesFromCompetitorsNameToCenter(tournamentId);
+    }
+
 }

Original file line number	Diff line number	Diff line change
`@@ -818,10 +818,10 @@ private List<Achievement> generateTerminatorAchievement(Tournament tournament) {`
`818`	`818`	`duels.forEach(duel -> competitors.addAll(duel.getCompetitors()));`
`819`	`819`
`820`	`820`	`duels.forEach(duel -> {`
`821`		`- if (duel.getCompetitor1Score().size() < Duel.POINTS_TO_WIN) {`
	`821`	`+ if (duel.getCompetitor1ScoreValue() < Duel.POINTS_TO_WIN) {`
`822`	`822`	`competitors.remove(duel.getCompetitor1());`
`823`	`823`	`}`
`824`		`- if (duel.getCompetitor2Score().size() < Duel.POINTS_TO_WIN) {`
	`824`	`+ if (duel.getCompetitor2ScoreValue() < Duel.POINTS_TO_WIN) {`
`825`	`825`	`competitors.remove(duel.getCompetitor2());`
`826`	`826`	`}`
`827`	`827`	`});`
`@@ -876,19 +876,19 @@ private List<Achievement> generateJuggernautAchievement(Tournament tournament) {`
`876`	`876`
`877`	`877`	`duels.forEach(duel -> {`
`878`	`878`	`//Max score competitor 1.`
`879`		`- if (duel.getCompetitor1Score().size() < Duel.POINTS_TO_WIN) {`
	`879`	`+ if (duel.getCompetitor1ScoreValue() < Duel.POINTS_TO_WIN) {`
`880`	`880`	`competitors.remove(duel.getCompetitor1());`
`881`	`881`	`}`
`882`	`882`	`//No hits against him`
`883`		`- if (!duel.getCompetitor2Score().isEmpty()) {`
	`883`	`+ if (duel.getCompetitor2ScoreValue() > 0) {`
`884`	`884`	`competitors.remove(duel.getCompetitor1());`
`885`	`885`	`}`
`886`	`886`	`//Max score competitor 2.`
`887`		`- if (duel.getCompetitor2Score().size() < Duel.POINTS_TO_WIN) {`
	`887`	`+ if (duel.getCompetitor2ScoreValue() < Duel.POINTS_TO_WIN) {`
`888`	`888`	`competitors.remove(duel.getCompetitor2());`
`889`	`889`	`}`
`890`	`890`	`//No hits against him`
`891`		`- if (!duel.getCompetitor1Score().isEmpty()) {`
	`891`	`+ if (duel.getCompetitor1ScoreValue() > 0) {`
`892`	`892`	`competitors.remove(duel.getCompetitor2());`
`893`	`893`	`}`
`894`	`894`	`});`
Original file line number	Diff line number	Diff line change
`@@ -274,4 +274,10 @@ public List<FightDTO> getBy(Participant participant) {`
`274`	`274`	`return convertAll(getProvider().getBy(Collections.singletonList(participant)));`
`275`	`275`	`}`
`276`	`276`
	`277`	`+ public boolean scoresGoesFromCompetitorsNameToCenter(int tournamentId) {`
	`278`	`+ return getProvider().scoresGoesFromCompetitorsNameToCenter(tournamentProvider.get(tournamentId)`
	`279`	`+ .orElseThrow(() -> new TournamentNotFoundException(getClass(), "No tournament found with id '" + tournamentId + "',",`
	`280`	`+ ExceptionType.INFO)));`
	`281`	`+ }`
	`282`	`+`
`277`	`283`	`}`
Original file line number	Diff line number	Diff line change
`@@ -183,9 +183,9 @@ public Integer getDrawDuels(ParticipantDTO competitor) {`
`183`	`183`	`public Integer getScore(ParticipantDTO competitor) {`
`184`	`184`	`int score = 0;`
`185`	`185`	`score += getDuels().stream().filter(duel ->`
`186`		`- (Objects.equals(duel.getCompetitor1(), competitor))).mapToInt(duel -> duel.getCompetitor1Score().size()).sum();`
	`186`	`+ (Objects.equals(duel.getCompetitor1(), competitor))).mapToInt(DuelDTO::getCompetitor1ScoreValue).sum();`
`187`	`187`	`score += getDuels().stream().filter(duel ->`
`188`		`- (Objects.equals(duel.getCompetitor2(), competitor))).mapToInt(duel -> duel.getCompetitor2Score().size()).sum();`
	`188`	`+ (Objects.equals(duel.getCompetitor2(), competitor))).mapToInt(DuelDTO::getCompetitor2ScoreValue).sum();`
`189`	`189`	`return score;`
`190`	`190`	`}`
`191`	`191`
`@@ -200,11 +200,11 @@ public Integer getScore(TeamDTO team) {`
`200`	`200`	`}`
`201`	`201`
`202`	`202`	`public Integer getScoreTeam1() {`
`203`		`- return getDuels().stream().mapToInt(duel -> duel.getCompetitor1Score().size()).sum();`
	`203`	`+ return getDuels().stream().mapToInt(DuelDTO::getCompetitor1ScoreValue).sum();`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`public Integer getScoreTeam2() {`
`207`		`- return getDuels().stream().mapToInt(duel -> duel.getCompetitor2Score().size()).sum();`
	`207`	`+ return getDuels().stream().mapToInt(DuelDTO::getCompetitor2ScoreValue).sum();`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`public Integer getDuelsWon(ParticipantDTO competitor) {`
Original file line number	Diff line number	Diff line change
`@@ -209,9 +209,9 @@ public void generateDuels(String createdBy) {`
`209`	`209`	`public Integer getScore(Participant competitor) {`
`210`	`210`	`int score = 0;`
`211`	`211`	`score += getDuels().stream().filter(duel ->`
`212`		`- (Objects.equals(duel.getCompetitor1(), competitor))).mapToInt(duel -> duel.getCompetitor1Score().size()).sum();`
	`212`	`+ (Objects.equals(duel.getCompetitor1(), competitor))).mapToInt(Duel::getCompetitor1ScoreValue).sum();`
`213`	`213`	`score += getDuels().stream().filter(duel ->`
`214`		`- (Objects.equals(duel.getCompetitor2(), competitor))).mapToInt(duel -> duel.getCompetitor2Score().size()).sum();`
	`214`	`+ (Objects.equals(duel.getCompetitor2(), competitor))).mapToInt(Duel::getCompetitor2ScoreValue).sum();`
`215`	`215`	`return score;`
`216`	`216`	`}`
`217`	`217`
`@@ -272,11 +272,11 @@ public Integer getScore(Team team) {`
`272`	`272`	`}`
`273`	`273`
`274`	`274`	`public Integer getScoreTeam1() {`
`275`		`- return getDuels().stream().mapToInt(duel -> duel.getCompetitor1Score().stream().filter(Objects::nonNull).toList().size()).sum();`
	`275`	`+ return getDuels().stream().mapToInt(Duel::getCompetitor1ScoreValue).sum();`
`276`	`276`	`}`
`277`	`277`
`278`	`278`	`public Integer getScoreTeam2() {`
`279`		`- return getDuels().stream().mapToInt(duel -> duel.getCompetitor2Score().stream().filter(Objects::nonNull).toList().size()).sum();`
	`279`	`+ return getDuels().stream().mapToInt(Duel::getCompetitor2ScoreValue).sum();`
`280`	`280`	`}`
`281`	`281`	`}`
`282`	`282`
Original file line number	Diff line number	Diff line change
`@@ -202,4 +202,14 @@ public List<FightDTO> getByCompetitor(@Parameter(description = "Id of the compet`
`202`	`202`	`}`
`203`	`203`
`204`	`204`
	`205`	`+ @PreAuthorize("hasAnyAuthority(@securityService.viewerPrivilege, @securityService.editorPrivilege, @securityService.adminPrivilege,"`
	`206`	`+ + " @securityService.participantPrivilege)")`
	`207`	`+ @Operation(summary = "Checks if the scores are added from the competitor's name, to the center of the sheet.", security = @SecurityRequirement(name = "bearerAuth"))`
	`208`	`+ @GetMapping(value = "/scores-from-name-to-center/tournaments/{tournamentId}", produces = MediaType.APPLICATION_JSON_VALUE)`
	`209`	`+ public boolean scoresGoesFromCompetitorsNameToCenter(@Parameter(description = "Id of an existing tournament", required = true)`
	`210`	`+ @PathVariable("tournamentId") Integer tournamentId,`
	`211`	`+ HttpServletRequest request) {`
	`212`	`+ return getController().scoresGoesFromCompetitorsNameToCenter(tournamentId);`
	`213`	`+ }`
	`214`	`+`
`205`	`215`	`}`