Feat: Add basic field validations to domain entities

src/main/java/cat/udl/eps/softarch/fll/domain/Award.java

@@ -50,6 +50,18 @@ public class Award extends UriEntity<Long> {
 	@JsonIdentityReference(alwaysAsId = true)
 	private Team winner;
 
+	public static Award create(String name, Edition edition, Team winner) {
+		DomainValidation.requireNonBlank(name, "name");
+		DomainValidation.requireNonNull(edition, "edition");
+		DomainValidation.requireNonNull(winner, "winner");
+
+		Award award = new Award();
+		award.name = name;
+		award.edition = edition;
+		award.winner = winner;
+		return award;
+	}
+
 	@Override
 	public Long getId() {
 		return this.id;

src/main/java/cat/udl/eps/softarch/fll/domain/Coach.java

@@ -1,7 +1,5 @@
 package cat.udl.eps.softarch.fll.domain;
 
-import java.util.HashSet;
-import java.util.Set;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.GeneratedValue;
@@ -13,6 +11,8 @@
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.ToString;
+import java.util.HashSet;
+import java.util.Set;
 
 @Entity
 @Data
@@ -30,11 +30,21 @@ public class Coach extends UriEntity<Integer> {
 	@NotBlank
 	@Email
 	@Column(unique = true)
-
 	private String emailAddress;
+
 	private String phoneNumber;
 
 	@ManyToMany(mappedBy = "trainedBy")
 	@ToString.Exclude
 	private Set<Team> teams = new HashSet<>();
+
+	public static Coach create(String name, String emailAddress) {
+		DomainValidation.requireNonBlank(name, "name");
+		DomainValidation.requireValidEmail(emailAddress, "emailAddress");
+
+		Coach coach = new Coach();
+		coach.name = name;
+		coach.emailAddress = emailAddress;
+		return coach;
+	}
 }

src/main/java/cat/udl/eps/softarch/fll/domain/CompetitionTable.java

@@ -1,7 +1,5 @@
 package cat.udl.eps.softarch.fll.domain;
 
-import java.util.ArrayList;
-import java.util.List;
 import com.fasterxml.jackson.annotation.JsonManagedReference;
 import jakarta.persistence.CascadeType;
 import jakarta.persistence.Entity;
@@ -11,39 +9,56 @@
 import jakarta.validation.constraints.Size;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
+import java.util.ArrayList;
+import java.util.List;
 
 @Entity
 @Table(name = "competition_tables")
-@Getter
-@Setter
-@NoArgsConstructor
-@EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true)
 public class CompetitionTable extends UriEntity<String> {
 
 	@Id
 	@EqualsAndHashCode.Include
 	private String id;
-
-	@OneToMany(mappedBy = "competitionTable", cascade = {CascadeType.PERSIST, CascadeType.MERGE})
+	@Getter
+	@OneToMany(mappedBy = "competitionTable", cascade = CascadeType.ALL)
 	@JsonManagedReference("table-matches")
-	@Setter(lombok.AccessLevel.NONE)
 	private List<Match> matches = new ArrayList<>();
-
+	@Getter
 	@OneToMany(mappedBy = "supervisesTable")
 	@Size(max = 3, message = "A table can have a maximum of 3 referees")
 	@JsonManagedReference("table-referees")
-	@Setter(lombok.AccessLevel.NONE)
 	private List<Referee> referees = new ArrayList<>();
 
+	public static CompetitionTable create(String id) {
+		DomainValidation.requireNonBlank(id, "id");
+		CompetitionTable table = new CompetitionTable();
+		table.id = id;
+		return table;
+	}
+
+	@Override
+	public String getId() {
+		return id;
+	}
+
+	public void setId(String id) {
+		this.id = id;
+	}
+
 	public void setMatches(List<Match> matches) {
 		new ArrayList<>(this.matches).forEach(this::removeMatch);
 		if (matches != null) {
 			matches.forEach(this::addMatch);
 		}
 	}
 
+	public void setReferees(List<Referee> referees) {
+		new ArrayList<>(this.referees).forEach(this::removeReferee);
+		if (referees != null) {
+			referees.forEach(this::addReferee);
+		}
+	}
+
 	public void addMatch(Match match) {
 		if (match == null) {
 			return;
@@ -55,10 +70,11 @@ public void addMatch(Match match) {
 
 		CompetitionTable previousTable = match.getCompetitionTable();
 		if (previousTable != null && previousTable != this) {
-			previousTable.getMatches().removeIf(m -> m == match);
+			previousTable.removeMatch(match);
+		}
+		if (!matches.contains(match)) {
+			matches.add(match);
 		}
-
-		this.matches.add(match);
 		match.setCompetitionTable(this);
 	}
 
@@ -67,18 +83,8 @@ public void removeMatch(Match match) {
 			return;
 		}
 
-		if (this.matches.removeIf(m -> m == match)) {
-			match.setCompetitionTable(null);
-		}
-	}
-
-	public void setReferees(List<Referee> referees) {
-		if (referees == this.referees) {
-			return;
-		}
-		List<Referee> incoming = (referees == null) ? List.of() : new ArrayList<>(referees);
-		new ArrayList<>(this.referees).forEach(this::removeReferee);
-		incoming.forEach(this::addReferee);
+		matches.remove(match);
+		match.setCompetitionTable(null);
 	}
 
 	public void addReferee(Referee referee) {
@@ -96,10 +102,12 @@ public void addReferee(Referee referee) {
 
 		CompetitionTable previousTable = referee.getSupervisesTable();
 		if (previousTable != null && previousTable != this) {
-			previousTable.getReferees().removeIf(r -> r == referee);
+			previousTable.removeReferee(referee);
 		}
-
-		this.referees.add(referee);
+		if (referees.contains(referee)) {
+			return;
+		}
+		referees.add(referee);
 		referee.setSupervisesTable(this);
 	}
 
@@ -108,8 +116,7 @@ public void removeReferee(Referee referee) {
 			return;
 		}
 
-		if (this.referees.removeIf(r -> r == referee)) {
-			referee.setSupervisesTable(null);
-		}
+		referees.remove(referee);
+		referee.setSupervisesTable(null);
 	}
 }

src/main/java/cat/udl/eps/softarch/fll/domain/DomainValidation.java

@@ -0,0 +1,83 @@
+package cat.udl.eps.softarch.fll.domain;
+
+import java.time.LocalDate;
+import java.util.regex.Pattern;
+
+public final class DomainValidation {
+
+	private static final Pattern EMAIL_PATTERN =
+		Pattern.compile("^[\\w\\-.]+@([\\w-]+\\.)+[\\w-]{2,}$");
+
+	private DomainValidation() {
+	}
+
+	public static void requireNonBlank(String value, String fieldName) {
+		if (value == null) {
+			throw new DomainValidationException(fieldName + " must not be null");
+		}
+		if (value.isBlank()) {
+			throw new DomainValidationException(fieldName + " must not be blank");
+		}
+	}
+
+	public static void requireValidEmail(String email, String fieldName) {
+		requireNonBlank(email, fieldName);
+		if (!EMAIL_PATTERN.matcher(email).matches()) {
+			throw new DomainValidationException(fieldName + " must be a valid email address");
+		}
+	}
+
+	public static void requireNonNegative(Integer value, String fieldName) {
+		if (value == null) {
+			throw new DomainValidationException(fieldName + " must not be null");
+		}
+		if (value < 0) {
+			throw new DomainValidationException(fieldName + " must not be negative");
+		}
+	}
+
+	public static void requireMin(Integer value, Integer minValue, String fieldName) {
+		if (value == null) {
+			throw new DomainValidationException(fieldName + " must not be null");
+		}
+		if (value < minValue) {
+			throw new DomainValidationException(fieldName + " must not be less than " + minValue);
+		}
+	}
+
+	public static void requirePast(LocalDate value, String fieldName) {
+		if (value == null) {
+			throw new DomainValidationException(fieldName + " must not be null");
+		}
+		if (!value.isBefore(LocalDate.now())) {
+			throw new DomainValidationException(fieldName + " must be in the past");
+		}
+	}
+
+	public static void requireLengthBetween(String value, Integer minLength, Integer maxLength, String fieldName) {
+		if (value == null) {
+			throw new DomainValidationException(fieldName + " must not be null");
+		}
+		if (value.length() < minLength) {
+			throw new DomainValidationException(fieldName + " length must not be less than " + minLength);
+		}
+		if (value.length() > maxLength) {
+			throw new DomainValidationException(fieldName + " length must not be more than " + maxLength);
+		}
+	}
+
+	public static void requireMaxLength(String value, Integer maxLength, String fieldName) {
+		if (value == null) {
+			throw new DomainValidationException(fieldName + " must not be null");
+		}
+		if (value.length() > maxLength) {
+			throw new DomainValidationException(fieldName + " length must not be more than " + maxLength);
+		}
+	}
+
+	public static void requireNonNull(Object value, String fieldName) {
+		if (value == null) {
+			throw new DomainValidationException(fieldName + " must not be null");
+		}
+	}
+}

src/main/java/cat/udl/eps/softarch/fll/domain/DomainValidationException.java

@@ -0,0 +1,8 @@
+package cat.udl.eps.softarch.fll.domain;
+
+public class DomainValidationException extends RuntimeException {
+
+	public DomainValidationException(String message) {
+		super(message);
+	}
+}

src/main/java/cat/udl/eps/softarch/fll/domain/Edition.java

@@ -1,7 +1,5 @@
 package cat.udl.eps.softarch.fll.domain;
 
-import java.util.HashSet;
-import java.util.Set;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.EnumType;
@@ -18,6 +16,8 @@
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.ToString;
+import java.util.HashSet;
+import java.util.Set;
 
 @Entity
 @Data
@@ -48,13 +48,28 @@ public class Edition extends UriEntity<Long> {
 
 	@ManyToMany
 	@JoinTable(
-			name = "edition_teams",
-			joinColumns = @JoinColumn(name = "edition_id"),
-			inverseJoinColumns = @JoinColumn(name = "team_name"))
+		name = "edition_teams",
+		joinColumns = @JoinColumn(name = "edition_id"),
+		inverseJoinColumns = @JoinColumn(name = "team_name"))
 	@ToString.Exclude
 	@EqualsAndHashCode.Exclude
 	private Set<Team> teams = new HashSet<>();
 
+	protected Edition() {
+	}
+
+	public static Edition create(Integer year, String venueName, String description) {
+		DomainValidation.requireNonNull(year, "year");
+		DomainValidation.requireNonBlank(venueName, "venueName");
+		DomainValidation.requireNonBlank(description, "description");
+
+		Edition edition = new Edition();
+		edition.year = year;
+		edition.venueName = venueName;
+		edition.description = description;
+		return edition;
+	}
+
 	public boolean hasReachedMaxTeams() {
 		return teams.size() >= MAX_TEAMS;
 	}

src/main/java/cat/udl/eps/softarch/fll/domain/Floater.java

@@ -1,31 +1,42 @@
 package cat.udl.eps.softarch.fll.domain;
 
-import java.util.HashSet;
-import java.util.Set;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.ManyToMany;
 import jakarta.persistence.Table;
 import jakarta.validation.constraints.NotBlank;
+import lombok.AccessLevel;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.ToString;
+import java.util.HashSet;
+import java.util.Set;
 
 @Entity
 @Table(name = "floaters")
 @Getter
 @Setter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
 @EqualsAndHashCode(callSuper = true, onlyExplicitlyIncluded = true)
 public class Floater extends Volunteer {
 
-
 	@NotBlank(message = "Student code is mandatory")
 	@Column(unique = true)
 	private String studentCode;
 
 	@ManyToMany(mappedBy = "floaters")
 	@ToString.Exclude
 	private Set<Team> assistedTeams = new HashSet<>();
+
+	public static Floater create(String name, String emailAddress, String phoneNumber, String studentCode) {
+		DomainValidation.requireNonBlank(studentCode, "studentCode");
+
+		Floater floater = new Floater();
+		floater.initFields(name, emailAddress, phoneNumber);
+		floater.studentCode = studentCode;
+		return floater;
+	}
 }