Table per class

pom.xml

@@ -143,7 +143,7 @@
         <executions>
           <execution>
             <id>validate</id>
-            <phase>validate</phase>
+            <phase>verify</phase>
             <configuration>
               <encoding>UTF-8</encoding>
               <consoleOutput>true</consoleOutput>

src/main/java/by/academy/it/task09/App.java

@@ -1,36 +1,66 @@
 package by.academy.it.task09;
 
+import by.academy.it.task09.dao.DaoFactory;
+import by.academy.it.task09.dao.TaskDao;
+import by.academy.it.task09.entity.Task;
+import by.academy.it.task09.util.HomeTaskEnum;
+import by.academy.it.task09.util.TaskEnum;
+import by.academy.it.task09.util.WorkTaskEnum;
+
+import java.util.List;
+
 /**
  * Create three classes
  * 1) Task - has the following fields
  * - id
  * - name
  * - description
- *
+ * <p>
  * 2) HomeTask extends Task - has additional fields
  * - startDate
  * - endDate
- * @Embedded
- * - performer (type Person [has two fields first and last name, make them Embeddable])
- * @Embedded
- * - accepter (type Person [has two fields first and last name, make them Embeddable])
  *
+ * @Embedded - performer
+ * (type Person [has two fields first and last name, make them Embeddable])
+ * @Embedded - accepter
+ * (type Person [has two fields first and last name, make them Embeddable])
+ * <p>
  * 3) WorkTask extends Task - has additional field
  * - cost
- *
+ * <p>
  * In three git branches, implement 3 inheritance strategies:
  * 1 - Table per class hierarchy
  * 2 - Table per subclass
  * 3 - Table Per Concrete class mapping
- *
+ * <p>
  * Write there some data from the main method.
  * Check through tests on H2, connect checkstyle, jacoco.
- *
  */
-public class App 
-{
-    public static void main( String[] args )
-    {
+public final class App {
+    /**
+     *
+     */
+    private App() {
+
+    }
 
+    /**
+     * @param args
+     */
+    public static void main(final String[] args) {
+        System.out.println("\'Table per class\' implementation");
+        List<Task> taskList =
+                List.of(TaskEnum.FIRST_TASK.getTask(),
+                        HomeTaskEnum.FIRST_HOME_TASK.getHomeTask(),
+                        WorkTaskEnum.FIRST_WORK_TASK.getWorkTask(),
+                        TaskEnum.SECOND_TASK.getTask(),
+                        HomeTaskEnum.SECOND_HOME_TASK.getHomeTask(),
+                        WorkTaskEnum.SECOND_WORK_TASK.getWorkTask());
+        TaskDao dao = DaoFactory.getInstance().getDaoProduction();
+        dao.save(taskList);
+        List<Task> result = dao.findAll();
+        for (Task task : result) {
+            System.out.println(task);
+        }
     }
 }

src/main/java/by/academy/it/task09/dao/DaoFactory.java

@@ -0,0 +1,39 @@
+package by.academy.it.task09.dao;
+
+import by.academy.it.task09.dao.impl.TaskDaoImpl;
+import by.academy.it.task09.dao.util.PersistenceUnitName;
+
+/**
+ *
+ */
+public class DaoFactory {
+
+    private static class SingletonHolder {
+        private final static DaoFactory INSTANCE = new DaoFactory();
+    }
+
+    private DaoFactory() {
+
+    }
+
+    /**
+     * @return -
+     */
+    public static DaoFactory getInstance() {
+        return SingletonHolder.INSTANCE;
+    }
+
+    /**
+     * @return -
+     */
+    public TaskDao getDaoProduction() {
+        return new TaskDaoImpl(PersistenceUnitName.PRODUCTION);
+    }
+
+    /**
+     * @return -
+     */
+    public TaskDao getDaoTest() {
+        return new TaskDaoImpl(PersistenceUnitName.TEST);
+    }
+}

src/main/java/by/academy/it/task09/dao/TaskDao.java

@@ -0,0 +1,41 @@
+package by.academy.it.task09.dao;
+
+import by.academy.it.task09.entity.Task;
+
+import java.util.List;
+
+/**
+ *
+ */
+public interface TaskDao {
+    /**
+     * @param id
+     * @return -
+     */
+    Task findById(Long id);
+
+    /**
+     * @return -
+     */
+    List<Task> findAll();
+
+    /**
+     * @param task
+     */
+    void save(Task task);
+
+    /**
+     * @param list
+     */
+    void save(List<Task> list);
+
+    /**
+     * @param task
+     */
+    void update(Task task);
+
+    /**
+     * @param id
+     */
+    void delete(Long id);
+}

src/main/java/by/academy/it/task09/dao/exception/TaskDaoException.java

@@ -0,0 +1,21 @@
+package by.academy.it.task09.dao.exception;
+
+/**
+ *
+ */
+public class TaskDaoException extends RuntimeException {
+    public TaskDaoException() {
+    }
+
+    public TaskDaoException(String message) {
+        super(message);
+    }
+
+    public TaskDaoException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public TaskDaoException(Throwable cause) {
+        super(cause);
+    }
+}

src/main/java/by/academy/it/task09/dao/impl/TaskDaoImpl.java

@@ -0,0 +1,136 @@
+package by.academy.it.task09.dao.impl;
+
+import by.academy.it.task09.dao.TaskDao;
+import by.academy.it.task09.dao.exception.TaskDaoException;
+import by.academy.it.task09.dao.util.PersistenceUnitName;
+import by.academy.it.task09.entity.Task;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+import java.util.List;
+
+/**
+ *
+ */
+public class TaskDaoImpl implements TaskDao {
+    /**
+     *
+     */
+    private final EntityManagerFactory factory;
+
+    public TaskDaoImpl(final PersistenceUnitName name) {
+        this.factory =
+                Persistence
+                        .createEntityManagerFactory(name.getValue());
+    }
+
+    /**
+     * @param id
+     * @return
+     */
+    @Override
+    public Task findById(final Long id) {
+        EntityManager entityManager = factory.createEntityManager();
+        Task result = null;
+        try {
+            result = entityManager.find(Task.class, id);
+        } catch (IllegalArgumentException e) {
+            throw new TaskDaoException(e);
+        } finally {
+            entityManager.close();
+        }
+        return result;
+    }
+
+    /**
+     * @return -
+     */
+    @Override
+    public List<Task> findAll() {
+        EntityManager entityManager = factory.createEntityManager();
+        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
+        CriteriaQuery<Task> criteriaQuery = criteriaBuilder.createQuery(Task.class);
+        Root<Task> rootEntry = criteriaQuery.from(Task.class);
+        CriteriaQuery<Task> all = criteriaQuery.select(rootEntry);
+        TypedQuery<Task> allQuery = entityManager.createQuery(all);
+        return allQuery.getResultList();
+    }
+
+    /**
+     * @param task
+     */
+    @Override
+    public void save(final Task task) {
+        EntityManager entityManager = factory.createEntityManager();
+        try {
+            entityManager.getTransaction().begin();
+            entityManager.persist(task);
+            entityManager.getTransaction().commit();
+        } catch (RuntimeException e) {
+            entityManager.getTransaction().rollback();
+            throw new TaskDaoException(e);
+        } finally {
+            entityManager.close();
+        }
+    }
+
+    /**
+     * @param list
+     */
+    @Override
+    public void save(final List<Task> list) {
+        EntityManager entityManager = factory.createEntityManager();
+        try {
+            entityManager.getTransaction().begin();
+            list.forEach(entityManager::persist);
+            entityManager.getTransaction().commit();
+        } catch (RuntimeException e) {
+            entityManager.getTransaction().rollback();
+            throw new TaskDaoException(e);
+        } finally {
+            entityManager.close();
+        }
+    }
+
+    /**
+     * @param task
+     */
+    @Override
+    public void update(final Task task) {
+        EntityManager entityManager = factory.createEntityManager();
+        try {
+            entityManager.getTransaction().begin();
+            entityManager.merge(task);
+            entityManager.getTransaction().commit();
+        } catch (RuntimeException e) {
+            entityManager.getTransaction().rollback();
+            throw new TaskDaoException(e);
+        } finally {
+            entityManager.close();
+        }
+    }
+
+    /**
+     * @param id
+     */
+    @Override
+    public void delete(final Long id) {
+        EntityManager entityManager = factory.createEntityManager();
+        try {
+            Task task = entityManager.find(Task.class,id);
+            entityManager.getTransaction().begin();
+            entityManager.remove(task);
+            entityManager.getTransaction().commit();
+        } catch (RuntimeException e) {
+            entityManager.getTransaction().rollback();
+            throw new TaskDaoException(e);
+        } finally {
+            entityManager.close();
+        }
+    }
+}

src/main/java/by/academy/it/task09/dao/util/PersistenceUnitName.java

@@ -0,0 +1,24 @@
+package by.academy.it.task09.dao.util;
+
+/**
+ *
+ */
+public enum PersistenceUnitName {
+    /**
+     *
+     */
+    PRODUCTION("production"),
+    /**
+     *
+     */
+    TEST("test");
+    private String value;
+
+    PersistenceUnitName(String value) {
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}