KevinSchoenmayer/GseTDDUebungKCLR
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added MySQL functionality

Browse Source
This commit is contained in:
Riley Schneider
2025-12-18 10:01:58 +01:00
parent 3344ba67cc
commit 35e22bba99
12 changed files with 297 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

395
src/main/java/hhn/temp/project/provider/SimpleDatabaseManager.java
View File

@@ -1,11 +1,10 @@
package hhn.temp.project.provider;
import hhn.temp.project.Task;
import hhn.temp.project.TaskState;
import hhn.temp.project.Worker;
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.sql.*;
@@ -13,216 +12,392 @@ import java.util.*;
public class SimpleDatabaseManager implements DatabaseManager {
private final static Path INSERT_TASK = Path.of("./src/main/resources/sql/InsertTaskTable.sql");
private final static Path DELETE_TASK = Path.of("./src/main/resources/sql/DeleteTaskTable.sql");
private final static Path SELECT_TASK = Path.of("./src/main/resources/sql/SelectTaskTable.sql");
private final static Path UPDATE_TASK = Path.of("./src/main/resources/sql/UpdateTaskTable.sql");
private Connection connection;
private boolean connected = false;
private Map<Integer, Task> temporaryTaskList = new HashMap();
private Map<Integer, Worker> temporaryWorkerList = new HashMap<>();
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,
SELECT,
UPDATE,
DELETE
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, URISyntaxException {
public String loadFile(QueryMode queryMode) throws IOException {
switch (queryMode) {
case INSERT -> {
case INSERT_TASK -> {
return Files.readString(INSERT_TASK);
}
case SELECT -> {
case SELECT_TASK -> {
return Files.readString(SELECT_TASK);
}
case DELETE -> {
case DELETE_TASK -> {
return Files.readString(DELETE_TASK);
}
case UPDATE -> {
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 "";
}
}
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(Task task) throws SQLException {
if (!connected) {
throw new SQLException("[CONNECTION FAILED] Instance is not connected to database.");
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;
}
if (!temporaryTaskList.containsKey(task.getTaskId())) {
temporaryTaskList.put(task.getTaskId(), task);
} else {
throw new SQLException("[INSERTION FAILED] Task with the same Task ID already exists.");
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(Collection<Task> tasks) throws SQLException {
public void saveTasks(final Collection<Task> tasks) throws SQLException {
for (Task task : tasks) {
saveTask(task);
}
}
@Override
public void saveWorker(Worker worker) throws SQLException {
if (!connected) {
throw new SQLException("[CONNECTION FAILED] Instance is not connected to database.");
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;
}
if (!temporaryWorkerList.containsKey(worker.getId())) {
temporaryWorkerList.put(worker.getId(), worker);
} else {
throw new SQLException("[INSERTION FAILED] Task with the same Task ID already exists.");
try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
preparedStatement.setInt(1, worker.getId());
preparedStatement.setString(2, worker.getName());
preparedStatement.execute();
}
}
@Override
public void saveWorkers(Collection<Worker> workers) throws SQLException {
public void saveWorkers(final Collection<Worker> workers) throws SQLException {
for (Worker worker : workers) {
saveWorker(worker);
}
}
@Override
public void updateTask(int taskId, Task newTaskObject) throws SQLException {
if (!connected) {
throw new SQLException("[CONNECTION FAILED] Instance is not connected to database.");
}
if (temporaryTaskList.containsKey(taskId) && newTaskObject.getTaskId() == taskId) {
temporaryTaskList.remove(taskId);
temporaryTaskList.put(taskId, newTaskObject);
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;
}
throw new SQLException("[UPDATE FAILED] Task ID not found OR Task ID does not equal New Task ID.");
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(int workerId, Worker newWorkerObject) throws SQLException {
if (!connected) {
throw new SQLException("[CONNECTION FAILED] Instance is not connected to database.");
}
if (temporaryWorkerList.containsKey(workerId) && newWorkerObject.getId() == workerId) {
temporaryWorkerList.remove(workerId);
temporaryWorkerList.put(workerId, newWorkerObject);
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;
}
throw new SQLException("[UPDATE FAILED] Worker ID not found OR Worker ID does not equal New Worker ID.");
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(int taskId) throws SQLException {
if (!connected) {
throw new SQLException("[CONNECTION FAILED] Instance is not connected to database.");
}
if (temporaryTaskList.containsKey(taskId)) {
temporaryTaskList.remove(taskId);
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;
}
throw new SQLException("[DELETION FAILED] Could not find Task ID. Nothing to delete.");
try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
preparedStatement.setInt(1, taskId);
preparedStatement.execute();
}
}
@Override
public void deleteWorker(int workerId) throws SQLException {
if (!connected) {
throw new SQLException("[CONNECTION FAILED] Instance is not connected to database.");
}
if (temporaryWorkerList.containsKey(workerId)) {
temporaryWorkerList.remove(workerId);
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;
}
throw new SQLException("[DELETION FAILED] Could not find Worker ID. Nothing to delete.");
try (PreparedStatement preparedStatement = connection.prepareStatement(query);) {
preparedStatement.setInt(1, workerId);
preparedStatement.execute();
}
}
@Override
public Collection<Task> getTasks() throws SQLException {
if (!connected) {
throw new SQLException("[CONNECTION FAILED] Instance is not connected to database.");
String query;
try {
query = loadFile(QueryMode.SELECT_ALL_TASK);
} catch (IOException e) {
System.err.println(e.getStackTrace());
return null;
}
return temporaryTaskList.values();
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 {
if (!connected) {
throw new SQLException("[CONNECTION FAILED] Instance is not connected to database.");
String query;
try {
query = loadFile(QueryMode.SELECT_ALL_WORKER);
} catch (IOException e) {
System.err.println(e.getStackTrace());
return null;
}
return temporaryWorkerList.values();
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(int taskId) throws SQLException {
if (!connected) {
throw new SQLException("[CONNECTION FAILED] Instance is not connected to database.");
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;
}
if (temporaryTaskList.containsKey(taskId)) {
return temporaryTaskList.get(taskId);
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;
}
}
throw new SQLException("[SELECTION FAILED] Could not find Task ID. Nothing to get.");
return null;
}
@Override
public Worker getWorkerByWorkerId(int workerId) throws SQLException {
if (!connected) {
throw new SQLException("[CONNECTION FAILED] Instance is not connected to database.");
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;
}
if (temporaryWorkerList.containsKey(workerId)) {
return temporaryWorkerList.get(workerId);
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;
}
}
throw new SQLException("[SELECTION FAILED] Could not find Worker ID. Nothing to get.");
return null;
}
@Override
public int getTotalNumberOfTasks() throws SQLException {
if (!connected) {
throw new SQLException("[CONNECTION FAILED] Instance is not connected to database.");
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 temporaryTaskList.size();
return 0;
}
@Override
public int getTotalNumberOfWorkers() throws SQLException {
if (!connected) {
throw new SQLException("[CONNECTION FAILED] Instance is not connected to database.");
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 temporaryWorkerList.size();
return 0;
}
public void clearDatabase() throws SQLException {
if (!connected) {
throw new SQLException("[CONNECTION FAILED] Instance is not connected to database.");
try (Statement statement = connection.createStatement()) {
statement.execute("TRUNCATE TABLE Task");
statement.execute("TRUNCATE TABLE Worker");
}
temporaryTaskList.clear();
temporaryWorkerList.clear();
}
@Override
public void connect() throws SQLException {
connected = true;
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/sql7810540?user=sql7810540&password=mXdJCFtDZz");
}
@Override
public void close() throws SQLException {
connected = false;
connection.close();
}
}
}