nicer entities using lombok

pom.xml

@@ -167,6 +167,10 @@
             <groupId>com.google.code.gson</groupId>
             <artifactId>gson</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

src/main/java/app/data/entity/AbstractEntity.java

@@ -1,42 +1,29 @@
 package app.data.entity;
 
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
-import javax.persistence.MappedSuperclass;
+import lombok.Getter;
+import lombok.Setter;
 
+import javax.persistence.*;
+
+@Getter
+@Setter
 @MappedSuperclass
-public abstract class AbstractEntity { // TODO: Use this in your own entities (adapt annotations and equals())
+public abstract class AbstractEntity {
 
     @Id
-    @GeneratedValue
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id", nullable = false)
     private Integer id;
 
-    public Integer getId() {
-        return id;
-    }
-
-    public void setId(Integer id) {
-        this.id = id;
-    }
-
     @Override
     public int hashCode() {
-        if (id != null) {
-            return id.hashCode();
-        }
-        return super.hashCode();
+        return id != null ? id.hashCode() : super.hashCode();
     }
 
     @Override
     public boolean equals(Object obj) {
-        if (!(obj instanceof AbstractEntity)) {
-            return false; // null or other class
-        }
+        if (!(obj instanceof AbstractEntity)) return false; // null or other class
         AbstractEntity other = (AbstractEntity) obj;
-
-        if (id != null) {
-            return id.equals(other.id);
-        }
-        return super.equals(other);
+        return id != null ? id.equals(other.id) : super.equals(other);
     }
 }

src/main/java/app/data/entity/Game.java

@@ -1,78 +1,36 @@
 package app.data.entity;
 
+import lombok.Getter;
+import lombok.Setter;
+
 import javax.persistence.*;
-import java.util.Objects;
 
+@Getter
+@Setter
 @Entity
-@Table(name = "game", schema = "public", catalog = "chessleague")
-public class Game {
-    private Integer id;
-    private Boolean player1IsWhite;
-    private Integer result;
+@Table(name = "game",
+        schema = "public",
+        catalog = "chessleague")
+public class Game extends AbstractEntity {
+
+    @ManyToOne(cascade = CascadeType.DETACH)
+    @JoinColumn(name = "match",
+            referencedColumnName = "id",
+            nullable = false)
     private Match match;
-    private GameInfo gameInfo;
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "id", nullable = false)
-    public Integer getId() {
-        return id;
-    }
-
-    public void setId(Integer id) {
-        this.id = id;
-    }
 
     @Basic
-    @Column(name = "player1_is_white", nullable = false)
-    public Boolean getPlayer1IsWhite() {
-        return player1IsWhite;
-    }
-
-    public void setPlayer1IsWhite(Boolean player1IsWhite) {
-        this.player1IsWhite = player1IsWhite;
-    }
+    @Column(name = "player1_is_white",
+            nullable = false)
+    private Boolean player1IsWhite;
 
     @Basic
-    @Column(name = "result", nullable = false)
-    public Integer getResult() {
-        return result;
-    }
-
-    public void setResult(Integer result) {
-        this.result = result;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        Game that = (Game) o;
-        return Objects.equals(id, that.id) && Objects.equals(player1IsWhite, that.player1IsWhite) && Objects.equals(result, that.result);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(id, player1IsWhite, result);
-    }
-
-    @ManyToOne(cascade=CascadeType.DETACH)
-    @JoinColumn(name = "match", referencedColumnName = "id", nullable = false)
-    public Match getMatch() {
-        return match;
-    }
-
-    public void setMatch(Match match) {
-        this.match = match;
-    }
+    @Column(name = "result",
+            nullable = false)
+    private Integer result;
 
     @OneToOne(cascade = CascadeType.ALL)
-    @JoinColumn(name = "info", referencedColumnName = "id")
-    public GameInfo getGameInfo() {
-        return gameInfo;
-    }
-
-    public void setGameInfo(GameInfo gameInfo) {
-        this.gameInfo = gameInfo;
-    }
+    @JoinColumn(name = "info",
+            referencedColumnName = "id")
+    private GameInfo gameInfo;
 }

src/main/java/app/data/entity/GameInfo.java

@@ -1,176 +1,69 @@
 package app.data.entity;
 
+import lombok.Getter;
+import lombok.Setter;
+
 import javax.persistence.*;
-import java.util.Objects;
 
+@Getter
+@Setter
 @Entity
-@Table(name = "game_info", schema = "public", catalog = "chessleague")
-public class GameInfo {
-    private Integer id;
-    private String chessComId;
-    private Game game;
-    private String timeControl;
-    private String fen;
-    private Long endTime;
-    private String pgn;
-    private Boolean rated;
-    private String timeClass;
-    private String rules;
-    private Integer whiteRating;
-    private Integer blackRating;
-    private String whiteResult;
-    private String blackResult;
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "id", nullable = false)
-    public Integer getId() {
-        return id;
-    }
+@Table(name = "game_info",
+        schema = "public",
+        catalog = "chessleague")
+public class GameInfo extends AbstractEntity {
 
-    public void setId(Integer id) {
-        this.id = id;
-    }
+    @OneToOne(mappedBy = "gameInfo",
+            cascade = CascadeType.DETACH)
+    private Game game;
 
     @Basic
-    @Column(name = "chess_com_id", length = -1)
-    public String getChessComId() {
-        return chessComId;
-    }
-
-    public void setChessComId(String chessComId) {
-        this.chessComId = chessComId;
-    }
+    @Column(name = "chess_com_id")
+    private String chessComId;
 
     @Basic
-    @Column(name = "time_control", nullable = false)
-    public String getTimeControl() {
-        return timeControl;
-    }
-
-    public void setTimeControl(String format) {
-        this.timeControl = format;
-    }
+    @Column(name = "time_control",
+            nullable = false)
+    private String timeControl;
 
     @Basic
-    @Column(name = "fen", nullable = false)
-    public String getFen() {
-        return fen;
-    }
-
-    public void setFen(String fen) {
-        this.fen = fen;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        GameInfo that = (GameInfo) o;
-        return Objects.equals(id, that.id) && Objects.equals(chessComId, that.chessComId) && Objects.equals(timeControl, that.timeControl);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(id, chessComId, timeControl);
-    }
-
-    @OneToOne(mappedBy = "gameInfo", cascade = CascadeType.DETACH)
-    public Game getGame() {
-        return game;
-    }
-
-    public void setGame(Game game) {
-        this.game = game;
-    }
+    @Column(name = "fen",
+            nullable = false)
+    private String fen;
 
     @Basic
     @Column(name = "end_time") // TODO: make not nullable (you need the end times of the first matchday for that...)
-    public Long getEndTime() {
-        return endTime;
-    }
-
-    public void setEndTime(Long endTime) {
-        this.endTime = endTime;
-    }
+    private Long endTime;
 
     @Basic
     @Column(name = "pgn")
-    public String getPgn() {
-        return pgn;
-    }
-
-    public void setPgn(String pgn) {
-        this.pgn = pgn;
-    }
+    private String pgn;
 
     @Basic
     @Column(name = "rated")
-    public Boolean getRated() {
-        return rated;
-    }
-
-    public void setRated(Boolean rated) {
-        this.rated = rated;
-    }
+    private Boolean rated;
 
     @Basic
     @Column(name = "time_class")
-    public String getTimeClass() {
-        return timeClass;
-    }
-
-    public void setTimeClass(String timeClass) {
-        this.timeClass = timeClass;
-    }
+    private String timeClass;
 
     @Basic
     @Column(name = "rules")
-    public String getRules() {
-        return rules;
-    }
-
-    public void setRules(String rules) {
-        this.rules = rules;
-    }
+    private String rules;
 
     @Basic
     @Column(name = "white_rating")
-    public Integer getWhiteRating() {
-        return whiteRating;
-    }
-
-    public void setWhiteRating(Integer whiteRating) {
-        this.whiteRating = whiteRating;
-    }
+    private Integer whiteRating;
 
     @Basic
     @Column(name = "black_rating")
-    public Integer getBlackRating() {
-        return blackRating;
-    }
-
-    public void setBlackRating(Integer blackRating) {
-        this.blackRating = blackRating;
-    }
+    private Integer blackRating;
 
     @Basic
     @Column(name = "white_result")
-    public String getWhiteResult() {
-        return whiteResult;
-    }
-
-    public void setWhiteResult(String whiteResult) {
-        this.whiteResult = whiteResult;
-    }
+    private String whiteResult;
 
     @Basic
     @Column(name = "black_result")
-    public String getBlackResult() {
-        return blackResult;
-    }
-
-    public void setBlackResult(String blackResult) {
-        this.blackResult = blackResult;
-    }
+    private String blackResult;
 }

src/main/java/app/data/entity/Match.java

@@ -1,78 +1,40 @@
 package app.data.entity;
 
+import lombok.Getter;
+import lombok.Setter;
+
 import javax.persistence.*;
 import java.util.Collection;
-import java.util.Objects;
 
+@Getter
+@Setter
 @Entity
-@Table(name = "match", schema = "public", catalog = "chessleague")
-public class Match {
-    private Integer id;
-    private Collection<Game> games;
-    private Player player1;
-    private Player player2;
+@Table(name = "match",
+        schema = "public",
+        catalog = "chessleague")
+public class Match extends AbstractEntity {
+
+    @ManyToOne(cascade = CascadeType.DETACH)
+    @JoinColumn(name = "matchday",
+            referencedColumnName = "id",
+            nullable = false)
     private Matchday matchday;
 
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "id", nullable = false)
-    public Integer getId() {
-        return id;
-    }
-
-    public void setId(Integer id) {
-        this.id = id;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        Match that = (Match) o;
-        return Objects.equals(id, that.id);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(id);
-    }
-
-    @OneToMany(mappedBy = "match", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
-    public Collection<Game> getGames() {
-        return games;
-    }
-
-    public void setGames(Collection<Game> games) {
-        this.games = games;
-    }
-
-    @ManyToOne(cascade=CascadeType.DETACH)
-    @JoinColumn(name = "player1", referencedColumnName = "id", nullable = false)
-    public Player getPlayer1() {
-        return player1;
-    }
-
-    public void setPlayer1(Player player1) {
-        this.player1 = player1;
-    }
-
-    @ManyToOne(cascade=CascadeType.DETACH)
-    @JoinColumn(name = "player2", referencedColumnName = "id", nullable = false)
-    public Player getPlayer2() {
-        return player2;
-    }
-
-    public void setPlayer2(Player player2) {
-        this.player2 = player2;
-    }
+    @ManyToOne(cascade = CascadeType.DETACH)
+    @JoinColumn(name = "player1",
+            referencedColumnName = "id",
+            nullable = false)
+    private Player player1;
 
-    @ManyToOne(cascade=CascadeType.DETACH)
-    @JoinColumn(name = "matchday", referencedColumnName = "id", nullable = false)
-    public Matchday getMatchday() {
-        return matchday;
-    }
+    @ManyToOne(cascade = CascadeType.DETACH)
+    @JoinColumn(name = "player2",
+            referencedColumnName = "id",
+            nullable = false)
+    private Player player2;
 
-    public void setMatchday(Matchday matchday) {
-        this.matchday = matchday;
-    }
+    @OneToMany(mappedBy = "match",
+            fetch = FetchType.EAGER,
+            cascade = CascadeType.ALL,
+            orphanRemoval = true)
+    private Collection<Game> games;
 }

src/main/java/app/data/entity/Matchday.java

@@ -1,67 +1,32 @@
 package app.data.entity;
 
+import lombok.Getter;
+import lombok.Setter;
+
 import javax.persistence.*;
 import java.util.Collection;
-import java.util.Objects;
 
+@Getter
+@Setter
 @Entity
-@Table(name = "matchday", schema = "public", catalog = "chessleague")
-public class Matchday {
-    private Integer id;
-    private Integer number;
-    private Collection<Match> matches;
+@Table(name = "matchday",
+        schema = "public",
+        catalog = "chessleague")
+public class Matchday extends AbstractEntity {
+
+    @ManyToOne(cascade = CascadeType.DETACH)
+    @JoinColumn(name = "season",
+            referencedColumnName = "id",
+            nullable = false)
     private Season season;
 
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "id", nullable = false)
-    public Integer getId() {
-        return id;
-    }
-
-    public void setId(Integer id) {
-        this.id = id;
-    }
-
     @Basic
     @Column(name = "number", nullable = false)
-    public Integer getNumber() {
-        return number;
-    }
-
-    public void setNumber(Integer number) {
-        this.number = number;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        Matchday that = (Matchday) o;
-        return Objects.equals(id, that.id) && Objects.equals(number, that.number);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(id, number);
-    }
-
-    @OneToMany(mappedBy = "matchday", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
-    public Collection<Match> getMatches() {
-        return matches;
-    }
-
-    public void setMatches(Collection<Match> matches) {
-        this.matches = matches;
-    }
-
-    @ManyToOne(cascade=CascadeType.DETACH)
-    @JoinColumn(name = "season", referencedColumnName = "id", nullable = false)
-    public Season getSeason() {
-        return season;
-    }
+    private Integer number;
 
-    public void setSeason(Season season) {
-        this.season = season;
-    }
+    @OneToMany(mappedBy = "matchday",
+            fetch = FetchType.EAGER,
+            cascade = CascadeType.ALL,
+            orphanRemoval = true)
+    private Collection<Match> matches;
 }

src/main/java/app/data/entity/Player.java

@@ -1,89 +1,39 @@
 package app.data.entity;
 
+import lombok.Getter;
+import lombok.Setter;
+
 import javax.persistence.*;
 import java.util.Collection;
-import java.util.Objects;
 
+@Getter
+@Setter
 @Entity
-@Table(name = "player", schema = "public", catalog = "chessleague")
-public class Player {
-    private Integer id;
-    private String name;
-    private String nickname;
-    private Collection<Match> matchesAsPlayer1;
-    private Collection<Match> matchesAsPlayer2;
-    private PlayerInfo playerInfo;
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "id", nullable = false)
-    public Integer getId() {
-        return id;
-    }
-
-    public void setId(Integer id) {
-        this.id = id;
-    }
+@Table(name = "player",
+        schema = "public",
+        catalog = "chessleague")
+public class Player extends AbstractEntity {
 
     @Basic
-    @Column(name = "name", nullable = false, length = -1)
-    public String getName() {
-        return name;
-    }
-
-    public void setName(String name) {
-        this.name = name;
-    }
+    @Column(name = "name",
+            nullable = false)
+    private String name;
 
     @Basic
-    @Column(name = "nickname", nullable = false, length = -1)
-    public String getNickname() {
-        return nickname;
-    }
-
-    public void setNickname(String nickname) {
-        this.nickname = nickname;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        Player that = (Player) o;
-        return Objects.equals(id, that.id) && Objects.equals(name, that.name) && Objects.equals(nickname, that.nickname);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(id, name, nickname);
-    }
-
-    @OneToMany(mappedBy = "player1", cascade = CascadeType.DETACH)
-    public Collection<Match> getMatchesAsPlayer1() {
-        return matchesAsPlayer1;
-    }
-
-    public void setMatchesAsPlayer1(Collection<Match> matchesAsPlayer1) {
-        this.matchesAsPlayer1 = matchesAsPlayer1;
-    }
+    @Column(name = "nickname",
+            nullable = false)
+    private String nickname;
 
-    @OneToMany(mappedBy = "player2", cascade = CascadeType.DETACH)
-    public Collection<Match> getMatchesAsPlayer2() {
-        return matchesAsPlayer2;
-    }
+    @OneToMany(mappedBy = "player1",
+            cascade = CascadeType.DETACH)
+    private Collection<Match> matchesAsPlayer1;
 
-    public void setMatchesAsPlayer2(Collection<Match> matchesAsPlayer2) {
-        this.matchesAsPlayer2 = matchesAsPlayer2;
-    }
+    @OneToMany(mappedBy = "player2",
+            cascade = CascadeType.DETACH)
+    private Collection<Match> matchesAsPlayer2;
 
     @OneToOne(cascade = CascadeType.ALL)
-    @JoinColumn(name = "info", referencedColumnName = "id")
-    public PlayerInfo getPlayerInfo() {
-        return playerInfo;
-    }
-
-    public void setPlayerInfo(PlayerInfo playerInfo) {
-        this.playerInfo = playerInfo;
-    }
-
-}
+    @JoinColumn(name = "info",
+            referencedColumnName = "id")
+    private PlayerInfo playerInfo;
+}

src/main/java/app/data/entity/PlayerInfo.java

@@ -1,55 +1,23 @@
 package app.data.entity;
 
+import lombok.Getter;
+import lombok.Setter;
+
 import javax.persistence.*;
-import java.util.Objects;
 
+@Getter
+@Setter
 @Entity
-@Table(name = "player_info", schema = "public", catalog = "chessleague")
-public class PlayerInfo {
-    private Integer id;
-    private String url;
-    private Player player;
+@Table(name = "player_info",
+        schema = "public",
+        catalog = "chessleague")
+public class PlayerInfo extends AbstractEntity {
 
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "id", nullable = false)
-    public Integer getId() {
-        return id;
-    }
-
-    public void setId(Integer id) {
-        this.id = id;
-    }
+    @OneToOne(mappedBy = "playerInfo",
+            cascade = CascadeType.DETACH)
+    private Player player;
 
     @Basic
-    @Column(name = "url", length = -1)
-    public String getUrl() {
-        return url;
-    }
-
-    public void setUrl(String url) {
-        this.url = url;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        PlayerInfo that = (PlayerInfo) o;
-        return Objects.equals(id, that.id) && Objects.equals(url, that.url);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(id, url);
-    }
-
-    @OneToOne(mappedBy = "playerInfo", cascade = CascadeType.DETACH)
-    public Player getPlayer() {
-        return player;
-    }
-
-    public void setPlayer(Player player) {
-        this.player = player;
-    }
+    @Column(name = "url")
+    private String url;
 }

src/main/java/app/data/entity/Season.java

@@ -1,68 +1,31 @@
 package app.data.entity;
 
+import lombok.Getter;
+import lombok.Setter;
+
 import javax.persistence.*;
 import java.util.Collection;
-import java.util.Objects;
 
+@Getter
+@Setter
 @Entity
-@Table(name = "season", schema = "public", catalog = "chessleague")
-public class Season {
-    private Integer id;
-    private Integer yearStart;
-    private Integer yearEnd;
-    private Collection<Matchday> matchdays;
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "id", nullable = false)
-    public Integer getId() {
-        return id;
-    }
-
-    public void setId(Integer id) {
-        this.id = id;
-    }
+@Table(name = "season",
+        schema = "public",
+        catalog = "chessleague")
+public class Season extends AbstractEntity {
 
     @Basic
-    @Column(name = "year_start", nullable = false)
-    public Integer getYearStart() {
-        return yearStart;
-    }
-
-    public void setYearStart(Integer yearStart) {
-        this.yearStart = yearStart;
-    }
+    @Column(name = "year_start",
+            nullable = false)
+    private Integer yearStart;
 
     @Basic
-    @Column(name = "year_end", nullable = false)
-    public Integer getYearEnd() {
-        return yearEnd;
-    }
-
-    public void setYearEnd(Integer yearEnd) {
-        this.yearEnd = yearEnd;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        Season that = (Season) o;
-        return Objects.equals(id, that.id) && Objects.equals(yearStart, that.yearStart) && Objects.equals(yearEnd, that.yearEnd);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(id, yearStart, yearEnd);
-    }
-
-    @OneToMany(mappedBy = "season", cascade = CascadeType.ALL)
-    public Collection<Matchday> getMatchdays() {
-        return matchdays;
-    }
-
-    public void setMatchdays(Collection<Matchday> matchdays) {
-        this.matchdays = matchdays;
-    }
+    @Column(name = "year_end",
+            nullable = false)
+    private Integer yearEnd;
 
+    @OneToMany(mappedBy = "season",
+            cascade = CascadeType.ALL,
+            orphanRemoval = true)
+    private Collection<Matchday> matchdays;
 }

src/main/java/app/data/entity/example/SampleAddress.java

@@ -16,30 +16,39 @@ public class SampleAddress extends AbstractEntity {
     public String getStreet() {
         return street;
     }
+
     public void setStreet(String street) {
         this.street = street;
     }
+
     public String getPostalCode() {
         return postalCode;
     }
+
     public void setPostalCode(String postalCode) {
         this.postalCode = postalCode;
     }
+
     public String getCity() {
         return city;
     }
+
     public void setCity(String city) {
         this.city = city;
     }
+
     public String getState() {
         return state;
     }
+
     public void setState(String state) {
         this.state = state;
     }
+
     public String getCountry() {
         return country;
     }
+
     public void setCountry(String country) {
         this.country = country;
     }

src/main/java/app/data/entity/example/SamplePerson.java

@@ -19,42 +19,55 @@ public class SamplePerson extends AbstractEntity {
     public String getFirstName() {
         return firstName;
     }
+
     public void setFirstName(String firstName) {
         this.firstName = firstName;
     }
+
     public String getLastName() {
         return lastName;
     }
+
     public void setLastName(String lastName) {
         this.lastName = lastName;
     }
+
     public String getEmail() {
         return email;
     }
+
     public void setEmail(String email) {
         this.email = email;
     }
+
     public String getPhone() {
         return phone;
     }
+
     public void setPhone(String phone) {
         this.phone = phone;
     }
+
     public LocalDate getDateOfBirth() {
         return dateOfBirth;
     }
+
     public void setDateOfBirth(LocalDate dateOfBirth) {
         this.dateOfBirth = dateOfBirth;
     }
+
     public String getOccupation() {
         return occupation;
     }
+
     public void setOccupation(String occupation) {
         this.occupation = occupation;
     }
+
     public boolean isImportant() {
         return important;
     }
+
     public void setImportant(boolean important) {
         this.important = important;
     }

src/main/java/app/data/service/ChessComService.java

@@ -8,9 +8,9 @@ import app.data.entity.GameInfo;
 import app.data.entity.Match;
 import app.data.entity.Player;
 import app.utils.ChessComUtils;
+import app.utils.HttpUtils;
 import app.utils.MatchUtils;
 import app.utils.TimeControl;
-import app.utils.HttpUtils;
 import com.google.gson.Gson;
 import org.springframework.lang.NonNull;
 import org.springframework.stereotype.Service;

src/main/java/app/data/service/MatchdayService.java

@@ -57,7 +57,7 @@ public class MatchdayService extends CrudService<Matchday, Integer> {
         if (matchdaysWithActivity.isEmpty()) {
             return getFirstMatchday(season);
         }
-        return Optional.of(matchdaysWithActivity.get(matchdaysWithActivity.size()-1));
+        return Optional.of(matchdaysWithActivity.get(matchdaysWithActivity.size() - 1));
     }
 
     public boolean hasActivity(@NonNull Matchday matchday) {

src/main/java/app/data/service/PlayerService.java

@@ -53,49 +53,70 @@ public class PlayerService extends CrudService<Player, Integer> {
         }
 
         private List<PlayerForTable> getPlayersForTableSorted(boolean calcDiffToLastMatchday) {
-            List<PlayerForTable> playerForTableList = players.stream()
-                    .map(this::getPlayerForTable)
-                    .sorted(Comparator.comparingDouble(PlayerForTable::getGamePointsForSelf).reversed())
-                    .sorted(Comparator.comparingDouble(PlayerForTable::getGamePointDiff).reversed())
-                    .sorted(Comparator.comparingInt(PlayerForTable::getMatchPoints).reversed())
-                    .collect(Collectors.toList());
+            List<PlayerForTable> playerForTableList = calcSortedPlayerForTableList();
             int offset = 0;
             PlayerForTable lastPlayer;
             PlayerForTable currentPlayer;
             for (int i = 0; i < playerForTableList.size(); i++) {
                 currentPlayer = playerForTableList.get(i);
-                if (i > 0) {
-                    lastPlayer = playerForTableList.get(i - 1);
-                    // TODO: add direct comparison below
-                    if (Objects.equals(currentPlayer.getMatchPoints(), lastPlayer.getMatchPoints())
-                            && Objects.equals(currentPlayer.getGamePointsForSelf(), lastPlayer.getGamePointsForSelf())
-                            && Objects.equals(currentPlayer.getGamePointsForOpponents(), lastPlayer.getGamePointsForOpponents())) {
-                        offset += 1;
-                    } else {
-                        offset = 0;
-                    }
-                }
+                offset = getOffset(playerForTableList, offset, currentPlayer, i);
                 currentPlayer.setPlace(i + 1 - offset);
                 currentPlayer.setPlaceString(offset == 0 ? String.valueOf(i + 1) : "");
             }
-            if (calcDiffToLastMatchday) {
-                if (matchdays.size() < 2) {
-                    playerForTableList.forEach(playerForTable -> playerForTable.setPlaceDiffToLastMatchday(Integer.MAX_VALUE));
-                } else {
-                    List<PlayerForTable> lastMatchdayList = new PlayerForTableProvider(matchdays.get(matchdays.size() - 2)).getPlayersForTableSorted(false);
-                    for (PlayerForTable playerForTable : playerForTableList) {
-                        int placeLastMatchday = lastMatchdayList.stream()
-                                .filter(playerForTableLastMatchday -> playerForTable.getPlayer().equals(playerForTableLastMatchday.getPlayer()))
-                                .findFirst()
-                                .map(PlayerForTable::getPlace)
-                                .orElseThrow();
-                        playerForTable.setPlaceDiffToLastMatchday(placeLastMatchday - playerForTable.getPlace());
-                    }
-                }
-            }
+            if (calcDiffToLastMatchday) calcAndSetPlaceDiffToLastMatchday(playerForTableList);
             return playerForTableList;
         }
 
+        private int getOffset(List<PlayerForTable> playerForTableList, int offset, PlayerForTable currentPlayer, int i) {
+            PlayerForTable lastPlayer;
+            if (i > 0) {
+                lastPlayer = playerForTableList.get(i - 1);
+                // TODO: add direct comparison below
+                if (playersHaveCompletelyEqualScores(lastPlayer, currentPlayer))
+                    return offset + 1;
+                return 0;
+            }
+            return offset;
+        }
+
+        private boolean playersHaveCompletelyEqualScores(PlayerForTable lastPlayer, PlayerForTable currentPlayer) {
+            return Objects.equals(currentPlayer.getMatchPoints(), lastPlayer.getMatchPoints())
+                    && Objects.equals(currentPlayer.getGamePointsForSelf(), lastPlayer.getGamePointsForSelf())
+                    && Objects.equals(currentPlayer.getGamePointsForOpponents(), lastPlayer.getGamePointsForOpponents());
+        }
+
+        private List<PlayerForTable> calcSortedPlayerForTableList() {
+            return players.stream()
+                    .map(this::getPlayerForTable)
+                    .sorted(Comparator.comparingDouble(PlayerForTable::getGamePointsForSelf).reversed())
+                    .sorted(Comparator.comparingDouble(PlayerForTable::getGamePointDiff).reversed())
+                    .sorted(Comparator.comparingInt(PlayerForTable::getMatchPoints).reversed())
+                    .collect(Collectors.toList());
+        }
+
+        private void calcAndSetPlaceDiffToLastMatchday(List<PlayerForTable> playerForTableList) {
+            if (matchdays.size() < 2) {
+                playerForTableList.forEach(playerForTable -> playerForTable.setPlaceDiffToLastMatchday(Integer.MAX_VALUE));
+                return;
+            }
+            List<PlayerForTable> listForLastMatchday = getListForLastMatchday();
+            playerForTableList.forEach(playerForTable -> calcAndSetPlaceDiffToLastMatchday(playerForTable, listForLastMatchday));
+
+        }
+
+        private void calcAndSetPlaceDiffToLastMatchday(PlayerForTable playerForTable, List<PlayerForTable> listForLastMatchday) {
+            int placeLastMatchday = listForLastMatchday.stream()
+                    .filter(playerForTableLastMatchday -> playerForTable.getPlayer().equals(playerForTableLastMatchday.getPlayer()))
+                    .findFirst()
+                    .map(PlayerForTable::getPlace)
+                    .orElseThrow();
+            playerForTable.setPlaceDiffToLastMatchday(placeLastMatchday - playerForTable.getPlace());
+        }
+
+        private List<PlayerForTable> getListForLastMatchday() {
+            return new PlayerForTableProvider(matchdays.get(matchdays.size() - 2)).getPlayersForTableSorted(false);
+        }
+
         private PlayerForTable getPlayerForTable(Player player) {
             List<CalculatedMatch> matchesAsPlayer1 = getMatchesAsPlayer1(player);
             List<CalculatedMatch> matchesAsPlayer2 = getMatchesAsPlayer2(player);
@@ -107,17 +128,10 @@ public class PlayerService extends CrudService<Player, Integer> {
             int amountOfMatchesLost = map.get(WinState.LOST).size();
 
             int amountOfMatches = amountOfMatchesWon + amountOfMatchesDrawn + amountOfMatchesLost;
-
             int matchPoints = amountOfMatchesWon * 2 + amountOfMatchesDrawn;
 
-            double gamePointsForSelf = 0;
-            gamePointsForSelf += matchesAsPlayer1.stream().mapToDouble(CalculatedMatch::getScore1).sum();
-            gamePointsForSelf += matchesAsPlayer2.stream().mapToDouble(CalculatedMatch::getScore2).sum();
-
-            double gamePointsForOpponents = 0;
-            gamePointsForOpponents += matchesAsPlayer1.stream().mapToDouble(CalculatedMatch::getScore2).sum();
-            gamePointsForOpponents += matchesAsPlayer2.stream().mapToDouble(CalculatedMatch::getScore1).sum();
-
+            double gamePointsForSelf = getGamePointsForSelf(matchesAsPlayer1, matchesAsPlayer2);
+            double gamePointsForOpponents = getGamePointsForOpponents(matchesAsPlayer1, matchesAsPlayer2);
             double gamePointDiff = gamePointsForSelf - gamePointsForOpponents;
 
             return new PlayerForTable(player,
@@ -143,6 +157,20 @@ public class PlayerService extends CrudService<Player, Integer> {
                     .collect(Collectors.toList());
         }
 
+        private double getGamePointsForSelf(List<CalculatedMatch> matchesAsPlayer1, List<CalculatedMatch> matchesAsPlayer2) {
+            double gamePointsForSelf = 0;
+            gamePointsForSelf += matchesAsPlayer1.stream().mapToDouble(CalculatedMatch::getScore1).sum();
+            gamePointsForSelf += matchesAsPlayer2.stream().mapToDouble(CalculatedMatch::getScore2).sum();
+            return gamePointsForSelf;
+        }
+
+        private double getGamePointsForOpponents(List<CalculatedMatch> matchesAsPlayer1, List<CalculatedMatch> matchesAsPlayer2) {
+            double gamePointsForOpponents = 0;
+            gamePointsForOpponents += matchesAsPlayer1.stream().mapToDouble(CalculatedMatch::getScore2).sum();
+            gamePointsForOpponents += matchesAsPlayer2.stream().mapToDouble(CalculatedMatch::getScore1).sum();
+            return gamePointsForOpponents;
+        }
+
         private Map<WinState, List<CalculatedMatch>> getWinStateLists(List<CalculatedMatch> matchesAsPlayer1, List<CalculatedMatch> matchesAsPlayer2) {
             Map<WinState, List<CalculatedMatch>> map = new HashMap<>();
             map.put(WinState.WON, new ArrayList<>());

src/main/java/app/gameimage/GameImageGenerator.java

@@ -14,7 +14,8 @@ public class GameImageGenerator {
     private static final Set<Character> BLANKS = Set.of('1', '2', '3', '4', '5', '6', '7', '8');
     private static final Character ROW_DELIMITER = '/';
 
-    private GameImageGenerator() {}
+    private GameImageGenerator() {
+    }
 
     public static BufferedImage generateImage(String fen) {
         BufferedImage image = GameImageUtils.readImage("board");

src/main/java/app/gameimage/GameImageService.java

@@ -12,7 +12,7 @@ import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.util.Optional;
 
-import static app.gameimage.GameImageGenerator.*;
+import static app.gameimage.GameImageGenerator.generateImage;
 import static app.gameimage.GameImageUtils.*;
 
 @Service

src/main/java/app/gameimage/GameImageUtils.java

@@ -1,13 +1,10 @@
 package app.gameimage;
 
 import app.data.entity.Game;
-import com.vaadin.flow.component.html.Image;
-import com.vaadin.flow.server.StreamResource;
 import org.apache.commons.io.FileUtils;
 
 import javax.imageio.ImageIO;
 import java.awt.image.BufferedImage;
-import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.IOException;
 

src/main/java/app/navigation/Navigation.java

@@ -306,9 +306,11 @@ public class Navigation implements HasUrlParameter<String> {
     public Optional<String> getSeasonParam() {
         return getSelectedSeason().map(EntityStringUtils::getSeasonStringForURL);
     }
+
     public Optional<String> getMatchdayParam() {
         return getSelectedMatchday().map(EntityStringUtils::getMatchdayStringForURL);
     }
+
     public Optional<String> getMatchParam() {
         return getSelectedMatch().map(EntityStringUtils::getMatchStringForURL);
     }

src/main/java/app/navigation/NavigationService.java

@@ -3,7 +3,6 @@ package app.navigation;
 import app.data.service.MatchService;
 import app.data.service.MatchdayService;
 import app.data.service.SeasonService;
-import app.navigation.Navigation;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 

src/main/java/app/utils/EntityComponentUtils.java

@@ -5,7 +5,8 @@ import com.vaadin.flow.component.html.Label;
 import com.vaadin.flow.component.orderedlayout.HorizontalLayout;
 
 public class EntityComponentUtils {
-    private EntityComponentUtils(){}
+    private EntityComponentUtils() {
+    }
 
     public static HorizontalLayout getPlayerLabel(Player player) {
         Label name = new Label(player.getName());

src/main/java/app/utils/EntityStringUtils.java

@@ -38,7 +38,7 @@ public class EntityStringUtils {
         return getSeasonString(season);
     }
 
-    public static String getMatchdayString(Matchday matchday ) {
+    public static String getMatchdayString(Matchday matchday) {
         return matchday.getNumber().toString();
     }
 

src/main/java/app/utils/TimeControl.java

@@ -1,7 +1,5 @@
 package app.utils;
 
-import java.sql.Time;
-
 public enum TimeControl {
     TEN_MINUTES,
     FIVE_MINUTES,

src/main/java/app/utils/VaadinUtils.java

@@ -1,7 +1,6 @@
 package app.utils;
 
 import app.data.entity.Player;
-import com.vaadin.flow.component.icon.Icon;
 import com.vaadin.flow.data.renderer.TemplateRenderer;
 import com.vaadin.flow.function.ValueProvider;
 

src/main/java/app/views/example/cardlist/CardListView.java

@@ -140,7 +140,7 @@ public class CardListView extends Div implements AfterNavigationObserver {
     }
 
     private static Person createPerson(String image, String name, String date, String post, String likes,
-            String comments, String shares) {
+                                       String comments, String shares) {
         Person p = new Person();
         p.setImage(image);
         p.setName(name);

src/main/java/app/views/main/MainView.java

@@ -1,6 +1,5 @@
 package app.views.main;
 
-import app.views.match.MatchView;
 import app.views.matchday.MatchdayView;
 import app.views.table.TableView;
 import com.vaadin.flow.component.Component;

src/main/java/app/views/match/components/EditMatchCard.java

@@ -13,8 +13,6 @@ import com.vaadin.flow.component.ClickEvent;
 import com.vaadin.flow.component.ComponentEventListener;
 import com.vaadin.flow.component.UI;
 import com.vaadin.flow.component.button.Button;
-import com.vaadin.flow.component.formlayout.FormLayout;
-import com.vaadin.flow.component.formlayout.FormLayout.ResponsiveStep;
 import com.vaadin.flow.component.html.Label;
 import com.vaadin.flow.component.icon.Icon;
 import com.vaadin.flow.component.icon.VaadinIcon;
@@ -27,7 +25,6 @@ import java.util.*;
 
 import static app.utils.TimeControl.*;
 import static com.vaadin.flow.component.button.ButtonVariant.LUMO_PRIMARY;
-import static com.vaadin.flow.component.formlayout.FormLayout.ResponsiveStep.LabelsPosition.ASIDE;
 
 public class EditMatchCard extends VerticalLayout {
 

src/main/java/app/views/match/components/utils/GameCardUtils.java

@@ -2,28 +2,20 @@ package app.views.match.components.utils;
 
 import app.data.entity.Game;
 import app.data.entity.Player;
-import app.gameimage.GameImageUtils;
 import app.utils.ChessComUtils;
 import app.utils.EntityComponentUtils;
 import app.utils.TimeControl;
 import com.vaadin.flow.component.button.Button;
 import com.vaadin.flow.component.button.ButtonVariant;
 import com.vaadin.flow.component.html.Div;
-import com.vaadin.flow.component.html.Image;
 import com.vaadin.flow.component.html.Label;
 import com.vaadin.flow.component.icon.Icon;
 import com.vaadin.flow.component.icon.VaadinIcon;
 import com.vaadin.flow.component.orderedlayout.FlexComponent;
 import com.vaadin.flow.component.orderedlayout.HorizontalLayout;
-import com.vaadin.flow.server.StreamResource;
-import org.apache.commons.io.FileUtils;
 
-import java.io.ByteArrayInputStream;
-import java.io.File;
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 public class GameCardUtils {
     private GameCardUtils() {

src/main/java/app/views/navigation/NavigationViewBase.java

@@ -1,9 +1,9 @@
 package app.views.navigation;
 
 import app.navigation.Navigation;
-import app.navigation.components.NavigationHeader;
 import app.navigation.NavigationLevel;
 import app.navigation.NavigationService;
+import app.navigation.components.NavigationHeader;
 import com.vaadin.flow.component.orderedlayout.FlexComponent;
 import com.vaadin.flow.component.orderedlayout.VerticalLayout;
 import com.vaadin.flow.router.BeforeEvent;

src/main/resources/application.properties

@@ -1,9 +1,9 @@
 server.port=${PORT:8080}
 # Ensure application is run in Vaadin 14/npm mode
-vaadin.compatibilityMode = false
-logging.level.org.atmosphere = warn
-
-# To improve the performance during development. 
+# suppress inspection "SpringBootApplicationProperties"
+vaadin.compatibilityMode=false
+logging.level.org.atmosphere=warn
+# To improve the performance during development.
 # For more information https://vaadin.com/docs/v14/flow/spring/tutorial-spring-configuration.html#special-configuration-parameters
 # vaadin.whitelisted-packages= org/vaadin/example
 spring.datasource.initialization-mode=always