Merge pull request 'Implemented database functionality' (#4) from database into main

Reviewed-on: #4

Tried with a few extra steps. Needs a ReadME, but works otherwise.

.gitignore

@@ -0,0 +1,2 @@
+build/
+.gradle/

.gradle/buildOutputCleanup/cache.properties

@@ -1,2 +0,0 @@
-#Tue Dec 02 10:03:29 CET 2025
-gradle.version=8.14

.idea/GSEUebung.iml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

.idea/modules.xml

@@ -2,7 +2,8 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/GSEUebung.iml" filepath="$PROJECT_DIR$/.idea/GSEUebung.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/modules/Template.iml" filepath="$PROJECT_DIR$/.idea/modules/Template.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/modules/Template.test.iml" filepath="$PROJECT_DIR$/.idea/modules/Template.test.iml" />
     </modules>
   </component>
 </project>

.idea/modules/Template.test.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module version="4">
+  <component name="AdditionalModuleElements">
+    <content url="file://$MODULE_DIR$/../../src/test" dumb="true">
+      <sourceFolder url="file://$MODULE_DIR$/../../src/test/resources" type="java-test-resource" />
+    </content>
+  </component>
+</module>

build.gradle

@@ -14,6 +14,7 @@ dependencies {
     testImplementation platform('org.junit:junit-bom:5.10.0')
     testImplementation 'org.junit.jupiter:junit-jupiter'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+    implementation 'com.mysql:mysql-connector-j:9.5.0'
 }
 
 jacoco {
@@ -36,6 +37,11 @@ sourceSets {
 
 test {
     useJUnitPlatform()
+    testLogging {
+        events "passed", "skipped", "failed"
+        exceptionFormat "full"
+        showStandardStreams = true
+    }
     finalizedBy jacocoTestReport
 }
 jacocoTestReport {

docker/compose.yml

@@ -0,0 +1,19 @@
+version: "3.9"
+
+services:
+  mysql:
+    image: mysql:8.0
+    container_name: mysql-db
+    restart: unless-stopped
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_DATABASE: sql7810540
+      MYSQL_USER: sql7810540
+      MYSQL_PASSWORD: mXdJCFtDZz
+    ports:
+      - "3306:3306"
+    volumes:
+      - mysql_data:/var/lib/mysql
+
+volumes:
+  mysql_data:

resources/sql/CountAllFieldsTask.sql

@@ -0,0 +1 @@
+SELECT COUNT(*) AS total FROM Task

resources/sql/CountAllFieldsWorker.sql

@@ -0,0 +1 @@
+SELECT COUNT(*) AS total FROM Worker

resources/sql/SelectAllTask.sql

@@ -0,0 +1 @@
+SELECT * FROM Task

resources/sql/SelectAllWorker.sql

@@ -0,0 +1 @@
+SELECT * FROM Worker

resources/sql/SelectTaskById.sql

@@ -0,0 +1 @@
+SELECT * FROM Task WHERE taskid = ? LIMIT 1

resources/sql/SelectWorkerById.sql

@@ -0,0 +1 @@
+SELECT * FROM Worker WHERE workerid = ? LIMIT 1

resources/sql/UpdateWorkerTable.sql

@@ -0,0 +1 @@
+UPDATE Worker SET workerid = ?, name = ? WHERE workerid = ?

resources/sql/createTaskTable.sql

@@ -0,0 +1,8 @@
+CREATE TABLE Task (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    taskid INT,
+    name VARCHAR(255) NOT NULL,
+    description TEXT,
+    workerid INT,
+    taskstate BIT
+);

resources/sql/createWorkerTable.sql

@@ -0,0 +1,5 @@
+CREATE TABLE Worker (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    workerid INT,
+    name VARCHAR(255) NOT NULL
+);

resources/sql/deleteTaskTable.sql

@@ -0,0 +1 @@
+DELETE FROM Task WHERE taskid = ?

resources/sql/insertTaskTable.sql

@@ -0,0 +1 @@
+INSERT INTO Task (taskid, name, description, workerid, taskstate) VALUES (?, ?, ?, ?, ?)

resources/sql/insertWorkerTable.sql

@@ -0,0 +1 @@
+INSERT INTO Worker (workerid, name) VALUES (?, ?)

resources/sql/selectTaskTable.sql

@@ -0,0 +1 @@
+SELECT * FROM Task WHERE workerid = ?

resources/sql/updateTaskTable.sql

@@ -0,0 +1 @@
+UPDATE Task SET name = ?, description = ?, taskstate = ? WHERE taskid = ?

src/main/java/hhn/temp/project/AssignmentManager.java

@@ -0,0 +1,72 @@
+package hhn.temp.project;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class AssignmentManager {
+    Map<Integer, Worker> workerMap;
+    Map<Integer, Task> taskMap;
+    int workerIdCounter;
+    int taskIdCounter;
+
+    public AssignmentManager() {
+        workerMap = new HashMap<>();
+        taskMap = new HashMap<>();
+        int workerIdCounter = 1000;
+        int taskIdCounter = 0;
+    }
+
+    public int createWorker(String name) {
+        Worker worker = new Worker(name, ++workerIdCounter);
+        workerMap.put(workerIdCounter, worker);
+        return workerIdCounter;
+    }
+    public int addTask(int workerId, String name, String description) {
+        if (!workerMap.containsKey(workerId) || name == null || description == null) {
+            throw new IllegalArgumentException("WorkerId must exist and name or description can't be null");
+        }
+        Task task = new Task(++taskIdCounter, workerId, name, description);
+        taskMap.put(taskIdCounter, task);
+        return taskIdCounter;
+    }
+    public Task getTask(int taskId) {
+        if (!taskMap.containsKey(taskId)) {
+            throw new IllegalArgumentException("Task Id does not exist");
+        }
+        return taskMap.get(taskId);
+    }
+    public Map<Integer, Task> getTaskMap() {
+        return taskMap;
+    }
+    public void editTask(int workerId, int taskId, String name, String description) {
+        if (!workerMap.containsKey(workerId) || !taskMap.containsKey(taskId)) {
+            throw new IllegalArgumentException("Task Id or Worker Id does not exist");
+        }
+        Task task = taskMap.get(taskId);
+        task.setName(name);
+        task.setDescription(description);
+    }
+    public void removeTask(int taskId) {
+        if (!taskMap.containsKey(taskId)) {
+            throw new IllegalArgumentException("Task Id does not exist");
+        }
+        taskMap.remove(taskId);
+    }
+    public void finishTask(int workerId, int taskId) {
+        if (!workerMap.containsKey(workerId) || !taskMap.containsKey(taskId)) {
+            throw new IllegalArgumentException("Task Id or Worker Id does not exist");
+        }
+        Task task = taskMap.get(taskId);
+        task.setTaskState(TaskState.FINISHED);
+    }
+    public void unfinishTask(int workerId, int taskId) {
+        if (!workerMap.containsKey(workerId) || !taskMap.containsKey(taskId)) {
+            throw new IllegalArgumentException("Task Id or Worker Id does not exist");
+        }
+        Task task = taskMap.get(taskId);
+        task.setTaskState(TaskState.IN_PROGRESS);
+    }
+
+}

src/main/java/hhn/temp/project/Main.java

@@ -1,17 +0,0 @@
-package hhn.temp.project;
-
-//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
-// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
-public class Main {
-  public static void main(String[] args) {
-    //TIP Press <shortcut actionId="ShowIntentionActions"/> with your caret at the highlighted text
-    // to see how IntelliJ IDEA suggests fixing it.
-    System.out.printf("Hello and welcome!");
-
-    for (int i = 1; i <= 5; i++) {
-      //TIP Press <shortcut actionId="Debug"/> to start debugging your code. We have set one <icon src="AllIcons.Debugger.Db_set_breakpoint"/> breakpoint
-      // for you, but you can always add more by pressing <shortcut actionId="ToggleLineBreakpoint"/>.
-      System.out.println("i = " + i);
-    }
-  }
-}

src/main/java/hhn/temp/project/Task.java

@@ -0,0 +1,42 @@
+package hhn.temp.project;
+
+public class Task {
+    String name;
+    String description;
+    int taskId;
+    int workerId;
+    TaskState state;
+    public Task(int taskId, int workerId, String name, String description) {
+        this.name = name;
+        this.description = description;
+        this.taskId = taskId;
+        this.workerId = workerId;
+        this.state = TaskState.IN_PROGRESS;
+    }
+
+    public String getName() {
+        return name;
+    }
+    public void setName(String name) {
+        this.name = name;
+    }
+    public String getDescription() {
+        return description;
+    }
+    public void setDescription(String description) {
+        this.description = description;
+    }
+    public int getTaskId() {
+        return taskId;
+    }
+    public int getWorkerId() {
+        return workerId;
+    }
+    public void setTaskState(TaskState state) {
+        this.state = state;
+    }
+    public TaskState getTaskState() {
+        return state;
+    }
+
+}

src/main/java/hhn/temp/project/TaskState.java

@@ -0,0 +1,6 @@
+package hhn.temp.project;
+
+public enum TaskState {
+    IN_PROGRESS,
+    FINISHED;
+}

src/main/java/hhn/temp/project/Worker.java

@@ -0,0 +1,17 @@
+package hhn.temp.project;
+
+public class Worker {
+    String name;
+    int workerId;
+    public Worker(String name, int workerId) {
+        this.name = name;
+        this.workerId = workerId;
+    }
+
+    public String getName() {
+        return name;
+    }
+    public int getId() {
+        return workerId;
+    }
+}

src/main/java/hhn/temp/project/provider/Database.java

@@ -0,0 +1,29 @@
+package hhn.temp.project.provider;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.sql.SQLException;
+
+/**
+ * A database interface with basic database connectivity
+ * @author Riley Schneider
+ */
+public interface Database {
+  /**
+   * Creates a connection to the database
+   * @throws SQLException Thrown if database error occurs
+   */
+  void connect() throws SQLException;
+
+  /**
+   * Closes a connection to the database
+   * @throws SQLException Thrown if database error occurs
+   */
+  void close() throws SQLException;
+
+  /**
+   * Clears the entire tables in the database and reset primary key counter to each table
+   * @throws SQLException Thrown if database error occurs
+   */
+  void clearDatabase() throws SQLException;
+}

src/main/java/hhn/temp/project/provider/DatabaseManager.java

@@ -0,0 +1,115 @@
+package hhn.temp.project.provider;
+
+import hhn.temp.project.Task;
+import hhn.temp.project.Worker;
+
+import java.sql.SQLException;
+import java.util.Collection;
+
+/**
+ * Simple Database Manager to handle simple command such as insertion, deletion, updating of Task and Worker objects.
+ * @author Riley Schneider
+ */
+public interface DatabaseManager extends Database {
+  /**
+   * Saves a Task object into the database
+   * @param task Task to be saved into the database
+   * @throws SQLException Thrown if database error occurs
+   */
+  void saveTask(Task task) throws SQLException;
+
+  /**
+   * Saves a collection of Task objects into the database
+   * @param tasks Tasks to be saved into the database
+   * @throws SQLException Thrown if database error occurs
+   */
+  void saveTasks(Collection<Task> tasks) throws SQLException;
+
+  /**
+   * Saves a Worker object into the database
+   * @param worker Worker to be saved into the database
+   * @throws SQLException Thrown if database error occurs
+   */
+  void saveWorker(Worker worker) throws SQLException;
+
+  /**
+   * Saves a collection Worker objects into the database
+   * @param workers Workers to be saved into the database
+   * @throws SQLException Thrown if database error occurs
+   */
+  void saveWorkers(Collection<Worker> workers) throws SQLException;
+
+  /**
+   * Updates a Task object that already exists in the database
+   * @param taskId The ID of the given task
+   * @param newTaskObject The new Task object that will overwrite the existent task on database
+   * @throws SQLException Thrown if database error occurs
+   */
+  void updateTask(int taskId, Task newTaskObject) throws  SQLException;
+
+  /**
+   * Updates a Worker object that already exists in the database
+   * @param workerId The ID of the given worker
+   * @param newWorkerObject The new Worker object that will overwrite the existent task on database
+   * @throws SQLException Thrown if database error occurs
+   */
+  void updateWorker(int workerId, Worker newWorkerObject) throws  SQLException;
+
+  /**
+   * Deletes a task from the database
+   * @param taskId The ID of the given task that needs to be deleted
+   * @throws SQLException Thrown if database error occurs
+   */
+  void deleteTask(int taskId) throws  SQLException;
+
+  /**
+   * Deletes a worker from the database
+   * @param workerId The ID of the given worker that needs to be deleted
+   * @throws SQLException Thrown if database error occurs
+   */
+  void deleteWorker(int workerId) throws  SQLException;
+
+  /**
+   * Gets a collection of all tasks available in the database
+   * @return A collection of tasks (empty if no task available)
+   * @throws SQLException Thrown if database error occurs
+   */
+  Collection<Task> getTasks() throws SQLException;
+
+  /**
+   * Gets a collection of all workers available in the database
+   * @return A collection of workers (empty if no task available)
+   * @throws SQLException Thrown if database error occurs
+   */
+  Collection<Worker> getWorkers() throws SQLException;
+
+  /**
+   * Gets a task given by its ID from the database
+   * @param taskId The task ID
+   * @return A task from the database (NULL if no task found)
+   * @throws SQLException Thrown if database error occurs
+   */
+  Task getTaskByTaskId(int taskId) throws SQLException;
+
+  /**
+   * Gets a worker given by its ID from the database
+   * @param workerId The worker ID
+   * @return A worker from the database (NULL if no worker found)
+   * @throws SQLException Thrown if database error occurs
+   */
+  Worker getWorkerByWorkerId(int workerId) throws SQLException;
+
+  /**
+   * Gets the total number of available tasks in the database.
+   * @return The total number of tasks (0 = zero entries; -1 = error)
+   * @throws SQLException Thrown if database error occurs
+   */
+  int getTotalNumberOfTasks() throws  SQLException;
+
+  /**
+   * Gets the total number of available workers in the database.
+   * @return The total number of workers (0 = zero entries; -1 = error)
+   * @throws SQLException Thrown if database error occurs
+   */
+  int getTotalNumberOfWorkers() throws  SQLException;
+}

src/main/java/hhn/temp/project/provider/SimpleDatabaseManager.java

@@ -0,0 +1,403 @@
+package hhn.temp.project.provider;
+
+import hhn.temp.project.Task;
+import hhn.temp.project.TaskState;
+import hhn.temp.project.Worker;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.sql.*;
+import java.util.*;
+
+public class SimpleDatabaseManager implements DatabaseManager {
+
+  private Connection connection;
+
+  private final static Path INSERT_TASK = Path.of("resources/sql/InsertTaskTable.sql");
+  private final static Path DELETE_TASK = Path.of("resources/sql/DeleteTaskTable.sql");
+  private final static Path SELECT_TASK = Path.of("resources/sql/SelectTaskTable.sql");
+  private final static Path UPDATE_TASK = Path.of("resources/sql/UpdateTaskTable.sql");
+  private final static Path COUNT_ALL_TASK = Path.of("resources/sql/CountAllFieldsTask.sql");
+  private final static Path SELECT_ALL_TASK = Path.of("resources/sql/SelectAllFieldsTask.sql");
+  private final static Path SELECT_TASK_BY_ID = Path.of("resources/sql/SelectTaskById.sql");
+  private final static Path INSERT_WORKER = Path.of("resources/sql/InsertWorkerTable.sql");
+  private final static Path DELETE_WORKER = Path.of("resources/sql/DeleteWorkerTable.sql");
+  private final static Path SELECT_WORKER = Path.of("resources/sql/SelectWorkerTable.sql");
+  private final static Path UPDATE_WORKER = Path.of("resources/sql/UpdateWorkerTable.sql");
+  private final static Path COUNT_ALL_WORKER = Path.of("resources/sql/CountAllFieldsWorker.sql");
+  private final static Path SELECT_ALL_WORKER = Path.of("resources/sql/SelectAllFieldsWorker.sql");
+  private final static Path SELECT_WORKER_BY_ID = Path.of("resources/sql/SelectWorkerById.sql");
+
+  public enum QueryMode {
+    INSERT_TASK,
+    SELECT_TASK,
+    UPDATE_TASK,
+    DELETE_TASK,
+    SELECT_ALL_TASK,
+    SELECT_TASK_BY_ID,
+    COUNT_ALL_TASK,
+    INSERT_WORKER,
+    SELECT_WORKER,
+    UPDATE_WORKER,
+    DELETE_WORKER,
+    COUNT_ALL_WORKER,
+    SELECT_ALL_WORKER,
+    SELECT_WORKER_BY_ID,
+  }
+
+  public String loadFile(QueryMode queryMode) throws IOException {
+    switch (queryMode) {
+      case INSERT_TASK -> {
+        return Files.readString(INSERT_TASK);
+      }
+      case SELECT_TASK -> {
+        return Files.readString(SELECT_TASK);
+      }
+      case DELETE_TASK -> {
+        return Files.readString(DELETE_TASK);
+      }
+      case UPDATE_TASK -> {
+        return Files.readString(UPDATE_TASK);
+      }
+      case COUNT_ALL_TASK -> {
+        return Files.readString(COUNT_ALL_TASK);
+      }
+      case SELECT_ALL_TASK -> {
+        return Files.readString(SELECT_ALL_TASK);
+      }
+      case SELECT_TASK_BY_ID -> {
+        return Files.readString(SELECT_TASK_BY_ID);
+      }
+      case INSERT_WORKER -> {
+        return Files.readString(INSERT_WORKER);
+      }
+      case SELECT_WORKER -> {
+        return Files.readString(SELECT_WORKER);
+      }
+      case DELETE_WORKER -> {
+        return Files.readString(DELETE_WORKER);
+      }
+      case UPDATE_WORKER -> {
+        return Files.readString(UPDATE_WORKER);
+      }
+      case COUNT_ALL_WORKER -> {
+        return Files.readString(COUNT_ALL_WORKER);
+      }
+      case SELECT_ALL_WORKER -> {
+        return Files.readString(SELECT_ALL_WORKER);
+      }
+      case SELECT_WORKER_BY_ID -> {
+        return Files.readString(SELECT_WORKER_BY_ID);
+      }
+      default -> {
+        return "";
+      }
+    }
+  }
+
+  private TaskState integerToTaskState(final int in) {
+    return in == 1 ? TaskState.FINISHED : TaskState.IN_PROGRESS;
+  }
+
+  private int taskStateToInteger(final TaskState taskState) {
+    return taskState == TaskState.FINISHED ? 1 : 0;
+  }
+
+  @Override
+  public void saveTask(final Task task) throws SQLException {
+    String query;
+    try {
+      query = loadFile(QueryMode.INSERT_TASK);
+    } catch (IOException e) {
+      System.err.println(e.getStackTrace());
+      return;
+    }
+    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
+      preparedStatement.setInt(1, task.getTaskId());
+      preparedStatement.setString(2, task.getName());
+      preparedStatement.setString(3, task.getDescription());
+      preparedStatement.setInt(4, task.getWorkerId());
+      preparedStatement.setInt(5, taskStateToInteger(task.getTaskState()));
+      preparedStatement.execute();
+    }
+  }
+
+  @Override
+  public void saveTasks(final Collection<Task> tasks) throws SQLException {
+    for (Task task : tasks) {
+      saveTask(task);
+    }
+  }
+
+  @Override
+  public void saveWorker(final Worker worker) throws SQLException {
+    String query;
+    try {
+      query = loadFile(QueryMode.INSERT_WORKER);
+    } catch (IOException e) {
+      System.err.println(e.getStackTrace());
+      return;
+    }
+    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
+      preparedStatement.setInt(1, worker.getId());
+      preparedStatement.setString(2, worker.getName());
+      preparedStatement.execute();
+    }
+  }
+
+  @Override
+  public void saveWorkers(final Collection<Worker> workers) throws SQLException {
+    for (Worker worker : workers) {
+      saveWorker(worker);
+    }
+  }
+
+  @Override
+  public void updateTask(final int taskId, final Task newTaskObject) throws SQLException {
+    String query;
+    try {
+      query = loadFile(QueryMode.UPDATE_TASK);
+    } catch (IOException e) {
+      System.err.println(e.getStackTrace());
+      return;
+    }
+    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
+      preparedStatement.setString(1, newTaskObject.getName());
+      preparedStatement.setString(2, newTaskObject.getDescription());
+      preparedStatement.setInt(3, taskStateToInteger(newTaskObject.getTaskState()));
+      preparedStatement.setInt(4, taskId);
+      preparedStatement.execute();
+    }
+  }
+
+  @Override
+  public void updateWorker(final int workerId, final Worker newWorkerObject) throws SQLException {
+    String query;
+    try {
+      query = loadFile(QueryMode.UPDATE_WORKER);
+    } catch (IOException e) {
+      System.err.println(e.getStackTrace());
+      return;
+    }
+    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
+      preparedStatement.setInt(1, newWorkerObject.getId());
+      preparedStatement.setString(2, newWorkerObject.getName());
+      preparedStatement.setInt(3, workerId);
+      preparedStatement.execute();
+    }
+  }
+
+  @Override
+  public void deleteTask(final int taskId) throws SQLException {
+    String query;
+    try {
+      query = loadFile(QueryMode.DELETE_TASK);
+    } catch (IOException e) {
+      System.err.println(e.getStackTrace());
+      return;
+    }
+    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
+      preparedStatement.setInt(1, taskId);
+      preparedStatement.execute();
+    }
+  }
+
+  @Override
+  public void deleteWorker(final int workerId) throws SQLException {
+    String query;
+    try {
+      query = loadFile(QueryMode.DELETE_WORKER);
+    } catch (IOException e) {
+      System.err.println(e.getStackTrace());
+      return;
+    }
+    try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
+      preparedStatement.setInt(1, workerId);
+      preparedStatement.execute();
+    }
+  }
+
+  @Override
+  public Collection<Task> getTasks() throws SQLException {
+    String query;
+    try {
+      query = loadFile(QueryMode.SELECT_ALL_TASK);
+    } catch (IOException e) {
+      System.err.println(e.getStackTrace());
+      return null;
+    }
+
+    Collection<Task> tasks = new ArrayList<>();
+
+    try (Statement statement = connection.createStatement();
+         ResultSet rs = statement.executeQuery(query);) {
+
+      while (rs.next()) {
+            int taskId = rs.getInt("taskid");
+            String name = rs.getString("name");
+            String description = rs.getString("description");
+            int workerId = rs.getInt("workerid");
+            TaskState taskState = integerToTaskState(rs.getInt("taskstate"));
+
+            Task task = new Task(taskId, workerId, name, description);
+            task.setTaskState(taskState);
+
+            tasks.add(task);
+      }
+
+    }
+
+    return tasks;
+  }
+
+  @Override
+  public Collection<Worker> getWorkers() throws SQLException {
+    String query;
+    try {
+      query = loadFile(QueryMode.SELECT_ALL_WORKER);
+    } catch (IOException e) {
+      System.err.println(e.getStackTrace());
+      return null;
+    }
+
+    Collection<Worker> workers = new ArrayList<>();
+
+    try (Statement statement = connection.createStatement();
+         ResultSet rs = statement.executeQuery(query);) {
+
+      while (rs.next()) {
+        int workerId = rs.getInt("workerid");
+        String name = rs.getString("name");
+
+        Worker worker = new Worker(name, workerId);
+
+        workers.add(worker);
+      }
+
+    }
+
+    return workers;
+  }
+
+  @Override
+  public Task getTaskByTaskId(final int taskId) throws SQLException {
+    String query;
+    try {
+      query = loadFile(QueryMode.SELECT_TASK_BY_ID);
+    } catch (IOException e) {
+      System.err.println(e.getStackTrace());
+      return null;
+    }
+
+    try (PreparedStatement statement = connection.prepareStatement(query);) {
+
+      statement.setInt(1, taskId);
+
+      ResultSet rs = statement.executeQuery();
+
+      while (rs.next()) {
+        int taskId1 = rs.getInt("taskid");
+        String name = rs.getString("name");
+        String description = rs.getString("description");
+        int workerId = rs.getInt("workerid");
+        TaskState taskState = integerToTaskState(rs.getInt("taskstate"));
+
+        Task task = new Task(taskId1, workerId, name, description);
+        task.setTaskState(taskState);
+
+        return task;
+      }
+
+    }
+
+    return null;
+  }
+
+  @Override
+  public Worker getWorkerByWorkerId(final int workerId) throws SQLException {
+    String query;
+    try {
+      query = loadFile(QueryMode.SELECT_WORKER_BY_ID);
+    } catch (IOException e) {
+      System.err.println(e.getStackTrace());
+      return null;
+    }
+
+    try (PreparedStatement statement = connection.prepareStatement(query);) {
+
+      statement.setInt(1, workerId);
+
+      ResultSet rs = statement.executeQuery();
+
+      while (rs.next()) {
+        int workerId1 = rs.getInt("workerid");
+        String name = rs.getString("name");
+
+        Worker worker = new Worker(name, workerId1);
+
+        return worker;
+      }
+
+    }
+
+    return null;
+  }
+
+  @Override
+  public int getTotalNumberOfTasks() throws SQLException {
+    String query = "";
+    try {
+      query = loadFile(QueryMode.COUNT_ALL_TASK);
+    } catch (IOException e) {
+      System.err.println(e.getStackTrace());
+      return -1;
+    }
+    try (Statement statement = connection.createStatement();
+         ResultSet rs = statement.executeQuery(query);) {
+
+      if (rs.next()) {
+        return rs.getInt("total");
+      }
+    }
+
+    return 0;
+  }
+
+  @Override
+  public int getTotalNumberOfWorkers() throws SQLException {
+    String query = "";
+    try {
+      query = loadFile(QueryMode.COUNT_ALL_WORKER);
+    } catch (IOException e) {
+      System.err.println(e.getStackTrace());
+      return -1;
+    }
+    try (Statement statement = connection.createStatement();
+         ResultSet rs = statement.executeQuery(query);) {
+
+      if (rs.next()) {
+        return rs.getInt("total");
+      }
+    }
+
+    return 0;
+  }
+
+  public void clearDatabase() throws SQLException {
+    try (Statement statement = connection.createStatement()) {
+      statement.execute("TRUNCATE TABLE Task");
+      statement.execute("TRUNCATE TABLE Worker");
+    }
+  }
+
+  @Override
+  public void connect() throws SQLException {
+    connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/sql7810540?user=sql7810540&password=mXdJCFtDZz");
+  }
+
+  @Override
+  public void close() throws SQLException {
+    connection.close();
+  }
+}

test/hhn/temp/project/BadCasesTest.java

@@ -0,0 +1,55 @@
+package hhn.temp.project;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class BadCasesTest {
+    AssignmentManager manager;
+
+    @BeforeEach
+    public void setup() {
+        manager = new AssignmentManager();
+    }
+
+    @Test
+    @DisplayName("Assert that added tasks can't be Null")
+    public void assertNewTasksAreNotNull() {
+        int workerId = manager.createWorker("Alfred");
+        assertThrows(IllegalArgumentException.class, () -> manager.addTask(workerId, null, null));
+    }
+    @Test
+    @DisplayName("Assert List isn't empty after adding a task")
+    public void assertListNowEmptyAfterAdd() {
+        int workerId = manager.createWorker("Alfred");
+        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
+        assertFalse(manager.getTaskMap().isEmpty());
+    }
+    @Test
+    @DisplayName("Assert only existing tasks can be edited")
+    public void assertEditOnlyExistingTasks() {
+        int workerId = manager.createWorker("Alfred");
+        assertThrows(IllegalArgumentException.class, () -> manager.editTask(workerId, 99969, "I", "am Illegal"));
+        assertThrows(IllegalArgumentException.class, () -> manager.editTask(22200, 99969, "I", "am Illegal"));
+    }
+    @Test
+    @DisplayName("Assert Add Task is programmed defensively")
+    public void assertAddTaskOnlyAcceptsValidParameters() {
+        int workerId = manager.createWorker("Alfred");
+        assertThrows(IllegalArgumentException.class, () -> manager.addTask( 20203,"I", "am Illegal"));
+        assertThrows(IllegalArgumentException.class, () -> manager.addTask( workerId,null, null));
+    }
+    @Test
+    @DisplayName("Assert that Remove Task is programmed defensively")
+    public void assertRemoveTaskOnlyAcceptsValidParameters() {
+        assertThrows(IllegalArgumentException.class, () -> manager.removeTask(20320));
+    }
+    @Test
+    @DisplayName("Assert that un-/finishing a Task only works with valid parameters")
+    public void assertTaskStateChangesOnlyAcceptsValidParameters() {
+        assertThrows(IllegalArgumentException.class, () -> manager.finishTask(20405, 21034));
+        assertThrows(IllegalArgumentException.class, () -> manager.unfinishTask(20405, 21034));
+    }
+}

test/hhn/temp/project/DatabaseBadCasesTest.java

@@ -0,0 +1,46 @@
+package hhn.temp.project;
+
+import hhn.temp.project.provider.DatabaseManager;
+import hhn.temp.project.provider.SimpleDatabaseManager;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.sql.SQLException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class DatabaseBadCasesTest {
+
+  private DatabaseManager databaseManager;
+
+  @BeforeEach
+  public void setup() throws SQLException {
+    databaseManager = new SimpleDatabaseManager();
+    databaseManager.connect();
+    databaseManager.clearDatabase();
+  }
+
+  @Test
+  @DisplayName("Inserting Tasks with the same ID")
+  public void insertTasksWithTheSameId() throws SQLException {
+    Task task = new Task(10, 10, "ABC", "XYZ");
+    Task taskFaker = new Task(10, 5, "ABC!", "XYZ!");
+
+    databaseManager.saveTask(task);
+
+    databaseManager.saveTask(taskFaker);
+  }
+
+  @Test
+  @DisplayName("Inserting Workers with the same ID")
+  public void insertWorkersWithTheSameId() throws SQLException {
+    Worker worker = new Worker("Worker-1", 1);
+    Worker workerFaker = new Worker("Worker-100", 1);
+
+    databaseManager.saveWorker(worker);
+
+    databaseManager.saveWorker(workerFaker);
+  }
+}

test/hhn/temp/project/DatabaseGoodCasesTest.java

@@ -0,0 +1,90 @@
+package hhn.temp.project;
+
+import hhn.temp.project.provider.SimpleDatabaseManager;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.sql.SQLException;
+import java.util.Collection;
+import java.util.List;
+
+public class DatabaseGoodCasesTest {
+
+  private SimpleDatabaseManager databaseManager;
+
+  @BeforeEach
+  public void setup() throws SQLException {
+    databaseManager = new SimpleDatabaseManager();
+    databaseManager.connect();
+    databaseManager.clearDatabase();
+  }
+
+  @Test
+  @DisplayName("Inserting test task into the database and receiving back the same test task")
+  public void insertTaskAndReceiveItBackTest() throws SQLException {
+    Task task = new Task(123, 10, "Hello World", "Doing Something, hell yeah!");
+
+    databaseManager.saveTask(task);
+
+    Task reTask = databaseManager.getTaskByTaskId(task.getTaskId());
+
+    assertNotNull(reTask);
+    assertEquals(task.getTaskId(), reTask.getTaskId());
+    assertEquals(task.getDescription(), reTask.getDescription());
+    assertEquals(task.getName(), reTask.getName());
+    assertEquals(task.getWorkerId(), reTask.getWorkerId());
+
+    assertEquals(1, databaseManager.getTotalNumberOfTasks());
+  }
+
+  @Test
+  @DisplayName("Inserting test worker into the database and receiving back the same test worker")
+  public void insertWorkerAndReceivedItBackTest() throws SQLException {
+    Worker worker = new Worker("Worker-01", 12345678);
+
+    databaseManager.saveWorker(worker);
+
+    Worker reWorker = databaseManager.getWorkerByWorkerId(worker.getId());
+
+    assertNotNull(reWorker);
+
+    assertEquals(worker.getId(), reWorker.getId());
+    assertEquals(worker.getName(), reWorker.getName());
+  }
+
+  @Test
+  @DisplayName("Clearing the database (Task and Worker) test")
+  public void clearDatabaseTest() throws SQLException, InterruptedException {
+    Task task1 = new Task(10, 5, "Hello", "World");
+    Task task2 = new Task(9, 4, "Hochschule", "Heilbronn");
+    Task task3 = new Task(8, 9, "Gangnam", "Style");
+    Collection<Task> tasks = List.of(task1, task2, task3);
+
+    Worker worker1 = new Worker("ABC", 2);
+    Worker worker2 = new Worker("XYZ", 9);
+    Collection<Worker> workers = List.of(worker1, worker2);
+
+    databaseManager.saveTasks(tasks);
+    databaseManager.saveWorkers(workers);
+
+    Thread.sleep(500);
+
+    assertEquals(tasks.size(), databaseManager.getTotalNumberOfTasks());
+    assertEquals(workers.size(), databaseManager.getTotalNumberOfWorkers());
+
+    databaseManager.clearDatabase();
+
+    assertEquals(0, databaseManager.getTotalNumberOfTasks());
+    assertEquals(0, databaseManager.getTotalNumberOfWorkers());
+  }
+
+  @Test
+  public void testRandom() throws IOException, URISyntaxException {
+     System.out.println(databaseManager.loadFile(SimpleDatabaseManager.QueryMode.INSERT_TASK));
+  }
+}

test/hhn/temp/project/GoodCasesTest.java

@@ -0,0 +1,84 @@
+package hhn.temp.project;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class GoodCasesTest {
+    AssignmentManager manager;
+
+    @BeforeEach
+    public void setup() {
+        manager = new AssignmentManager();
+    }
+    @Test
+    @DisplayName("Assert that a Worker can add a Task")
+    public void assertWorkerCanAddTask() {
+        int workerId = manager.createWorker("Alfred");
+        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
+        assertNotNull(manager.getTask(taskId));
+        assertEquals("Run", manager.getTask(taskId).getName());
+    }
+
+    @Test
+    @DisplayName("Assert that added Tasks are added to the List")
+    public void assertTasksShowInList() {
+        int sizeCount = manager.getTaskMap().size();
+        int workerId = manager.createWorker("Alfred");
+        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
+        assertEquals(sizeCount + 1, manager.getTaskMap().size());
+    }
+    @Test
+    @DisplayName("Assert existing Tasks can be edited")
+    public void assertExistingTasksCanBeEdited() {
+        int workerId = manager.createWorker("Alfred");
+        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
+        manager.editTask(workerId, taskId, "Walk", "Walk 3 Miles");
+        assertEquals("Walk", manager.getTask(taskId).getName());
+        assertEquals("Walk 3 Miles", manager.getTask(taskId).getDescription());
+    }
+
+    @Test
+    @DisplayName("Assert that Worker can remove Task")
+    public void assertWorkerCanRemoveOwnTask() {
+        int sizeCount = manager.getTaskMap().size();
+        int workerId = manager.createWorker("Alfred");
+        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
+        assertEquals(sizeCount + 1, manager.getTaskMap().size());
+        manager.removeTask(taskId);
+        assertEquals(sizeCount, manager.getTaskMap().size());
+    }
+    @Test
+    @DisplayName("Assert deleted Tasks no longer show up in the List")
+    public void assertDeletedTasksDisappear() {
+        int workerId = manager.createWorker("Alfred");
+        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
+        manager.removeTask(taskId);
+        assertThrows(IllegalArgumentException.class, () -> manager.getTask(taskId));
+    }
+    @Test
+    @DisplayName("Check Getters")
+    public void assertGettersWorkCorrectly() {
+        int workerId = manager.createWorker("Alfred");
+        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
+        assertEquals("Alfred", manager.workerMap.get(workerId).getName());
+        //This one may be somewhat nonsensical, but it ensures the getId works so one may iterate over the workerMap
+        assertEquals(manager.workerMap.get(workerId).getId(), workerId);
+        assertEquals(manager.getTask(taskId).getTaskId(), taskId);
+        assertEquals(manager.getTask(taskId).getWorkerId(), workerId);
+
+    }
+    @Test
+    @DisplayName("Assert that Task State is actually changed when submitted as finished")
+    public void assertTaskStateChanges() {
+        int workerId = manager.createWorker("Alfred");
+        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
+        manager.finishTask(workerId, taskId);
+        assertSame(TaskState.FINISHED, manager.getTask(taskId).getTaskState());
+        manager.unfinishTask(workerId, taskId);
+        assertSame(TaskState.IN_PROGRESS, manager.getTask(taskId).getTaskState());
+    }
+
+}

test/java/BadCasesTest.java

@@ -1,14 +0,0 @@
-package java;
-
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Assertions.*;
-
-public class BadCasesTest {
-
-    @BeforeEach
-    public void setup() {
-
-    }
-
-
-}

test/java/GoodCasesTest.java

@@ -1,14 +0,0 @@
-package java;
-
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Assertions.*;
-
-public class GoodCasesTest {
-
-    @BeforeEach
-    public void setup() {
-
-    }
-
-
-}