Merge branch 'main' of https://gitlab.reutlingen-university.de/goerlita/op_planung

opp/core/src/main/java/OPStaffServiceImpl.java

@@ -55,8 +55,10 @@ public class OPStaffServiceImpl implements OPStaffService{
 
     public OPStaff delete(OPStaff.Delete del) throws Exception{
 
-        return repo.deleteOPStaff(del.id());
-
+        if(repo.findOPStaffOperationTeams(del.id())==false){ //wenn false, dann ist er keinem team zugewiesen
+            return repo.deleteOPStaff(del.id());
+        }
+        return null;
     }
 
     @Override

opp/core/src/main/java/OperationServiceImpl.java

@@ -100,6 +100,10 @@ public class OperationServiceImpl implements OperationService {
      */
     public Operation delete(Operation.Delete del) throws Exception {
 
-        return repo.deleteOperation(del.id());
+        Optional<Operation> foundOperation =  repo.findOperation(del.id());
+        if (foundOperation.isPresent()) {
+            return repo.deleteOperation(del.id());
+        }
+        return null;
     }
 }

opp/core/src/main/java/OperationTeamImpl.java

 import java.sql.SQLException;
 import java.time.Instant;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
@@ -22,8 +23,23 @@ public class OperationTeamImpl implements OperationTeamService{
         };
     }
 
-    private OperationTeam delete(OperationTeam.Delete del)  throws SQLException {
-        return repo.deleteOperationTeam(del.operationTeamId());
+    private OperationTeam delete(OperationTeam.Delete del) throws Exception {
+
+        Optional<OperationTeam> returnedOperationTeam = repo.findOperationTeam(del.operationTeamId());
+
+        if(returnedOperationTeam.isPresent()) {
+            if (returnedOperationTeam.get().opStaffs().isEmpty()) {
+                return repo.deleteOperationTeam(del.operationTeamId());
+            } else {
+                int sizeOPStafflist = returnedOperationTeam.get().opStaffs().size();
+                for(int i = 0; i<sizeOPStafflist; i++){
+                    repo.removeOPStaffInOperationTeam(del.operationTeamId(),returnedOperationTeam.get().opStaffs().get(i).id());
+                }
+                return repo.deleteOperationTeam(del.operationTeamId());
+
+            }
+        }
+        return null;
     }
 
     //Only creates a connection between the newly created operationTeam and the already existing opStaffs.
@@ -65,10 +81,13 @@ public class OperationTeamImpl implements OperationTeamService{
 
     private OperationTeam removeStaff(OperationTeam.RemoveStaff rs) throws Exception {
 
-        OperationTeam findOperationTeam = repo.getOperationTeam(rs.operationTeamId());
+        Optional<OperationTeam> findOperationTeam = repo.findOperationTeam(rs.operationTeamId());
 
-        if(repo.removeOPStaffInOperationTeam(rs.operationTeamId(), rs.opStaffId())){
-            return findOperationTeam;
+        if(findOperationTeam.isPresent()){
+            if(repo.removeOPStaffInOperationTeam(rs.operationTeamId(), rs.opStaffId())){
+                Optional<OperationTeam> newOperationTeam = repo.findOperationTeam(rs.operationTeamId());
+                return newOperationTeam.get();
+            }
         }
         return null;
     }

opp/core/src/main/java/PreparationNote.java

 import java.time.Instant;
-import java.time.LocalDateTime;
-import java.util.Objects;
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.util.Optional;
 
-import java.util.Objects;
+public record PreparationNote (
 
-public class PreparationNote {
-    private String noteId;      // Eindeutige Identifikation der Notiz
-    private String operationId; // ID der zugehörigen Operation
-    private String content;     // Inhalt der Notiz
+    Id<PreparationNote> id,
+    String note,
+    Id<Operation> operationsId,
+    Instant lastUpdate
+) {
 
-    // Konstruktor zur Initialisierung der Notiz-Attribute
-    public PreparationNote(String noteId, String operationId, String content) {
-        this.noteId = noteId;
-        this.operationId = operationId;
-        this.content = content;
-    }
-/*
-    // Getter und Setter Methoden für die Attribute
-    public String getId() {
-        return noteId;
-    }
+    public static sealed interface Command permits Create, Update, Delete { }
 
-    public void setNoteId(String noteId) {
-        this.noteId = noteId;
-    }
+    public static record Create(
+            String note,
+            Id<Operation> operationsId
+    ) implements Command {}
 
-    public String getOperationId() {
-        return operationId;
-    }
+    public static record Update(
+            Id<PreparationNote> id,
+            String note
+    ) implements Command {}
 
-    public void setOperationId(String operationId) {
-        this.operationId = operationId;
-    }
+    public static record Delete(
+            Id<PreparationNote> id
+    ) implements Command {}
 
-    public String getContent() {
-        return content;
-    }
 
-    public void setContent(String content) {
-        this.content = content;
-    }
-
-    // toString Methode zur Darstellung der Notiz als String
-    @Override
-    public String toString() {
-        return "PreparationNote{" +
-                "noteId='" + noteId + '\'' +
-                ", operationId='" + operationId + '\'' +
-                ", content='" + content + '\'' +
-                '}';
-    }
-
-    // equals Methode zum Vergleichen von zwei PreparationNote Objekten
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        PreparationNote that = (PreparationNote) o;
-        return Objects.equals(noteId, that.NoteId) &&
-                Objects.equals(operationId, that.operationId) &&
-                Objects.equals(content, that.content);
-    }
-    // hashCode Methode zur Berechnung des Hashcodes eines PreparationNote Objekts
-    @Override
-    public int hashCode() {
-        return Objects.hash(noteId, operationId, content);
-    }
-
-
- */
 }
-
-//public record PreparationNote(
-//        Id<PreparationNote> preparationNoteId,
-//        String text,
-//        Operation operationId,
-//        Instant lastUpdate
-//) {
-

opp/core/src/main/java/PreparationNoteCommand.java

-public class PreparationNoteCommand {
-    private String operationId;
-    private String content;
-
-    // Konstruktor zur Initialisierung der Command-Attribute
-    public PreparationNoteCommand(String operationId, String content) {
-        this.operationId = operationId;
-        this.content = content;
-    }
-
-    // Getter und Setter Methoden für die Attribute
-    public String getOperationId() {
-        return operationId;
-    }
-
-    public void setOperationId(String operationId) {
-        this.operationId = operationId;
-    }
-
-    public String getContent() {
-        return content;
-    }
-
-    public void setContent(String content) {
-        this.content = content;
-    }
-}

opp/core/src/main/java/PreparationNoteImpl.java

+import java.time.Instant;
+import java.util.Optional;
+
+public class PreparationNoteImpl implements PreparationNoteService {
+
+    private final Repository repo;
+
+    public PreparationNoteImpl(Repository repo) {
+        this.repo = repo;
+    }
+
+    @Override
+    public PreparationNote process(PreparationNote.Command cmd) throws Exception {
+        return switch (cmd){
+            case PreparationNote.Create cr -> create(cr);
+            case PreparationNote.Update up -> update(up);
+            case PreparationNote.Delete del -> delete(del);
+        };
+    }
+
+    public PreparationNote create(PreparationNote.Create cr) throws Exception {
+        PreparationNote preparationNote =
+                new PreparationNote(
+                        repo.preparationNoteId(),
+                        cr.note(),
+                        cr.operationsId(),
+                        Instant.now());
+
+        repo.save(preparationNote);
+
+        return preparationNote;
+    }
+
+    public PreparationNote update(PreparationNote.Update up) throws Exception {
+
+        Optional<PreparationNote> foundPreparationNote =  repo.findPreparationNote(up.id());
+
+        PreparationNote preparationNote = null;
+        if (foundPreparationNote.isPresent()) {
+            PreparationNote currentPreparationNote = foundPreparationNote.get();
+
+            preparationNote =
+                    new PreparationNote(
+                            currentPreparationNote.id(),
+                            up.note(),
+                            currentPreparationNote.operationsId(),
+                            Instant.now());
+
+            repo.save(preparationNote);
+        }
+
+        return preparationNote;
+    }
+
+    private PreparationNote delete(PreparationNote.Delete del) throws Exception {
+
+        Optional<PreparationNote> returnedPreparationNote = repo.findPreparationNote(del.id());
+
+        if(returnedPreparationNote.isPresent()) {
+             return repo.deletePreparationNote(del.id());
+        }
+        return null;
+    }
+
+    public Optional<PreparationNote> findPreparationNote(Id<PreparationNote> id){
+        return repo.findPreparationNote(id);
+    }
+
+
+
+}

opp/core/src/main/java/PreparationNoteService.java

-import java.util.List;
+import java.util.Optional;
 
 public interface PreparationNoteService {
-    PreparationNote createNote(PreparationNoteCommand command);    // Methode zum Erstellen einer neuen Notiz
-    PreparationNote updateNote(String noteId, PreparationNoteCommand command); // Methode zum Aktualisieren einer Notiz
-    void deleteNote(String noteId);                     // Methode zum Löschen einer Notiz
-    PreparationNote getNoteById(String noteId);         // Methode zum Abrufen einer Notiz nach ID
-    List<PreparationNote> getNotesByOperationId(String operationId); // Methode zum Abrufen von Notizen nach Operation-ID
+
+    PreparationNote process(PreparationNote.Command cmd) throws Exception;
+
+    Optional<PreparationNote> findPreparationNote(Id<PreparationNote> id);
 }

opp/core/src/main/java/Repository.java

@@ -97,4 +97,25 @@ public interface Repository {
 
 
     Boolean findOperationTeamOPStaff(Id<OperationTeam> operationTeamId, Id<OPStaff> opStaffId);
+
+    Boolean findOPStaffOperationTeams(Id<OPStaff> opStaffId);
+
+
+    Id<PreparationNote> preparationNoteId();
+
+    Optional<PreparationNote> findPreparationNote(Id<PreparationNote> id);
+
+    void save(PreparationNote preparationNote);
+
+    PreparationNote deletePreparationNote(Id<PreparationNote> id);
+
+    Id<Room> roomId();
+
+    Optional<Room> findRoom(Id<Room> id);
+
+    void save(Room room);
+
+    Room deleteRoom(Id<Room> id);
+
+
 }

opp/core/src/main/java/Room.java

 import java.time.Instant;
-import java.util.Objects;
 
-public class Room {
-    private String roomId;  // Eindeutige Identifikation des Raum
-    private String roomName;// Name des Raums
-    private int capacity;   // Kapazität des Raums
+public record Room (
+    Id<Room> id,
+    String roomName,
+    Instant lastUpdate
+) {
 
-    // Konstruktor zur Initialisierung der Raum-Attribute
-    public Room(String RoomId, String roomName, int capacity) {
-        this.roomId = roomId;
-        //this.roomName = RoomName;
-        this.capacity = capacity;
-    }
+    public static sealed interface Command permits
+            Create,
+            Update,
+            Delete
+    {}
 
-    // Getter und Setter Methoden für die Attribute
-    //public String getRoomId() {
-    //    return RoomId;
-    //}
+    public static record Create(
+            String roomName
+    ) implements Command {}
 
-    //public void setRoomId(String roomId) {
-    //    this.id = RoomId;
-    //}
+    public static record Update(
+            Id<Room> id,
+            String roomName
+    ) implements Command{}
 
-    public String getRoomName() {
-        return roomName;
-    }
+    public static record Delete(
+            Id<Room> id
+    ) implements Command{}
 
-    public void setRoomName(String roomName) {
-        this.roomName = roomName;
-    }
-
-    public int getCapacity() {
-        return capacity;
-    }
-
-    public void setCapacity(int capacity) {
-        this.capacity = capacity;
-    }
-
-    // toString Methode zur Darstellung des Raums als String
-    @Override
-    public String toString() {
-        return "Room{" +
-                "roomId='" + roomId + '\'' +
-                ", roomName='" + roomName + '\'' +
-                ", capacity=" + capacity +
-                '}';
-    }
-
-    // equals Methode zum Vergleichen von zwei Room Objekten    
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        Room room = (Room) o;
-        return capacity == room.capacity &&
-                Objects.equals(roomId, room.roomId) &&
-                Objects.equals(roomName, room.roomName);
-    }
-    // hashCode Methode zur Berechnung des Hashcodes eines Room Objekts
-    @Override
-    public int hashCode() {
-        return Objects.hash(roomId, roomName, capacity);
-    }
 }
-
-//public record Room(
-//      Id<Room> roomId,
-//      String roomName,
-//      Instant lastUpdate
-//) {

opp/core/src/main/java/RoomCommand.java

-public class RoomCommand {
-    private String roomName;
-    private int capacity;
-
-    // Konstruktor zur Initialisierung der Kommando-Attribute
-    public RoomCommand(String roomName, int capacity) {
-        this.roomName = roomName;
-        this.capacity = capacity;
-    }
-
-    // Getter und Setter Methoden für die Attribute
-    public String getRoomName() {
-        return roomName;
-    }
-
-    public void setRoomName(String roomName) {
-        this.roomName = roomName;
-    }
-
-    public int getCapacity() {
-        return capacity;
-    }
-
-    public void setCapacity(int capacity) {
-        this.capacity = capacity;
-    }
-}

opp/core/src/main/java/RoomService.java

-import java.util.List;
+import java.util.Optional;
 
 public interface RoomService {
-    Room createRoom(RoomCommand command);    // Methode zum Erstellen eines neuen Raums
-    Room updateRoom(String roomId, RoomCommand command); // Methode zum Aktualisieren eines Raums
-    void deleteRoom(String roomId);           // Methode zum Löschen eines Raums
-    Room getRoomById(String roomId);          // Methode zum Abrufen eines Raums nach ID
-    List<Room> getAllRooms();                 // Methode zum Abrufen aller Räume
+
+    Room process(Room.Command cmd) throws Exception;
+
+    Optional<Room> findRoom(Id<Room> id);
 }

opp/core/src/main/java/RoomServiceImpl.java

+import java.time.Instant;
+import java.util.Optional;
+
+public class RoomServiceImpl implements RoomService {
+
+    private final Repository repo;
+
+    public RoomServiceImpl(Repository repo) {
+        this.repo = repo;
+    }
+
+    @Override
+    public Room process(Room.Command cmd) throws Exception {
+        return switch (cmd){
+            case Room.Create cr -> create(cr);
+            case Room.Update up -> update(up);
+            case Room.Delete del -> delete(del);
+        };
+    }
+
+    public Room create(Room.Create cr) throws Exception {
+        Room room = new Room(
+                repo.roomId(),
+                cr.roomName(),
+                Instant.now());
+
+        repo.save(room);
+
+        return room;
+    }
+
+    public Optional<Room> findRoom(Id<Room> id){
+        return repo.findRoom(id);
+    }
+
+    public Room update(Room.Update up) throws Exception {
+
+        Optional<Room> foundRoom = repo.findRoom(up.id());
+
+        Room room = null;
+        if (foundRoom.isPresent()) {
+            Room currentRoom = foundRoom.get();
+
+            room = new Room(
+                    currentRoom.id(),
+                    up.roomName(),
+                    Instant.now());
+
+            repo.save(room);
+        }
+
+        return room;
+    }
+
+    private Room delete(Room.Delete del) throws Exception {
+
+        Optional<Room> returnedRoom = repo.findRoom(del.id());
+
+        if(returnedRoom.isPresent()) {
+            return repo.deleteRoom(del.id());
+        }
+        return null;
+    }
+}
+

opp/jdbc-repo-impl/src/main/java/JDBCRepository.java

@@ -97,6 +97,28 @@ class JDBCRepository implements Repository
     );
   """;
 
+  /**
+   * The structure of the opStaffs table.
+   */
+  private static final String CREATE_PREPARATIONNOTE_TABLE = """
+    CREATE TABLE IF NOT EXISTS preparationNote(
+      id VARCHAR(50) PRIMARY KEY,
+      note VARCHAR(50) NOT NULL,
+      operationsId VARCHAR(50) NOT NULL,
+      lastUpdate TIMESTAMP NOT NULL,
+      FOREIGN KEY (operationsId) REFERENCES operations(id)
+    );
+  """;
+
+  private static final String CREATE_ROOM_TABLE = """
+      CREATE TABLE IF NOT EXISTS room(
+      id VARCHAR(50) PRIMARY KEY,
+      roomName VARCHAR(50) NOT NULL,
+      lastUpdate TIMESTAMP NOT NULL
+      );
+  """;
+
+
   //endregion
 
 
@@ -112,6 +134,8 @@ class JDBCRepository implements Repository
       stmt.execute(CREATE_OP_STAFF_TABLE);
       stmt.execute(CREATE_OPERATION_TABLE);
       stmt.execute(CREATE_OP_STAFF_IN_OPERATION_TEAM_TABLE);
+      stmt.execute(CREATE_PREPARATIONNOTE_TABLE);
+      stmt.execute(CREATE_ROOM_TABLE);
 
     } catch (SQLException e){
       throw new RuntimeException(e);
@@ -763,6 +787,22 @@ class JDBCRepository implements Repository
     }
   }
 
+  @Override
+  public Boolean findOPStaffOperationTeams(Id<OPStaff> opStaffId){
+
+    try(
+            var result =
+                    conn.createStatement()
+                            .executeQuery("SELECT * " +
+                                    "FROM opStaffsInOperationTeams " +
+                                    "WHERE opStaffsInOperationTeams.opStaffId = " + quoted(opStaffId.value()) + ";")
+    ) {
+      return result.next();
+    }catch(SQLException e){
+      throw new RuntimeException(e);
+    }
+  }
+
   /*
   @Override
   public List<OPStaff> getOperationTeamOPStaffImpl(Id<OperationTeam> operationTeamId){
@@ -794,6 +834,193 @@ class JDBCRepository implements Repository
   //endregion
 
 
+
+
+  @Override
+  public Id<PreparationNote> preparationNoteId() {
+
+    var id = new Id<PreparationNote>(randomUUID().toString());
+
+    return findPreparationNote(id).isEmpty() ? id : preparationNoteId();
+  }
+
+  public Optional<PreparationNote> findPreparationNote(Id<PreparationNote> id){
+      try (
+              var result =
+                      conn.createStatement()
+                              .executeQuery("SELECT * FROM preparationNote WHERE id = " + sqlValue(id.value()) + ";")
+      ){
+        return
+                result.next() ?
+                        Optional.of(readPreparationNoteFromRow(result)) :
+                        Optional.empty();
+
+      } catch (SQLException e){
+        throw new RuntimeException(e);
+      }
+  }
+
+
+  private static PreparationNote readPreparationNoteFromRow(ResultSet rs) throws SQLException {
+
+    return new PreparationNote(
+            new Id<>(rs.getString("id")),
+            rs.getString("note"),
+            new Id<>(rs.getString("operationsId")),
+            rs.getTimestamp("lastUpdate").toInstant()
+    );
+  }
+
+  @Override
+  public void save(PreparationNote preparationNote) {
+    try (
+            var stmt = conn.createStatement()
+    ){
+      var sql =
+              findPreparationNote (preparationNote.id()).isPresent() ?
+                      updateSQL(preparationNote) :
+                      insertSQL(preparationNote );
+
+      stmt.executeUpdate(sql);
+
+    } catch (SQLException e){
+      throw new RuntimeException(e);
+    }
+  }
+
+  /*
+  CREATE TABLE IF NOT EXISTS preparationNote(
+      id VARCHAR(50) PRIMARY KEY,
+      note VARCHAR(50) NOT NULL,
+      operationsId VARCHAR(50) NOT NULL,
+      lastUpdate TIMESTAMP NOT NULL,
+      FOREIGN KEY (operationsId) REFERENCES operations(id)
+    );
+   */
+  private static String updateSQL(PreparationNote preparationNote){
+    return
+            "UPDATE preparationNote SET " +
+                    "note = " + sqlValue(preparationNote.note()) + "," +
+                    "lastUpdate = " + sqlValue(preparationNote.lastUpdate()) + " " +
+                    "WHERE id = " + sqlValue(preparationNote.id().value()) + ";";
+  }
+
+  private static String insertSQL(PreparationNote preparationNote){
+    return
+            "INSERT INTO preparationNote(" +
+                    "id,note,operationsId,lastUpdate" +
+                    ") VALUES (" +
+                    sqlValue(preparationNote.id().value()) + "," +
+                    sqlValue(preparationNote.note()) + "," +
+                    sqlValue(preparationNote.operationsId()) + "," +
+                    sqlValue(preparationNote.lastUpdate()) +
+                    ");";
+  }
+
+  @Override
+  public PreparationNote deletePreparationNote(Id<PreparationNote> id) {
+    var preparationNote = findPreparationNote(id);
+
+    if(preparationNote.isPresent()) {
+      var sql = "DELETE FROM preparationNote WHERE id = " + quoted(id.value()) + ";";
+
+      try {
+        conn.createStatement().executeUpdate(sql);
+        return preparationNote.get();
+      } catch (SQLException e) {
+        throw new RuntimeException(e);
+      }
+    }
+    return null;
+  }
+
+  @Override
+  public Id<Room> roomId() {
+
+    var id = new Id<Room>(randomUUID().toString());
+
+    return findRoom(id).isEmpty() ? id : roomId();
+  }
+
+  public Optional<Room> findRoom(Id<Room> id){
+    try (
+            var result =
+                    conn.createStatement()
+                            .executeQuery("SELECT * FROM room WHERE id = " +sqlValue(id.value()) + ";")
+    ){
+      return
+              result.next() ?
+                      Optional.of(readRoomFromRow(result)) :
+                      Optional.empty();
+
+    } catch (SQLException e){
+      throw new RuntimeException(e);
+    }
+  }
+
+  private static Room readRoomFromRow(ResultSet rs) throws SQLException {
+
+    return new Room(
+            new Id<>(rs.getString("id")),
+            rs.getString("roomName"),
+            rs.getTimestamp("lastUpdate").toInstant()
+    );
+  }
+
+  @Override
+  public void save(Room room) {
+    try (
+            var stmt = conn.createStatement()
+    ){
+      var sql =
+              findRoom(room.id()).isPresent() ?
+                      updateSQL(room) :
+                      insertSQL(room);
+
+      stmt.executeUpdate(sql);
+
+
+    } catch (SQLException e){
+      throw new RuntimeException(e);
+    }
+  }
+
+  private static String updateSQL(Room room){
+    return
+            "UPDATE room SET " +
+                    "roomName = " + sqlValue(room.roomName()) + "," +
+                    "lastUpdate = " + sqlValue(room.lastUpdate()) + " " +
+                    "WHERE id = " + sqlValue(room.id().value()) + ";";
+  }
+
+  private static String insertSQL(Room room){
+    return
+            "INSERT INTO room(" +
+                    "id,roomName,lastUpdate" +
+                    ") VALUES (" +
+                    sqlValue(room.id().value()) + "," +
+                    sqlValue(room.roomName()) + "," +
+                    sqlValue(room.lastUpdate()) +
+                    ");";
+  }
+
+  @Override
+  public Room deleteRoom(Id<Room> id) {
+    var room = findRoom(id);
+
+    if(room.isPresent()) {
+      var sql = "DELETE FROM room WHERE id =" + quoted(id.value()) + ";";
+
+      try {
+        conn.createStatement().executeUpdate(sql);
+        return room.get();
+      } catch (SQLException e) {
+        throw new RuntimeException(e);
+      }
+    }
+    return null;
+  }
+
 }
 
 

opp/jdbc-repo-impl/src/test/java/Tests.java

@@ -36,6 +36,14 @@ public final class Tests
 
   private static OperationTeamService operationTeamService;
 
+  private static PreparationNote testPreparationNote = null;
+
+  private static PreparationNoteService preparationNoteService;
+
+  private static Room testRoom = null;
+
+  private static RoomService roomService;
+
   @BeforeClass
   public static void init() throws Exception {
 
@@ -90,14 +98,32 @@ public final class Tests
             Instant.now()
     );
 
+    testPreparationNote = new PreparationNote(
+            new Id<>("note1111"),
+            ("Test notiz!"),
+            testOperation.id(),
+            Instant.now()
+    );
+
+    testRoom = new Room(
+            new Id<>("room1111"),
+            ("Test Raum"),
+            Instant.now()
+    );
+
     operationService = new OperationServiceImpl(repo);
 
     opStaffService = new OPStaffServiceImpl(repo);
 
     operationTeamService = new OperationTeamImpl(repo);
 
+    preparationNoteService = new PreparationNoteImpl(repo);
+
+    roomService = new RoomServiceImpl(repo);
+
   }
 
+@Ignore
   @Test
   public void testRepoOperationSave(){
 
@@ -113,6 +139,168 @@ public final class Tests
     );
   }
 
+@Ignore
+  @Test
+  public void testCreatePreparationNote() throws Exception {
+
+    PreparationNote.Create createCommand = new PreparationNote.Create(
+            ("Notiz erstellt mit Command"),
+            testOperation.id()
+    );
+
+    PreparationNote createdPreparationNote = preparationNoteService.process(createCommand);
+
+    assertTrue(
+            repo.findPreparationNote(createdPreparationNote.id()).isPresent()
+    );
+  }
+
+
+  @Ignore
+  @Test
+  public void testUpdatePreparationNote() throws Exception {
+
+    PreparationNote.Update updateCommand = new PreparationNote.Update(
+            testPreparationNote.id(),
+            ("COmmand wurde hier geupdaet!?!?!?!?")
+    );
+
+    PreparationNote updatePreparationNote = preparationNoteService.process(updateCommand);
+
+    Optional<PreparationNote> readPreparationNote = repo.findPreparationNote(updatePreparationNote.id());
+
+    if (readPreparationNote.isPresent()) {
+      assertNotEquals(readPreparationNote.get().note(), testPreparationNote.note());
+
+      assertEquals(readPreparationNote.get().operationsId(), testPreparationNote.operationsId());
+
+      assertEquals(readPreparationNote.get().id(), testPreparationNote.id());
+
+      assertNotEquals(readPreparationNote.get().lastUpdate(), testPreparationNote.lastUpdate());
+    } else {
+      throw new Exception();
+    }
+  }
+
+
+  @Ignore
+  @Test
+  public void testDeletePreparationNote() throws Exception {
+
+    repo.save(testPreparationNote);
+
+    PreparationNote.Delete deleteCommand = new PreparationNote.Delete(
+            testPreparationNote.id()
+    );
+
+    PreparationNote deletePreparationNote = preparationNoteService.process(deleteCommand);
+
+    assertFalse(repo.findPreparationNote(deletePreparationNote.id()).isPresent());
+  }
+
+  @Ignore
+  @Test
+  public void testRepoPreparationNoteSave(){
+
+    try {
+      repo.save(testPreparationNote);
+    } catch (Exception e){
+      e.printStackTrace();
+    }
+
+    assertTrue(
+            repo.findPreparationNote(testPreparationNote.id()).isPresent()
+    );
+  }
+
+
+
+  @Ignore
+  @Test
+  public void testRepoPreparationNoteUpdate() throws Exception {
+
+    try {
+      repo.save(testPreparationNote);
+    } catch (Exception e){
+      e.printStackTrace();
+    }
+
+    PreparationNote updatedTestPreparatioNote = new PreparationNote(
+            testPreparationNote.id(),
+            ("ES WURDE GEUPDATED!!!"),
+            testPreparationNote.operationsId(),
+            Instant.now()
+    );
+
+    try {
+      repo.save(updatedTestPreparatioNote);
+    } catch (Exception e){
+      e.printStackTrace();
+    }
+
+    Optional<PreparationNote> readPreparationNote = repo.findPreparationNote(updatedTestPreparatioNote.id());
+    if (readPreparationNote.isPresent()) {
+      assertNotEquals(readPreparationNote.get().note(), testPreparationNote.note());
+      assertNotEquals(readPreparationNote.get().lastUpdate(), testPreparationNote.lastUpdate());
+    } else {
+      throw new Exception();
+    }
+  }
+  @Ignore
+  @Test
+  public void testCreateRoom() throws Exception{
+
+    Room.Create createCommand = new Room.Create(
+            "Neuen Raum erstellt mit Command"
+    );
+
+    Room createdRoom = roomService.process(createCommand);
+
+    assertNotNull("Room should be created", createdRoom);
+    assertNotNull("Room ID should not be null", createdRoom.id());
+    assertTrue(
+            repo.findRoom(createdRoom.id()).isPresent()
+    );
+  }
+  @Ignore
+  @Test
+  public void testRoomUpdate() throws Exception {
+ // repo.save(testRoom);
+    Room.Update updateCommand = new Room.Update(
+            testRoom.id(),
+            ("COmmand wurde hier geupdaet!?!?!?!?")
+    );
+
+    Room updateRoom = roomService.process(updateCommand);
+
+    Optional<Room> readRoom = repo.findRoom(updateRoom.id());
+
+    if (readRoom.isPresent()) {
+      assertNotEquals(readRoom.get().roomName(), testRoom.roomName());
+
+      assertEquals(readRoom.get().id(), testRoom.id());
+
+      assertNotEquals(readRoom.get().lastUpdate(), testRoom.lastUpdate());
+    } else {
+      throw new Exception();
+    }
+  }
+
+  @Test
+  public void testDeleteRoom() throws Exception {
+
+  //  repo.save(testRoom);
+
+    Room.Delete deleteCommand = new Room.Delete(
+            testRoom.id()
+    );
+
+    Room deleteRoom = roomService.process(deleteCommand);
+
+    assertFalse(repo.findRoom(deleteRoom.id()).isPresent());
+  }
+
+  @Ignore
   @Test
   public void testRepoOperationUpdate() throws Exception {
 
@@ -148,6 +336,7 @@ public final class Tests
     }
   }
 
+  @Ignore
   @Test
   public void testRepoOperationDelete() {
       try {
@@ -166,7 +355,7 @@ public final class Tests
 
       assertFalse(repo.findOperation(testOperation.id()).isPresent());
   }
-
+@Ignore
   @Test
   public void testCreateOperation() throws Exception {
 
@@ -186,7 +375,7 @@ public final class Tests
             repo.findOperation(createdOperation.id()).isPresent()
     );
   }
-
+@Ignore
   @Test
   public void testUpdateOperation() throws Exception {
 
@@ -219,6 +408,7 @@ public final class Tests
     }
   }
 
+@Ignore
   @Test
   public void testDeleteOperation() throws Exception {
 
@@ -231,9 +421,10 @@ public final class Tests
 
     Operation deleteOperation = operationService.process(deleteCommand);
 
-    assertFalse(repo.findOperation(deleteOperation.id()).isPresent());
+   assertFalse(repo.findOperation(deleteOperation.id()).isPresent());
   }
 
+  @Ignore
   @Test
   public void testGetOperation() throws Exception {
     repo.save(testOperationTeam1);
@@ -253,6 +444,7 @@ public final class Tests
     }
   }
 
+  @Ignore
   @Test
   public void testGetOperations() throws Exception {
 
@@ -270,7 +462,7 @@ public final class Tests
       assertEquals(operation.date(), testDate);
     }
   }
-
+@Ignore
   @Test
   public void testRepoOPStaffSave(){
 
@@ -284,7 +476,7 @@ public final class Tests
             repo.findOPStaff(testOPStaff1.id()).isPresent()
     );
   }
-
+@Ignore
   @Test
   public void testRepoOPStaffUpdate() throws Exception {
 
@@ -316,6 +508,7 @@ public final class Tests
     }
   }
 
+  @Ignore
   @Test
   public void testRepoOPStaffDelete() {
     try {
@@ -333,6 +526,7 @@ public final class Tests
     assertFalse(repo.findOPStaff(testOPStaff1.id()).isPresent());
   }
 
+  @Ignore
   @Test
   public void testCreateOPStaff() throws Exception {
 
@@ -348,6 +542,7 @@ public final class Tests
     );
   }
 
+  @Ignore
   @Test
   public void testUpdateOPStaff() throws Exception {
 
@@ -374,6 +569,7 @@ public final class Tests
     }
   }
 
+@Ignore
   @Test
   public void testDeleteOPStaff() throws Exception {
 
@@ -388,6 +584,7 @@ public final class Tests
     assertFalse(repo.findOPStaff(deletedOPStaff.id()).isPresent());
   }
 
+ @Ignore
   @Test
   public void testGetOPStaff() throws Exception {
     repo.save(testOPStaff1);
@@ -403,6 +600,7 @@ public final class Tests
     }
   }
 
+  @Ignore
   @Test
   public void testGetOPStaffs() throws Exception {
 
@@ -419,6 +617,7 @@ public final class Tests
     assertEquals(2, filteredList.size());
   }
 
+  @Ignore
   @Test
   public void testRepoOperationTeamAssignStaff(){
 
@@ -441,6 +640,7 @@ public final class Tests
     }
   }
 
+  @Ignore
   @Test
   public void testCreateOperationTeam() throws Exception {
 
@@ -494,8 +694,7 @@ public final class Tests
       throw new Exception();
     }
   }
-
-  @Ignore
+@Ignore
   @Test
   public void testRepoOperationTeamDelete() {
     try {
@@ -517,6 +716,7 @@ public final class Tests
     assertFalse(repo.findOperationTeam(testOperationTeam1.id()).isPresent());
   }
 
+
   @Ignore
   @Test
   public void testDeleteOperationTeam() throws Exception {
@@ -581,7 +781,7 @@ public final class Tests
     assertTrue(result);
   }
 
-  @Ignore
+@Ignore
   @Test
   public void testAssignStaffToOperationTeam() throws Exception {
 
@@ -600,7 +800,10 @@ public final class Tests
     assertTrue(result);
   }
 
-  @Ignore
+
+
+
+@Ignore
   @Test
   public void testRemoveOPStaffsInOperationTeams() throws Exception{
 
@@ -612,6 +815,7 @@ public final class Tests
     OperationTeam removedTeam = operationTeamService.process(removeStaffCommand);
 
     assertEquals(testOperationTeam1.id().value(), removedTeam.id().value());
+    assertFalse(repo.findOperationTeamOPStaff(testOperationTeam1.id(), testOPStaff1.id()));
   }
 }