feat: solution

src/main/java/lab/App.java

@@ -2,9 +2,14 @@ package lab;
 
 import java.io.IOException;
 import java.sql.SQLException;
+import java.util.List;
 
 import org.h2.tools.Server;
 
+import lab.data.Game;
+import lab.data.Player;
+import lab.data.Score;
+import lab.data.Score.Difficult;
 import lab.storage.JpaConnector;
 import lombok.extern.log4j.Log4j2;
 
@@ -23,12 +28,50 @@ public class App {
 		Server server = startDBWebServer();
 
 		JpaConnector connector = new JpaConnector();
-
-		//TODO
+		for (int i = 0; i < 10; i++) {
+			connector.save(Game.generateAny());
+		}
+		for (int i = 0; i < 10; i++) {
+			connector.save(Player.generate());
+		}
+		List<Player> players = connector.getAll(Player.class);
+		List<Game> games = connector.getAll(Game.class);
+		for (int i = 0; i < 10; i++) {
+			connector.save(Score.generate(players, games));
+		}
+		connector.getEntityManager().clear();
+		connector.getAll(Score.class).forEach(System.out::println);
+		connector.getAll(Player.class).forEach(App::printPlayer);
+		connector.getAll(Game.class).forEach(App::printGame);
+		
+		System.out.println("-----------null,null-----------------------------");
+		connector.findBy(null, null).forEach(System.out::println);
+		System.out.println("-----------    ,null-----------------------------");
+		connector.findBy("   ", null).forEach(System.out::println);
+		System.out.println("-----------'ea',null-----------------------------");
+		connector.findBy("ea", null).forEach(System.out::println);
+		System.out.println("-----------'ea',medium-----------------------------");
+		connector.findBy("ea", Difficult.MEDIUM).forEach(System.out::println);
+		System.out.println("-----------'Java',null-----------------------------");
+		connector.findBy("Java", Difficult.MEDIUM).forEach(System.out::println);
 
 		waitForKeyPress();
 		stopDBWebServer(server);
 	}
+	
+	private static void printPlayer(Player player) {
+		System.out.println(player);
+		for (Score score : player.getScores()) {
+			System.out.println("  -> " + score);
+		}
+	}
+
+	private static void printGame(Game game) {
+		System.out.println(game);
+		for (Score score : game.getScores()) {
+			System.out.println("  -> " + score);
+		}
+	}
 
 	private static Server startDBWebServer() {
 		// Start HTTP server for access H2 DB for look inside

src/main/java/lab/data/FirstPersonShooter.java

@@ -2,13 +2,17 @@ package lab.data;
 
 import java.util.List;
 
+import jakarta.persistence.Entity;
 import lab.Tools;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.ToString;
 
+@Entity
 @Getter
 @Setter
+@NoArgsConstructor
 @ToString(callSuper = true)
 public class FirstPersonShooter extends Game {
 

src/main/java/lab/data/Game.java

@@ -2,20 +2,37 @@ package lab.data;
 
 import java.util.List;
 
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToMany;
 import lab.Tools;
+import lombok.AllArgsConstructor;
 import lombok.Builder;
+import lombok.EqualsAndHashCode;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.ToString;
 
+@Entity
 @Getter
 @Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
 @ToString
 @Builder(toBuilder = true)
 public class Game implements MyEntity {
 
+	@Id
+	@GeneratedValue(strategy = GenerationType.AUTO)
+	@EqualsAndHashCode.Include
 	private Long id;
 	private String name;
+	@OneToMany(mappedBy = Score_.GAME)
+	@ToString.Exclude
 	private List<Score> scores;
 
 	public static Game generate() {

src/main/java/lab/data/PlatformGame.java

@@ -2,13 +2,19 @@ package lab.data;
 
 import java.util.List;
 
+import jakarta.persistence.Entity;
 import lab.Tools;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.ToString;
 
+@Entity
 @Getter
 @Setter
+@AllArgsConstructor
+@NoArgsConstructor
 @ToString(callSuper = true)
 public class PlatformGame extends Game {
 

src/main/java/lab/data/Player.java

@@ -2,22 +2,40 @@ package lab.data;
 
 import java.util.List;
 
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToMany;
 import lab.Tools;
+import lombok.AllArgsConstructor;
 import lombok.Builder;
+import lombok.EqualsAndHashCode;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.ToString;
 
+@Entity
 @Getter
 @Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
 @ToString
 @Builder(toBuilder = true)
 public class Player implements MyEntity {
 
+	
+	@Id
+	@GeneratedValue(strategy = GenerationType.AUTO)
+	@EqualsAndHashCode.Include
 	private Long id;
 	private String firstName;
 	private String lastName;
 	private String nick;
+	@OneToMany(mappedBy = Score_.PLAYER)
+	@ToString.Exclude
 	private List<Score> scores;
 
 	public static Player generate() {

src/main/java/lab/data/Score.java

@@ -2,25 +2,42 @@ package lab.data;
 
 import java.util.List;
 
+import jakarta.persistence.Entity;
 import jakarta.persistence.EnumType;
 import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.ManyToOne;
 import lab.Tools;
+import lombok.AllArgsConstructor;
 import lombok.Builder;
+import lombok.EqualsAndHashCode;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.ToString;
 
+@Entity
 @Getter
 @Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
 @ToString
 @Builder(toBuilder = true)
 public class Score implements MyEntity {
 
+	@EqualsAndHashCode.Include
+	@Id
+	@GeneratedValue(strategy = GenerationType.AUTO)
 	private Long id;
 	private int points;
 	@Enumerated(EnumType.STRING)
 	private Difficult difficult;
+	@ManyToOne
 	private Player player;
+	@ManyToOne
 	private Game game;
 
 	public static Score generate(List<Player> players, List<Game> games) {

src/main/java/lab/storage/JpaConnector.java

 package lab.storage;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
 
 import jakarta.persistence.EntityManager;
 import jakarta.persistence.EntityManagerFactory;
 import jakarta.persistence.Persistence;
+import jakarta.persistence.criteria.CriteriaBuilder;
+import jakarta.persistence.criteria.CriteriaQuery;
+import jakarta.persistence.criteria.Predicate;
+import jakarta.persistence.criteria.Root;
+import lab.data.Game_;
 import lab.data.MyEntity;
 import lab.data.Score;
+import lab.data.Score_;
 
 public class JpaConnector {
 
@@ -19,18 +26,29 @@ public class JpaConnector {
 		em = emf.createEntityManager();
 	}
 
-	public<T extends MyEntity> List<T> getAll(Class<T> clazz) {
-		//TODO
-		return null;
+	public <T extends MyEntity> List<T> getAll(Class<T> clazz) {
+		return em.createQuery("select e from " + clazz.getSimpleName() + " e", clazz).getResultList();
 	}
 
-	public<T extends MyEntity> T save(T score) {
-		//TODO
-		return null;
+	public <T extends MyEntity> T save(T entity) {
+		T result;
+		em.getTransaction().begin();
+		if (entity.getId() == null || entity.getId() == 0) {
+			em.persist(entity);
+			result = entity;
+		} else {
+			result = em.merge(entity);
+		}
+		em.getTransaction().commit();
+		return result;
 	}
 
-	public void delete(List<? extends MyEntity> e) {
-		//TODO
+	public void delete(List<? extends MyEntity> entities) {
+		em.getTransaction().begin();
+		for (MyEntity entity : entities) {
+			em.remove(entity);
+		}
+		em.getTransaction().commit();
 	}
 
 	public void stop() {
@@ -42,21 +60,33 @@ public class JpaConnector {
 		return em;
 	}
 
-	public<T> T find(long id, Class<T> clazz) {
+	public <T> T find(long id, Class<T> clazz) {
 		return em.find(clazz, id);
 	}
-	
-	public void modifyNoPersistOrMerge(long id, Consumer<Score> motificator) {
+
+	public void modifyNoPersistOrMerge(long id, Consumer<Score> modificator) {
 		em.getTransaction().begin();
 		Score score = em.find(Score.class, id);
-		motificator.accept(score);
+		modificator.accept(score);
 		em.getTransaction().commit();
 	}
 
-	
-	public List<Score> findBy(String partialName, Score.Difficult difficult){
-		//TODO
-		return null;
+	public List<Score> findBy(String partialName, Score.Difficult difficult) {
+		CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
+		CriteriaQuery<Score> criteriaQuery = criteriaBuilder.createQuery(Score.class);
+		Root<Score> root = criteriaQuery.from(Score.class);
+		List<Predicate> predicates = new ArrayList<>();
+		if (partialName != null && !partialName.isBlank()) {
+			predicates.add(
+					criteriaBuilder.like(root.get(Score_.game).get(Game_.name), String.format("%%%s%%", partialName)));
+		}
+		if (difficult != null) {
+			predicates.add(criteriaBuilder.equal(root.get(Score_.difficult), difficult));
+		}
+		if (!predicates.isEmpty()) {
+			criteriaQuery.where(predicates.toArray(new Predicate[predicates.size()]));
+		}
+		return em.createQuery(criteriaQuery).getResultList();
 	}
-	
+
 }

src/test/java/jez04/structure/test/ClassStructureTest.java

@@ -12,7 +12,6 @@ import java.util.Objects;
 
 import org.hamcrest.Matchers;
 import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;