Created some logic in TaskRepository. Added id to models, etc...

src/main/java/repository/TaskRepository.java

@@ -3,14 +3,16 @@ package repository;
 import models.Task;
 
 import java.util.ArrayList;
+import java.util.Date;
 import java.util.List;
 import java.util.Optional;
 
 public interface TaskRepository {
-    ArrayList<Task> getUserTasks(int userId);
-    ArrayList<Task> findUserTasksByTitle(int userId, String title);
-    Optional<Task> getUserTask(int userId, int taskId);
-    void save(Task task);
-    void update(int taskId, Task task);
-    void delete(int taskId);
+    ArrayList<Task> getUserTasks();
+    ArrayList<Task> getUserTasks(Date startDate, Date endDate);
+    ArrayList<Task> getUserTasks(String title);
+    Optional<Task> getUserTask(int taskId);
+    Optional<Task> save(String title, String description);
+    Optional<Task> update(int taskId, String title, String description);
+    boolean delete(int taskId);
 }

src/main/java/repository/TaskRepositoryJdbc.java

@@ -1,41 +1,259 @@
 package repository;
 
 import models.Task;
+import models.User;
+import util.Session;
 
+import javax.imageio.plugins.jpeg.JPEGImageReadParam;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.ArrayList;
-import java.util.List;
+import java.util.Date;
 import java.util.Optional;
 
 public class TaskRepositoryJdbc implements TaskRepository {
 
+    private final Connection connection;
 
-    @Override
-    public ArrayList<Task> getUserTasks(int userId) {
-        return new ArrayList<>();
+    public TaskRepositoryJdbc(Connection connection) {
+        this.connection = connection;
     }
 
     @Override
-    public ArrayList<Task> findUserTasksByTitle(int userId, String title) {
-        return new ArrayList<>();
+    public ArrayList<Task> getUserTasks() {
+        try {
+            User user = Session.getInstance().getUser();
+            if (user == null) return new ArrayList<>();
+
+            PreparedStatement preparedStatement = connection.prepareStatement(
+                    "SELECT * FROM tasks WHERE user_id=(?)"
+            );
+            preparedStatement.setInt(1, user.id());
+
+            ResultSet resultSet = preparedStatement.executeQuery();
+            ArrayList<Task> tasks = new ArrayList<>();
+
+            while (resultSet.next()) {
+
+                Task task = new Task(
+                        resultSet.getInt("id"),
+                        resultSet.getString("title"),
+                        resultSet.getString("description"),
+                        resultSet.getTimestamp("created_at"),
+                        user
+                );
+                tasks.add(task);
+            }
+
+            return tasks;
+        } catch (SQLException ex) {
+            ex.printStackTrace();
+            return new ArrayList<>();
+        }
+    }
+
+
+    @Override
+    public ArrayList<Task> getUserTasks(Date startDate, Date endDate) {
+        try {
+            User user = Session.getInstance().getUser();
+            if (user == null) return new ArrayList<>();
+
+            PreparedStatement preparedStatement = connection.prepareStatement(
+                    "SELECT * FROM tasks WHERE user_id=(?) AND created_at BETWEEN (?) AND (?)"
+            );
+
+            preparedStatement.setInt(1, user.id());
+            preparedStatement.setDate(2, new java.sql.Date(startDate.getTime()));
+            preparedStatement.setDate(3, new java.sql.Date(endDate.getTime()));
+
+            ResultSet resultSet = preparedStatement.executeQuery();
+            ArrayList<Task> tasks = new ArrayList<>();
+
+            while (resultSet.next()) {
+
+                Task task = new Task(
+                        resultSet.getInt("id"),
+                        resultSet.getString("title"),
+                        resultSet.getString("description"),
+                        resultSet.getTimestamp("created_at"),
+                        user
+                );
+
+                tasks.add(task);
+            }
+
+            return tasks;
+        } catch (SQLException ex) {
+            ex.printStackTrace();
+            return new ArrayList<>();
+        }
     }
 
     @Override
-    public Optional<Task> getUserTask(int userId, int taskId) {
-        return Optional.empty();
+    public ArrayList<Task> getUserTasks(String title) {
+        try {
+            User user = Session.getInstance().getUser();
+            if (user == null) return new ArrayList<>();
+
+            PreparedStatement preparedStatement = connection.prepareStatement(
+                    "SELECT * FROM tasks WHERE user_id=(?) AND title ILIKE (?)"
+            );
+
+            preparedStatement.setInt(1, user.id());
+            preparedStatement.setString(2,  "%" + title + "%");
+
+            ResultSet resultSet = preparedStatement.executeQuery();
+            ArrayList<Task> tasks = new ArrayList<>();
+
+            while (resultSet.next()) {
+
+                Task task = new Task(
+                        resultSet.getInt("id"),
+                        resultSet.getString("title"),
+                        resultSet.getString("description"),
+                        resultSet.getTimestamp("created_at"),
+                        user
+                );
+
+                tasks.add(task);
+            }
+
+            return tasks;
+        } catch (SQLException ex) {
+            ex.printStackTrace();
+            return new ArrayList<>();
+        }
     }
 
     @Override
-    public void save(Task task) {
+    public Optional<Task> getUserTask(int taskId) {
+        try {
+            User user = Session.getInstance().getUser();
+            if (user == null) return Optional.empty();
 
+            PreparedStatement preparedStatement = connection.prepareStatement(
+                    "SELECT * FROM tasks WHERE id=(?) AND user_id=(?)"
+            );
+
+            preparedStatement.setInt(1, taskId);
+            preparedStatement.setInt(2, user.id());
+            ResultSet resultSet = preparedStatement.executeQuery();
+
+            if (resultSet.next()) {
+                Task task = new Task(
+                        resultSet.getInt("id"),
+                        resultSet.getString("title"),
+                        resultSet.getString("description"),
+                        resultSet.getTimestamp("created_at"),
+                        user
+                );
+
+                return Optional.of(task);
+            }
+
+            return Optional.empty();
+        } catch (SQLException ex) {
+            ex.printStackTrace();
+            return Optional.empty();
+        }
     }
 
     @Override
-    public void update(int taskId, Task task) {
+    public Optional<Task> save(String title, String description) {
+        try {
+            User user = Session.getInstance().getUser();
+            if (user == null) Optional.empty();
 
+            PreparedStatement preparedStatement = connection.prepareStatement(
+                    "INSERT INTO tasks (title, description) VALUES (?, ?) RETURNING id, created_at"
+            );
+
+            preparedStatement.setString(1, title);
+            preparedStatement.setString(2, description);
+            ResultSet resultSet = preparedStatement.executeQuery();
+
+            if (resultSet.next()) {
+                Task task = new Task(
+                        resultSet.getInt("id"),
+                        title,
+                        description,
+                        resultSet.getTimestamp("created_at"),
+                        user
+                );
+
+                return Optional.of(task);
+            }
+
+            return Optional.empty();
+        } catch (SQLException ex) {
+            ex.printStackTrace();
+            return Optional.empty();
+        }
     }
 
     @Override
-    public void delete(int taskId) {
+    public Optional<Task> update(int taskId, String title, String description) {
+        try {
+            User user = Session.getInstance().getUser();
+            if (user == null) Optional.empty();
+
+            PreparedStatement preparedStatement = connection.prepareStatement(
+                    "UPDATE tasks SET title=?, description=? WHERE id=? AND user_id=(?) RETURNING id, created_at;"
+            );
+
+            preparedStatement.setString(1, title);
+            preparedStatement.setString(2, description  );
+            preparedStatement.setInt(3, taskId);
+            preparedStatement.setInt(4, user.id());
+
+            ResultSet resultSet = preparedStatement.executeQuery();
+
+            if (resultSet.next()) {
+                Task task = new Task(
+                        resultSet.getInt("id"),
+                        title,
+                        description,
+                        resultSet.getTimestamp("created_at"),
+                        user
+                );
+
+                return Optional.of(task);
+            }
+
+            return Optional.empty();
+        } catch (SQLException ex) {
+            ex.printStackTrace();
+            return Optional.empty();
+        }
+    }
+
+    @Override
+    public boolean delete(int taskId) {
+        try {
+            User user = Session.getInstance().getUser();
+            if (user == null) return false;
+
+            PreparedStatement preparedStatement = connection.prepareStatement(
+                    "DELETE FROM tasks WHERE id=(?) AND user_id=(?);"
+            );
+
+            preparedStatement.setInt(1, taskId);
+            preparedStatement.setInt(2, user.id());
+
+            int affected = preparedStatement.executeUpdate();
+
+            if (affected > 0) {
+                return false;
+            }
+
+            return true;
+        } catch (SQLException ex) {
+            ex.printStackTrace();
+            return false;
+        }
 
     }
 }

src/main/java/repository/UserRepositoryJdbc.java

@@ -31,13 +31,14 @@ public class UserRepositoryJdbc implements UserRepository {
                 return Optional.empty();
             }
 
+            Integer userId = resultSet.getInt("id");
             String passwordFromDB = resultSet.getString("password");
             String emailFromDB = resultSet.getString("email");
             if (!PasswordService.checkPassword(password, passwordFromDB)) {
                 return Optional.empty();
             }
 
-            User user = new User(username, emailFromDB);
+            User user = new User(userId, username, emailFromDB);
 
             return Optional.of(user);
         } catch (SQLException e) {
@@ -74,16 +75,24 @@ public class UserRepositoryJdbc implements UserRepository {
             String hashedPassword = PasswordService.hashPassword(password);
 
             PreparedStatement preparedStatement = connection.prepareStatement(
-                    "INSERT INTO users (name, email, password) VALUES (?, ?, ?);"
+                    "INSERT INTO users (name, email, password) VALUES (?, ?, ?) RETURNING id, name, email;"
             );
 
             preparedStatement.setString(1, username);
             preparedStatement.setString(2, email);
             preparedStatement.setString(3, hashedPassword);
-            preparedStatement.executeUpdate();
 
-            User user = new User(username, email);
-            return Optional.of(user);
+            ResultSet resultSet = preparedStatement.executeQuery();
+            if (resultSet.next()) {
+                User user = new User(
+                        resultSet.getInt("id"),
+                        username,
+                        email
+                );
+                return Optional.of(user);
+            }
+
+            return Optional.empty();
         } catch (SQLException e) {
             e.printStackTrace();
             return Optional.empty();