Merge pull request 'Add event grouping' (#57) from event-brackets into main

Reviewed-on: SteamWar/SteamWar#57
Reviewed-by: YoyoNow <yoyonow@noreply.localhost>

CommonCore/SQL/src/de/steamwar/sql/EventFight.java

@@ -37,6 +37,8 @@ public class EventFight implements Comparable<EventFight> {
 
     private static final Table<EventFight> table = new Table<>(EventFight.class);
     private static final SelectStatement<EventFight> byId = table.select(Table.PRIMARY);
+    private static final SelectStatement<EventFight> byGroup = new SelectStatement<EventFight>(table, "SELECT * FROM EventFight WHERE GroupID = ? ORDER BY StartTime ASC");
+    private static final SelectStatement<EventFight> byGroupLast = new SelectStatement<EventFight>(table, "SELECT * FROM EventFight WHERE GroupID = ? ORDER BY StartTime DESC LIMIT 1");
     private static final SelectStatement<EventFight> allComing = new SelectStatement<>(table, "SELECT * FROM EventFight WHERE StartTime > now() ORDER BY StartTime ASC");
     private static final SelectStatement<EventFight> event = new SelectStatement<>(table, "SELECT * FROM EventFight WHERE EventID = ? ORDER BY StartTime ASC");
     private static final SelectStatement<EventFight> activeFights = new SelectStatement<>(table, "SELECT * FROM EventFight WHERE Fight IS NOT NULL AND StartTime < now() AND DATEDIFF(StartTime, now()) < 0");
@@ -46,6 +48,7 @@ public class EventFight implements Comparable<EventFight> {
 
     private static final Statement create = table.insertFields(true, "eventID", "startTime", "spielmodus", "map", "teamBlue", "teamRed", "spectatePort");
     private static final Statement update = table.update(Table.PRIMARY, "startTime", "spielModus", "map", "teamBlue", "teamRed", "spectatePort");
+    private static final Statement setGroup = table.update(Table.PRIMARY, "GroupID");
     private static final Statement delete = table.delete(Table.PRIMARY);
 
     @Getter
@@ -55,6 +58,14 @@ public class EventFight implements Comparable<EventFight> {
         return byId.select(fightID);
     }
 
+    public static List<EventFight> get(EventGroup group) {
+        return byGroup.listSelect(group.getId());
+    }
+
+    public static Optional<EventFight> getLast(EventGroup group) {
+        return Optional.ofNullable(byGroupLast.select(group.getId()));
+    }
+
     public static void loadAllComingFights() {
         fights.clear();
         fights.addAll(allComing.listSelect());
@@ -89,6 +100,10 @@ public class EventFight implements Comparable<EventFight> {
     private final int fightID;
     @Getter
     @Setter
+    @Field(nullable = true, def = "null")
+    private Integer groupId;
+    @Getter
+    @Setter
     @Field
     private Timestamp startTime;
     @Getter
@@ -112,11 +127,35 @@ public class EventFight implements Comparable<EventFight> {
     @Field(nullable = true)
     private Integer spectatePort;
     @Getter
+    @Setter
+    @Field(def = "1")
+    private int bestOf;
+    @Getter
     @Field(def = "0")
     private int ergebnis;
     @Field(nullable = true)
     private int fight;
 
+    public Optional<EventGroup> getGroup() {
+        return Optional.ofNullable(groupId).flatMap(EventGroup::get);
+    }
+
+    public Optional<Team> getWinner() {
+        if(ergebnis == 0)
+            return Optional.empty();
+        return Optional.ofNullable(ergebnis == 1 ? Team.get(teamBlue) : Team.get(teamRed));
+    }
+
+    public Optional<Team> getLosser() {
+        if(ergebnis == 0)
+            return Optional.empty();
+        return Optional.ofNullable(ergebnis == 1 ? Team.get(teamRed) : Team.get(teamBlue));
+    }
+
+    public List<EventRelation> getDependents() {
+        return EventRelation.getFightRelations(this);
+    }
+
     public void setErgebnis(int winner) {
         this.ergebnis = winner;
         setResult.update(winner, fightID);
@@ -128,6 +167,11 @@ public class EventFight implements Comparable<EventFight> {
         setFight.update(fight, fightID);
     }
 
+    public void setGroup(Integer group) {
+        setGroup.update(group, fightID);
+        this.groupId = group;
+    }
+
     public boolean hasFinished() {
         return fight != 0 || ergebnis != 0;
     }

CommonCore/SQL/src/de/steamwar/sql/EventGroup.java

@@ -0,0 +1,173 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.sql;
+
+import de.steamwar.sql.internal.*;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@Getter
+@Setter
+public class EventGroup {
+    static {
+        SqlTypeMapper.ordinalEnumMapper(EventGroupType.class);
+    }
+
+    private static final Table<EventGroup> table = new Table<>(EventGroup.class);
+
+    private static final SelectStatement<EventGroup> get = table.select(Table.PRIMARY);
+    private static final SelectStatement<EventGroup> byEvent = new SelectStatement<>(table, "SELECT * FROM EventGroup WHERE EventID = ?");
+
+    private static final Statement insert = table.insertFields(true, "EventID", "Name", "Type");
+    private static final Statement update = table.update(Table.PRIMARY, "Name", "Type", "PointsPerWin", "PointsPerLoss", "PointsPerDraw");
+    private static final Statement delete = table.delete(Table.PRIMARY);
+
+    public static List<EventGroup> get(Event eventID) {
+        return byEvent.listSelect(eventID.getEventID());
+    }
+
+    public static EventGroup create(Event event, String name, EventGroupType type) {
+        int key = insert.insertGetKey(event.getEventID(), name, type);
+        return EventGroup.get(key).get();
+    }
+
+    public static Optional<EventGroup> get(int id) {
+        return Optional.ofNullable(get.select(id));
+    }
+
+    @Field(keys = Table.PRIMARY)
+    private final int id;
+
+    @Field(keys = "EVENT_NAME")
+    private int eventID;
+
+    @Field(keys = "EVENT_NAME")
+    private String name;
+
+    @Field
+    private EventGroupType type;
+
+    @Field
+    private int pointsPerWin;
+
+    @Field
+    private int pointsPerLoss;
+
+    @Field
+    private int pointsPerDraw;
+
+    public EventGroup(int id, int eventID, String name, EventGroupType type, int pointsPerWin, int pointsPerLoss, int pointsPerDraw) {
+        this.id = id;
+        this.eventID = eventID;
+        this.name = name;
+        this.type = type;
+        this.pointsPerWin = pointsPerWin;
+        this.pointsPerLoss = pointsPerLoss;
+        this.pointsPerDraw = pointsPerDraw;
+    }
+
+    private Map<Team, Integer> points;
+
+    public List<EventFight> getFights() {
+        return EventFight.get(this);
+    }
+
+    public Set<Integer> getTeamsId() {
+        return getFights().stream().flatMap(fight -> Stream.of(fight.getTeamBlue(), fight.getTeamRed()))
+                .collect(Collectors.toSet());
+    }
+
+    public Set<Team> getTeams() {
+        return getTeamsId().stream().map(Team::get).collect(Collectors.toSet());
+    }
+
+    public Optional<EventFight> getLastFight() {
+        return EventFight.getLast(this);
+    }
+
+    public List<EventRelation> getDependents() {
+        return EventRelation.getGroupRelations(this);
+    }
+
+    public Map<Team, Integer> calculatePoints() {
+        if (points == null) {
+            Map<Integer, Integer> p = getTeamsId().stream().collect(Collectors.toMap(team -> team, team -> 0));
+
+            for (EventFight fight : getFights()) {
+                int blueTeamAdd = 0;
+                int redTeamAdd = 0;
+
+                if (!fight.hasFinished()) {
+                    continue;
+                }
+
+                switch (fight.getErgebnis()) {
+                    case 1:
+                        blueTeamAdd += pointsPerWin;
+                        redTeamAdd += pointsPerLoss;
+                        break;
+                    case 2:
+                        blueTeamAdd += pointsPerLoss;
+                        redTeamAdd += pointsPerWin;
+                        break;
+                    case 0:
+                        if (fight.getFightID() != 0) {
+                            blueTeamAdd += pointsPerDraw;
+                            redTeamAdd += pointsPerDraw;
+                        }
+                        break;
+                }
+
+                p.put(fight.getTeamBlue(), p.get(fight.getTeamBlue()) + blueTeamAdd);
+                p.put(fight.getTeamRed(), p.get(fight.getTeamRed()) + redTeamAdd);
+            }
+
+            points = p.entrySet().stream().collect(Collectors.toMap(integerIntegerEntry -> Team.get(integerIntegerEntry.getKey()), Map.Entry::getValue));
+        }
+
+        return points;
+    }
+
+    public void update(String name, EventGroupType type, int pointsPerWin, int pointsPerLoss, int pointsPerDraw) {
+        update.update(name, type, pointsPerWin, pointsPerLoss, pointsPerDraw, id);
+        this.name = name;
+        this.type = type;
+        this.pointsPerWin = pointsPerWin;
+        this.pointsPerLoss = pointsPerLoss;
+        this.pointsPerDraw = pointsPerDraw;
+    }
+
+    public boolean needsTieBreak() {
+        return calculatePoints().values().stream().sorted().limit(2).distinct().count() < 2;
+    }
+
+    public void delete() {
+        delete.update(id);
+    }
+
+    public static enum EventGroupType {
+        GROUP_STAGE,
+        ELIMINATION_STAGE
+    }
+}

CommonCore/SQL/src/de/steamwar/sql/EventRelation.java

@@ -0,0 +1,191 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.sql;
+
+import de.steamwar.sql.internal.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+@AllArgsConstructor
+@Getter
+@Setter
+public class EventRelation {
+
+    static {
+        SqlTypeMapper.ordinalEnumMapper(FightTeam.class);
+        SqlTypeMapper.ordinalEnumMapper(FromType.class);
+    }
+
+    private static final Table<EventRelation> table = new Table<>(EventRelation.class);
+
+    private static final SelectStatement<EventRelation> get = new SelectStatement<>(table, "SELECT * FROM EventRelation WHERE FromType = ? AND FromId = ?");
+    private static final SelectStatement<EventRelation> byId = new SelectStatement<>(table, "SELECT * FROM EventRelation WHERE id = ?");
+    private static final SelectStatement<EventRelation> byEvent = new SelectStatement<>(table, "SELECT ER.* FROM EventRelation ER JOIN EventFight EF ON EF.id = ER.fightId WHERE EF.EventID = ?");
+    private static final Statement insert = table.insertAll(true);
+    private static final Statement update = table.update(Table.PRIMARY, "fromType", "fromId", "fromPlace");
+    private static final Statement updateTeam = table.update(Table.PRIMARY, "fightTeam");
+    private static final Statement delete = table.delete(Table.PRIMARY);
+
+    public static List<EventRelation> get(Event event) {
+        return byId.listSelect(event.getEventID());
+    }
+
+    public static EventRelation get(int id) {
+        return byId.select(id);
+    }
+
+    public static List<EventRelation> getFightRelations(EventFight fight) {
+        return get.listSelect(FromType.FIGHT, fight.getFightID());
+    }
+
+    public static List<EventRelation> getGroupRelations(EventGroup group) {
+        return get.listSelect(FromType.GROUP, group.getId());
+    }
+
+    public static EventRelation create(EventFight fight, FightTeam fightTeam, FromType fromType, int fromId, int fromPlace) {
+        int id = insert.insertGetKey(fight.getFightID(), fightTeam, fromType, fromId, fromPlace);
+        return get(id);
+    }
+
+    @Field(keys = Table.PRIMARY)
+    private final int id;
+
+    @Field
+    private int fightId;
+
+    @Field
+    private FightTeam fightTeam;
+
+    @Field
+    private FromType fromType;
+
+    @Field
+    private int fromId;
+
+    @Field
+    private int fromPlace;
+
+    public EventFight getFight() {
+        return EventFight.get(fightId);
+    }
+
+    public Optional<EventFight> getFromFight() {
+        if(fromType == FromType.FIGHT) {
+            return Optional.of(EventFight.get(fromId));
+        } else {
+            return Optional.empty();
+        }
+    }
+
+    public Optional<EventGroup> getFromGroup() {
+        if(fromType == FromType.GROUP) {
+            return EventGroup.get(fromId);
+        } else {
+            return Optional.empty();
+        }
+    }
+
+    public void delete() {
+        delete.update(id);
+    }
+
+    public void setUpdateTeam(FightTeam team) {
+        updateTeam.update(id, team);
+        this.fightTeam = team;
+    }
+
+    public void setFromFight(EventFight fight, int place) {
+        setFrom(fight.getFightID(), place, FromType.FIGHT);
+    }
+
+    public void setFromGroup(EventGroup group, int place) {
+        setFrom(group.getId(), place, FromType.GROUP);
+    }
+
+    private void setFrom(int id, int place, FromType type) {
+        update.update(id, type, id, place);
+        this.fromType = type;
+        this.fromId = id;
+        this.fromPlace = place;
+    }
+
+    public Optional<Team> getAdvancingTeam() {
+        if (fromType == FromType.FIGHT) {
+            if (fromPlace == 0) {
+                return getFromFight().flatMap(EventFight::getWinner);
+            } else {
+                return getFromFight().flatMap(EventFight::getLosser);
+            }
+        } else if (fromType == FromType.GROUP) {
+            return getFromGroup().map(EventGroup::calculatePoints)
+                    .flatMap(points -> points.entrySet().stream()
+                            .sorted(Map.Entry.comparingByValue())
+                            .skip(fromPlace)
+                            .findFirst()
+                            .map(Map.Entry::getKey));
+        } else {
+            return Optional.empty();
+        }
+    }
+
+    public boolean apply() {
+        Optional<Integer> team = getAdvancingTeam().map(Team::getTeamId);
+        if(!team.isPresent())
+            return false;
+
+        EventFight fight = getFight();
+        if(fightTeam == FightTeam.RED) {
+            fight.update(
+                    fight.getStartTime(),
+                    fight.getSpielmodus(),
+                    fight.getMap(),
+                    team.get(),
+                    fight.getTeamBlue(),
+                    fight.getSpectatePort()
+            );
+        } else {
+            fight.update(
+                    fight.getStartTime(),
+                    fight.getSpielmodus(),
+                    fight.getMap(),
+                    fight.getTeamRed(),
+                    team.get(),
+                    fight.getSpectatePort()
+            );
+        }
+
+        return true;
+    }
+
+    public static enum FightTeam {
+        RED,
+        BLUE
+    }
+
+    public static enum FromType {
+        FIGHT,
+        GROUP
+    }
+}