Merge branch 'master' into ozg-2956-mongodb-tls

nachrichten-manager/src/test/java/de/ozgcloud/nachrichten/postfach/bayernid/GrpcSendBayernIdMessageResponseTestFactory.java → bescheid-manager/src/test/java/de/ozgcloud/bescheid/BescheidManagerConfigTestFactory.java

@@ -21,23 +21,24 @@
  * Die sprachspezifischen Genehmigungen und Beschränkungen
  * unter der Lizenz sind dem Lizenztext zu entnehmen.
  */
-package de.ozgcloud.nachrichten.postfach.bayernid;
+package de.ozgcloud.bescheid;
 
-import de.ozgcloud.nachrichten.postfach.bayernid.proxy.GrpcSendBayernIdMessageResponse;
+import de.ozgcloud.bescheid.BescheidManagerConfig.BescheidManagerConfigBuilder;
+import de.ozgcloud.bescheid.BescheidManagerConfig.Features;
 
-public class GrpcSendBayernIdMessageResponseTestFactory {
+public class BescheidManagerConfigTestFactory {
 
-	public static final String STATUS = "code";
-	public static final String MESSAGE_TEXT = "messageText";
+	public static final String VERSION = "1.0.0";
+	public static final String JAVA_VERSION = "21";
 
-	public static GrpcSendBayernIdMessageResponse create() {
+	public static BescheidManagerConfig create() {
 		return createBuilder().build();
 	}
 
-	public static GrpcSendBayernIdMessageResponse.Builder createBuilder() {
-		return GrpcSendBayernIdMessageResponse.newBuilder()
-				.setSuccess(true)
-				.setStatus(STATUS)
-				.setMessage(MESSAGE_TEXT);
+	public static BescheidManagerConfigBuilder createBuilder() {
+		return BescheidManagerConfig.builder()
+				.version(VERSION)
+				.javaVersion(JAVA_VERSION)
+				.features(Features.builder().canCreateBescheidDocument(true).build());
 	}
 }

bescheid-manager/src/test/java/de/ozgcloud/bescheid/BescheidServiceTest.java

@@ -5,7 +5,6 @@ import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
-import java.util.Collections;
 import java.util.Map;
 import java.util.Optional;
 
@@ -20,6 +19,7 @@ import org.mockito.Captor;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Spy;
+import org.springframework.boot.info.BuildProperties;
 import org.springframework.test.util.ReflectionTestUtils;
 
 import de.ozgcloud.bescheid.attacheditem.AttachedItem;
@@ -57,6 +57,8 @@ class BescheidServiceTest {
 	private UserProfile callContextUser;
 	@Mock
 	private ClientAttributeService clientAttributeService;
+	@Mock
+	private BuildProperties buildProperties;
 
 	@BeforeEach
 	void init() {
@@ -107,14 +109,6 @@ class BescheidServiceTest {
 		@BeforeEach
 		void init() {
 			doNothing().when(service).validateBescheidSendManually(any(), anyLong());
-			doReturn(bescheidItem).when(attachedItemService).getItem(anyString());
-		}
-
-		@Test
-		void shouldCallGetItem() {
-			sendBescheid();
-
-			verify(attachedItemService).getItem(AttachedItemTestFactory.ID);
 		}
 
 		@Test
@@ -132,7 +126,7 @@ class BescheidServiceTest {
 		}
 
 		private void sendBescheid() {
-			service.sendBescheidManually(AttachedItemTestFactory.ID, AttachedItemTestFactory.VERSION);
+			service.sendBescheidManually(bescheidItem, AttachedItemTestFactory.VERSION);
 		}
 	}
 
@@ -171,7 +165,7 @@ class BescheidServiceTest {
 	@Nested
 	class TestSendBescheidPostfachMail {
 
-		private final AttachedItem bescheidItem = AttachedItemTestFactory.createBescheid();
+		private AttachedItem bescheidItem;
 		@Mock
 		private AttachedItem bescheidSendItem;
 		@Captor
@@ -179,21 +173,15 @@ class BescheidServiceTest {
 
 		@BeforeEach
 		void init() {
+			var item = AttachedItemTestFactory.createBescheidItem();
+			item.put(Bescheid.FIELD_SEND_BY, Bescheid.SendBy.NACHRICHT.name());
+			bescheidItem = AttachedItemTestFactory.createBescheidBuilder().item(item).build();
+
 			doNothing().when(service).validateBescheidSendPostfach(any(), anyLong());
-			doReturn(bescheidItem).when(attachedItemService).getItem(anyString());
 			lenient().when(callContextUser.getId()).thenReturn(UserId.from("user-id"));
 			lenient().when(currentUserService.getUserProfile()).thenReturn(callContextUser);
 		}
 
-		@Test
-		void shouldCallGetItem() {
-			when(vorgangService.getById(any())).thenReturn(VorgangTestFactory.create());
-
-			sendBescheid();
-
-			verify(attachedItemService).getItem(AttachedItemTestFactory.ID);
-		}
-
 		@Test
 		void shouldCallValidateBescheid() {
 			when(vorgangService.getById(any())).thenReturn(VorgangTestFactory.create());
@@ -232,7 +220,7 @@ class BescheidServiceTest {
 
 			sendBescheid();
 
-			verify(nachrichtService).createNachrichtDraft(bescheid);
+			verify(nachrichtService).sendNachricht(bescheid);
 		}
 
 		@Test
@@ -245,7 +233,7 @@ class BescheidServiceTest {
 		}
 
 		private void sendBescheid() {
-			service.sendBescheidPostfachMail(AttachedItemTestFactory.ID, AttachedItemTestFactory.VERSION);
+			service.sendBescheidPostfachMail(bescheidItem, AttachedItemTestFactory.VERSION);
 		}
 	}
 
@@ -473,19 +461,10 @@ class BescheidServiceTest {
 		private AttachedItem bescheidSendItem;
 
 		@Test
-		void shouldCallBuildBescheidSend() {
-			sendBescheid();
-
-			verify(service).setBescheidSendStatus(bescheidItem);
-		}
-
-		@Test
-		void shouldCallPatch() {
-			doReturn(bescheidSendItem).when(service).setBescheidSendStatus(any());
-
+		void shouldCallSetBescheidStatusSent() {
 			sendBescheid();
 
-			verify(attachedItemService).patch(bescheidSendItem);
+			verify(attachedItemService).setBescheidStatus(AttachedItemTestFactory.ID, AttachedItemTestFactory.VERSION, Bescheid.Status.SENT);
 		}
 
 		@Test
@@ -496,34 +475,12 @@ class BescheidServiceTest {
 		}
 
 		@Test
-		void shouldCallGetItem() {
-			when(attachedItemService.getItem(any())).thenReturn(AttachedItemTestFactory.createBescheid());
-			doThrow(new TechnicalException("error")).when(vorgangService).bescheiden(anyString());
-
-			assertThrows(TechnicalException.class, this::sendBescheid);
-
-			verify(attachedItemService).getItem(AttachedItemTestFactory.ID);
-		}
-
-		@Test
-		void shouldCallSetBescheidDraftStatus() {
-			doThrow(new TechnicalException("error")).when(vorgangService).bescheiden(anyString());
-			var updatedBescheidUitem = AttachedItemTestFactory.createBescheid();
-			when(attachedItemService.getItem(any())).thenReturn(updatedBescheidUitem);
-
-			assertThrows(TechnicalException.class, this::sendBescheid);
-
-			verify(service).setBescheidDraftStatus(updatedBescheidUitem);
-		}
-
-		@Test
-		void shouldCallPatchWhenBescheidenFails() {
-			doReturn(bescheidSendItem).when(service).setBescheidDraftStatus(any());
+		void shouldCallSetBescheidStatusDraft() {
 			doThrow(new TechnicalException("error")).when(vorgangService).bescheiden(anyString());
 
 			assertThrows(TechnicalException.class, this::sendBescheid);
 
-			verify(attachedItemService).patch(bescheidSendItem);
+			verify(attachedItemService).setBescheidStatus(AttachedItemTestFactory.ID, AttachedItemTestFactory.VERSION, Bescheid.Status.SENT);
 		}
 
 		@Test
@@ -570,28 +527,77 @@ class BescheidServiceTest {
 	}
 
 	@Nested
-	class TestSetBescheidSendStatus {
+	class TestGetConfig {
 
 		@Test
-		void shouldSetSendStatus() {
-			var bescheidItem = AttachedItemTestFactory.createBescheid();
+		void shouldCallGetVersion() {
+			service.getConfig();
+
+			verify(buildProperties).getVersion();
+		}
+
+		@Test
+		void shouldSetBescheidManagerVersion() {
+			when(buildProperties.getVersion()).thenReturn(BescheidManagerConfigTestFactory.VERSION);
+
+			var result = service.getConfig();
+
+			assertThat(result.getVersion()).isEqualTo(BescheidManagerConfigTestFactory.VERSION);
+		}
+
+		@Test
+		void shouldCallGetJavaVersion() {
+			service.getConfig();
+
+			verify(service).getJavaVersion();
+		}
+
+		@Test
+		void shouldSetJavaVersion() {
+			when(service.getJavaVersion()).thenReturn(BescheidManagerConfigTestFactory.JAVA_VERSION);
+
+			var result = service.getConfig();
+
+			assertThat(result.getJavaVersion()).isEqualTo(BescheidManagerConfigTestFactory.JAVA_VERSION);
+		}
+
+		@Test
+		void shouldCallBuildFeatures() {
+			service.getConfig();
+
+			verify(service).buildFeatures();
+		}
 
-			var result = service.setBescheidSendStatus(bescheidItem);
+		@Test
+		void shouldSetFeatures() {
+			var features = BescheidManagerConfig.Features.builder().build();
+			when(service.buildFeatures()).thenReturn(features);
+
+			var result = service.getConfig();
 
-			assertThat(result.getItem()).containsEntry(Bescheid.FIELD_STATUS, Bescheid.Status.SEND.name());
+			assertThat(result.getFeatures()).isSameAs(features);
 		}
+
 	}
 
 	@Nested
-	class TestSetBescheidDraftStatus {
+	class TestBuildFeatures {
 
 		@Test
-		void shouldSetDraftStatus() {
-			var bescheidItem = AttachedItemTestFactory.createBescheidBuilder().item(Collections.emptyMap()).build();
+		void shouldSetCannotCreateBescheidDocument() {
+			ReflectionTestUtils.setField(service, "remoteService", Optional.empty());
+
+			var result = service.buildFeatures();
 
-			var result = service.setBescheidDraftStatus(bescheidItem);
+			assertThat(result.isCanCreateBescheidDocument()).isFalse();
+		}
+
+		@Test
+		void shouldSetCanCreateBescheidDocument() {
+			var result = service.buildFeatures();
 
-			assertThat(result.getItem()).containsEntry(Bescheid.FIELD_STATUS, Bescheid.Status.DRAFT.name());
+			assertThat(result.isCanCreateBescheidDocument()).isTrue();
 		}
+
 	}
 }

bescheid-manager/src/test/java/de/ozgcloud/bescheid/BescheidTestFactory.java

@@ -10,6 +10,7 @@ import com.thedeanda.lorem.LoremIpsum;
 import de.ozgcloud.bescheid.common.callcontext.UserProfileTestFactory;
 import de.ozgcloud.bescheid.vorgang.ServiceKontoTestFactory;
 import de.ozgcloud.bescheid.vorgang.VorgangTestFactory;
+import de.ozgcloud.common.binaryfile.FileId;
 import de.ozgcloud.common.binaryfile.TempFileUtils;
 
 public class BescheidTestFactory {
@@ -36,6 +37,7 @@ public class BescheidTestFactory {
 				.contentType(CONTENT_TYPE)
 				.bescheidFileName(FILE_NAME)
 				.bescheidFile(BESCHEID_FILE)
+				.bescheidFileId(FileId.from(BESCHEID_FILE_ID))
 				.nachrichtSubject(Optional.of(NACHRICHT_SUBJECT))
 				.nachrichtText(Optional.of(NACHRICHT_TEXT))
 				.genehmigt(true)

bescheid-manager/src/test/java/de/ozgcloud/bescheid/GrpcBescheidItemMapperTest.java

@@ -8,7 +8,7 @@ import org.mapstruct.factory.Mappers;
 
 class GrpcBescheidItemMapperTest {
 
-	private GrpcBescheidMapper mapper = Mappers.getMapper(GrpcBescheidMapper.class);
+	private final GrpcBescheidMapper mapper = Mappers.getMapper(GrpcBescheidMapper.class);
 
 	@Nested
 	class TestFromBescheid {
@@ -21,4 +21,15 @@ class GrpcBescheidItemMapperTest {
 		}
 	}
 
+	@Nested
+	class TestFromBescheidManagerConfig {
+
+		@Test
+		void shouldMapAllFields() {
+			var result = mapper.fromBescheidManagerConfig(BescheidManagerConfigTestFactory.create());
+
+			assertThat(result).usingRecursiveComparison().isEqualTo(GrpcBescheidManagerConfigResponseTestFactory.create());
+		}
+	}
+
 }

nachrichten-bayernid-proxy/bayernid-proxy-impl/src/test/java/de/ozgcloud/nachrichten/postfach/bayernid/proxy/GrpcAttachmentMetadataTestFactory.java → bescheid-manager/src/test/java/de/ozgcloud/bescheid/GrpcBescheidManagerConfigResponseTestFactory.java

@@ -21,20 +21,18 @@
  * Die sprachspezifischen Genehmigungen und Beschränkungen
  * unter der Lizenz sind dem Lizenztext zu entnehmen.
  */
-package de.ozgcloud.nachrichten.postfach.bayernid.proxy;
+package de.ozgcloud.bescheid;
 
-public class GrpcAttachmentMetadataTestFactory {
+public class GrpcBescheidManagerConfigResponseTestFactory {
 
-	public static final String FILE_TYPE = "plain/text";
-	public static final String FILE_NAME = "test.txt";
-
-	public static GrpcAttachmentMetadata create() {
+	public static GrpcBescheidManagerConfigResponse create() {
 		return createBuilder().build();
 	}
 
-	public static GrpcAttachmentMetadata.Builder createBuilder() {
-		return GrpcAttachmentMetadata.newBuilder()
-				.setFileType(FILE_TYPE)
-				.setFileName(FILE_NAME);
+	public static GrpcBescheidManagerConfigResponse.Builder createBuilder() {
+		return GrpcBescheidManagerConfigResponse.newBuilder()
+				.setVersion(BescheidManagerConfigTestFactory.VERSION)
+				.setJavaVersion(BescheidManagerConfigTestFactory.JAVA_VERSION)
+				.setFeatures(GrpcBescheidManagerFeatures.newBuilder().setCanCreateBescheidDocument(true).build());
 	}
 }

bescheid-manager/src/test/java/de/ozgcloud/bescheid/attacheditem/AttachedItemMapperTest.java

@@ -26,23 +26,37 @@ package de.ozgcloud.bescheid.attacheditem;
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
+import java.util.List;
+import java.util.Map;
+
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
 import org.mapstruct.factory.Mappers;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.Spy;
 
+import de.ozgcloud.bescheid.Bescheid;
+import de.ozgcloud.bescheid.GrpcBescheid;
 import de.ozgcloud.document.DocumentService;
 import de.ozgcloud.vorgang.common.grpc.GrpcObjectMapper;
 
 class AttachedItemMapperTest {
 
+	@Spy
 	@InjectMocks
 	private AttachedItemMapper mapper = Mappers.getMapper(AttachedItemMapper.class);
 
 	@Mock
 	private GrpcObjectMapper grpcObjectMapper;
 
+	@Nested
+	class TestMapFromVorgangAttachedItem {
+
 		@BeforeEach
 		void init() {
 			when(grpcObjectMapper.mapFromGrpc(any())).thenReturn(AttachedItemTestFactory.createDocumentItem());
@@ -57,5 +71,132 @@ class AttachedItemMapperTest {
 
 			assertThat(result).usingRecursiveComparison().isEqualTo(AttachedItemTestFactory.createDocument());
 		}
+	}
+
+	@Nested
+	class TestToBescheid {
+
+		@Test
+		void shouldSetBeschiedenAm() {
+			var bescheid = mapBescheid();
+
+			assertThat(bescheid.getBeschiedenAm()).isEqualTo(AttachedItemTestFactory.BESCHEIDEN_AM);
+		}
+
+		@Test
+		void shouldSetBewilligt() {
+			var bescheid = mapBescheid();
+
+			assertThat(bescheid.getBewilligt()).isTrue();
+		}
+
+		@Test
+		void shouldSetBescheidDocument() {
+			var bescheid = mapBescheid();
+
+			assertThat(bescheid.getBescheidDocument()).isEqualTo(AttachedItemTestFactory.BESCHEID_DOCUMENT);
+		}
+
+		@Test
+		void shouldSetSendBy() {
+			var bescheid = mapBescheid();
+
+			assertThat(bescheid.getSendBy()).isEqualTo(AttachedItemTestFactory.SEND_BY.name());
+		}
+
+		@Test
+		void shouldSetNachrichtText() {
+			var bescheid = mapBescheid();
+
+			assertThat(bescheid.getNachrichtText()).isEqualTo(AttachedItemTestFactory.NACHRICHT_TEXT);
+		}
+
+		@Test
+		void shouldSetNachrichtSubject() {
+			var bescheid = mapBescheid();
+
+			assertThat(bescheid.getNachrichtSubject()).isEqualTo(AttachedItemTestFactory.NACHRICHT_SUBJECT);
+		}
+
+		@Test
+		void shouldCallToAttachments() {
+			var expectedAttachments = List.of(AttachedItemTestFactory.ATTACHMENT);
+			var bescheidItem = AttachedItemTestFactory.createBescheidBuilder()
+					.item(Map.of(Bescheid.FIELD_ATTACHMENTS, expectedAttachments)).build();
+
+			mapper.toBescheid(bescheidItem);
+
+			verify(mapper).toAttachments(expectedAttachments);
+		}
+
+		@Test
+		void shouldNotCallToAttachments() {
+			var bescheidItem = AttachedItemTestFactory.createBescheidBuilder().clearItem().build();
+
+			mapper.toBescheid(bescheidItem);
+
+			verify(mapper, never()).toAttachments(any());
+		}
+
+		@Test
+		void shouldSetAttachments() {
+			doReturn(List.of(AttachedItemTestFactory.ATTACHMENT)).when(mapper).toAttachments(any());
+
+			var bescheid = mapBescheid();
+
+			assertThat(bescheid.getAttachmentsList()).containsExactly(AttachedItemTestFactory.ATTACHMENT);
+		}
+
+		@Test
+		void shouldSetId() {
+			var bescheid = mapBescheid();
+
+			assertThat(bescheid.getId()).isEqualTo(AttachedItemTestFactory.ID);
+		}
+
+		@Test
+		void shouldSetVersion() {
+			var bescheid = mapBescheid();
+
+			assertThat(bescheid.getVersion()).isEqualTo(AttachedItemTestFactory.VERSION);
+		}
+
+		@Test
+		void shouldSetStatus() {
+			var bescheid = mapBescheid();
 
+			assertThat(bescheid.getStatus()).isEqualTo(Bescheid.Status.DRAFT.name());
+		}
+
+		private GrpcBescheid mapBescheid() {
+			return mapper.toBescheid(AttachedItemTestFactory.createBescheid());
+		}
+	}
+
+	@Nested
+	class TestToAttachments {
+
+		@Test
+		void shouldMapCollection() {
+			var result = mapper.toAttachments(List.of(AttachedItemTestFactory.ATTACHMENT));
+
+			assertThat(result).containsExactly(AttachedItemTestFactory.ATTACHMENT);
+		}
+
+		@Test
+		void shouldMapSingleValue() {
+			var result = mapper.toAttachments(AttachedItemTestFactory.ATTACHMENT);
+
+			assertThat(result).containsExactly(AttachedItemTestFactory.ATTACHMENT);
+		}
+
+		@DisplayName("should return null")
+		@ParameterizedTest(name = "when attachmentsObject is \"{0}\"")
+		@NullAndEmptySource
+		void shouldReturnNull(String attachmentsObject) {
+			var result = mapper.toAttachments(attachmentsObject);
+
+			assertThat(result).isNull();
+		}
+	}
 }
\ No newline at end of file

bescheid-manager/src/test/java/de/ozgcloud/bescheid/attacheditem/BescheidItemMapperTest.java

-/*
- * Copyright (C) 2024 Das Land Schleswig-Holstein vertreten durch den
- * Ministerpräsidenten des Landes Schleswig-Holstein
- * Staatskanzlei
- * Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
- *
- * Lizenziert unter der EUPL, Version 1.2 oder - sobald
- * diese von der Europäischen Kommission genehmigt wurden -
- * Folgeversionen der EUPL ("Lizenz");
- * Sie dürfen dieses Werk ausschließlich gemäß
- * dieser Lizenz nutzen.
- * Eine Kopie der Lizenz finden Sie hier:
- *
- * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
- *
- * Sofern nicht durch anwendbare Rechtsvorschriften
- * gefordert oder in schriftlicher Form vereinbart, wird
- * die unter der Lizenz verbreitete Software "so wie sie
- * ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
- * ausdrücklich oder stillschweigend - verbreitet.
- * Die sprachspezifischen Genehmigungen und Beschränkungen
- * unter der Lizenz sind dem Lizenztext zu entnehmen.
- */
-package de.ozgcloud.bescheid.attacheditem;
-
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-
-import java.util.List;
-import java.util.Map;
-
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.NullAndEmptySource;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.Spy;
-
-import de.ozgcloud.bescheid.GrpcBescheid;
-import de.ozgcloud.command.CommandTestFactory;
-import de.ozgcloud.vorgang.common.grpc.GrpcObjectMapper;
-import de.ozgcloud.vorgang.vorgangAttachedItem.GrpcFindVorgangAttachedItemResponse;
-
-class BescheidItemMapperTest {
-
-	@Spy
-	@InjectMocks
-	private BescheidItemMapper mapper;
-
-	@Mock
-	private GrpcObjectMapper grpcObjectMapper;
-
-	@Nested
-	class TestFromFindVorgangAttachedItemResponse {
-
-		GrpcFindVorgangAttachedItemResponse grpcResponse = GrpcFindVorgangAttachedItemResponseTestFactory.create();
-
-		@Test
-		void shouldCallMapFromVorgangAttachedItem() {
-			mapper.fromFindVorgangAttachedItemResponse(grpcResponse).toList();
-
-			verify(mapper).mapFromVorgangAttachedItem(grpcResponse.getVorgangAttachedItems(0));
-		}
-
-		@Test
-		void shouldReturnBescheidITem() {
-			var bescheid = BescheidItemTestFactory.create();
-			doReturn(bescheid).when(mapper).mapFromVorgangAttachedItem(any());
-
-			var result = mapper.fromFindVorgangAttachedItemResponse(grpcResponse).toList();
-
-			assertThat(result).first().isEqualTo(bescheid);
-		}
-	}
-
-	@Nested
-	class TestMapFromVorgangAttachedItem {
-
-		@Test
-		void shouldSetId() {
-			var result = mapper.mapFromVorgangAttachedItem(GrpcVorgangAttachedItemTestFactory.create());
-
-			assertThat(result.getId()).isEqualTo(BescheidItemTestFactory.ID);
-		}
-
-		@Test
-		void shouldSetVersion() {
-			var grpcAttachedItem = GrpcVorgangAttachedItemTestFactory.createBuilder().setVersion(BescheidItemTestFactory.VERSION).build();
-
-			var result = mapper.mapFromVorgangAttachedItem(grpcAttachedItem);
-
-			assertThat(result.getVersion()).isEqualTo(BescheidItemTestFactory.VERSION);
-		}
-
-		@Test
-		void shouldSetClient() {
-			var result = mapper.mapFromVorgangAttachedItem(GrpcVorgangAttachedItemTestFactory.create());
-
-			assertThat(result.getClient()).isEqualTo(BescheidItemTestFactory.CLIENT);
-		}
-
-		@Test
-		void shouldSetVorgangId() {
-			var result = mapper.mapFromVorgangAttachedItem(GrpcVorgangAttachedItemTestFactory.create());
-
-			assertThat(result.getVorgangId()).isEqualTo(CommandTestFactory.VORGANG_ID);
-		}
-
-		@Test
-		void shouldSetItemName() {
-			var result = mapper.mapFromVorgangAttachedItem(GrpcVorgangAttachedItemTestFactory.create());
-
-			assertThat(result.getItemName()).isEqualTo(AttachedItemService.BESCHEID_ITEM_NAME);
-		}
-
-		@Test
-		void shouldCallGrpcObjectMapper() {
-			var grpcAttachedItem = GrpcVorgangAttachedItemTestFactory.create();
-
-			mapper.mapFromVorgangAttachedItem(grpcAttachedItem);
-
-			verify(grpcObjectMapper).mapFromGrpc(grpcAttachedItem.getItem());
-		}
-
-		@Test
-		void shouldSetBescheidData() {
-			var bescheidData = BescheidItemTestFactory.createBescheidBody();
-			when(grpcObjectMapper.mapFromGrpc(any())).thenReturn(bescheidData);
-
-			var result = mapper.mapFromVorgangAttachedItem(GrpcVorgangAttachedItemTestFactory.create());
-
-			assertThat(result.getBescheidData()).isEqualTo(bescheidData);
-		}
-	}
-
-	@Nested
-	class TestToBescheid {
-
-		@Test
-		void shouldSetBeschiedenAm() {
-			var bescheid = mapBescheid();
-
-			assertThat(bescheid.getBeschiedenAm()).isEqualTo(BescheidItemTestFactory.BESCHEIDEN_AM);
-		}
-
-		@Test
-		void shouldSetBewilligt() {
-			var bescheid = mapBescheid();
-
-			assertThat(bescheid.getBewilligt()).isTrue();
-		}
-
-		@Test
-		void shouldSetBescheidDocument() {
-			var bescheid = mapBescheid();
-
-			assertThat(bescheid.getBescheidDocument()).isEqualTo(BescheidItemTestFactory.BESCHEID_DOCUMENT);
-		}
-
-		@Test
-		void shouldSetSendBy() {
-			var bescheid = mapBescheid();
-
-			assertThat(bescheid.getSendBy()).isEqualTo(BescheidItemTestFactory.SEND_BY);
-		}
-
-		@Test
-		void shouldSetNachrichtText() {
-			var bescheid = mapBescheid();
-
-			assertThat(bescheid.getNachrichtText()).isEqualTo(BescheidItemTestFactory.NACHRICHT_TEXT);
-		}
-
-		@Test
-		void shouldSetNachrichtSubject() {
-			var bescheid = mapBescheid();
-
-			assertThat(bescheid.getNachrichtSubject()).isEqualTo(BescheidItemTestFactory.NACHRICHT_SUBJECT);
-		}
-
-		@Test
-		void shouldCallToAttachments() {
-			var expectedAttachments = List.of(BescheidItemTestFactory.ATTACHMENT);
-			var bescheidItem = BescheidItemTestFactory.createBuilder()
-					.bescheidData(Map.of(BescheidItem.FIELD_ATTACHMENTS, expectedAttachments)).build();
-
-			mapper.toBescheid(bescheidItem);
-
-			verify(mapper).toAttachments(expectedAttachments);
-		}
-
-		@Test
-		void shouldNotCallToAttachments() {
-			var bescheidItem = BescheidItemTestFactory.createBuilder().bescheidData(Map.of()).build();
-
-			mapper.toBescheid(bescheidItem);
-
-			verify(mapper, never()).toAttachments(any());
-		}
-
-		@Test
-		void shouldSetAttachments() {
-			doReturn(List.of(BescheidItemTestFactory.ATTACHMENT)).when(mapper).toAttachments(any());
-
-			var bescheid = mapBescheid();
-
-			assertThat(bescheid.getAttachmentsList()).containsExactly(BescheidItemTestFactory.ATTACHMENT);
-		}
-
-		@Test
-		void shouldSetId() {
-			var bescheid = mapBescheid();
-
-			assertThat(bescheid.getId()).isEqualTo(BescheidItemTestFactory.ID);
-		}
-
-		@Test
-		void shouldSetVersion() {
-			var bescheid = mapBescheid();
-
-			assertThat(bescheid.getVersion()).isEqualTo(BescheidItemTestFactory.VERSION);
-		}
-
-		private GrpcBescheid mapBescheid() {
-			return mapper.toBescheid(BescheidItemTestFactory.create());
-		}
-	}
-
-	@Nested
-	class TestToAttachments {
-
-		@Test
-		void shouldMapCollection() {
-			var result = mapper.toAttachments(List.of(BescheidItemTestFactory.ATTACHMENT));
-
-			assertThat(result).containsExactly(BescheidItemTestFactory.ATTACHMENT);
-		}
-
-		@Test
-		void shouldMapSingleValue() {
-			var result = mapper.toAttachments(BescheidItemTestFactory.ATTACHMENT);
-
-			assertThat(result).containsExactly(BescheidItemTestFactory.ATTACHMENT);
-		}
-
-		@DisplayName("should return null")
-		@ParameterizedTest(name = "when attachmentsObject is \"{0}\"")
-		@NullAndEmptySource
-		void shouldReturnNull(String attachmentsObject) {
-			var result = mapper.toAttachments(attachmentsObject);
-
-			assertThat(result).isNull();
-		}
-	}
-}
\ No newline at end of file

bescheid-manager/src/test/java/de/ozgcloud/bescheid/attacheditem/BescheidItemTestFactory.java

-/*
- * Copyright (C) 2024 Das Land Schleswig-Holstein vertreten durch den
- * Ministerpräsidenten des Landes Schleswig-Holstein
- * Staatskanzlei
- * Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
- *
- * Lizenziert unter der EUPL, Version 1.2 oder - sobald
- * diese von der Europäischen Kommission genehmigt wurden -
- * Folgeversionen der EUPL ("Lizenz");
- * Sie dürfen dieses Werk ausschließlich gemäß
- * dieser Lizenz nutzen.
- * Eine Kopie der Lizenz finden Sie hier:
- *
- * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
- *
- * Sofern nicht durch anwendbare Rechtsvorschriften
- * gefordert oder in schriftlicher Form vereinbart, wird
- * die unter der Lizenz verbreitete Software "so wie sie
- * ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
- * ausdrücklich oder stillschweigend - verbreitet.
- * Die sprachspezifischen Genehmigungen und Beschränkungen
- * unter der Lizenz sind dem Lizenztext zu entnehmen.
- */
-package de.ozgcloud.bescheid.attacheditem;
-
-import java.util.List;
-import java.util.Map;
-
-import de.ozgcloud.bescheid.attacheditem.BescheidItem.BescheidItemBuilder;
-import de.ozgcloud.command.CommandTestFactory;
-
-public class BescheidItemTestFactory {
-
-	public static final String ID = "bescheid-item-id";
-	public static final long VERSION = 10L;
-	public static final String CLIENT = "client";
-
-	public static final String BESCHEIDEN_AM = "2024-01-01";
-	public static final String BESCHEID_DOCUMENT = "bescheid-document";
-	public static final String ATTACHMENT = "attachment-id";
-	public static final String SEND_BY = "POSTFACH";
-	public static final String NACHRICHT_TEXT = "nachricht-text";
-	public static final String NACHRICHT_SUBJECT = "nachricht-subject";
-
-	public static BescheidItem create() {
-		return createBuilder().build();
-	}
-
-	public static BescheidItemBuilder createBuilder() {
-		return BescheidItem.builder()
-				.id(ID)
-				.version(VERSION)
-				.client(CLIENT)
-				.vorgangId(CommandTestFactory.VORGANG_ID)
-				.itemName(AttachedItemService.BESCHEID_ITEM_NAME)
-				.bescheidData(createBescheidBody());
-	}
-
-	public static Map<String,  Object> createBescheidBody() {
-		return Map.of(
-				BescheidItem.FIELD_STATUS, BescheidItem.Status.DRAFT,
-				BescheidItem.FIELD_BESCHIEDEN_AM, BESCHEIDEN_AM,
-				BescheidItem.FIELD_BEWILLIGT, true,
-				BescheidItem.FIELD_BESCHEID_DOCUMENT, BESCHEID_DOCUMENT,
-				BescheidItem.FIELD_ATTACHMENTS, List.of(ATTACHMENT),
-				BescheidItem.FIELD_SEND_BY, SEND_BY,
-				BescheidItem.FIELD_NACHRICHT_TEXT, NACHRICHT_TEXT,
-				BescheidItem.FIELD_NACHRICHT_SUBJECT, NACHRICHT_SUBJECT);
-	}
-}

bescheid-manager/src/test/java/de/ozgcloud/bescheid/attacheditem/GrpcVorgangAttachedItemTestFactory.java

@@ -41,9 +41,9 @@ public class GrpcVorgangAttachedItemTestFactory {
 
 	static GrpcVorgangAttachedItem.Builder createBuilder() {
 		return GrpcVorgangAttachedItem.newBuilder()
-				.setId(BescheidItemTestFactory.ID)
+				.setId(AttachedItemTestFactory.ID)
 				.setVorgangId(CommandTestFactory.VORGANG_ID)
-				.setClient(BescheidItemTestFactory.CLIENT)
+				.setClient(AttachedItemTestFactory.CLIENT)
 				.setItemName(AttachedItemService.BESCHEID_ITEM_NAME)
 				.setItem(OBJECT);
 	}

bescheid-manager/src/test/java/de/ozgcloud/bescheid/attacheditem/UtilsTest.java

@@ -35,11 +35,10 @@ class UtilsTest {
 
 	@Test
 	void shouldReturnClient() {
-		var command = CommandTestFactory.createBuilder().bodyObject(Map.of(BescheidItem.PROPERTY_CLIENT, BescheidItemTestFactory.CLIENT))
-				.build();
+		var command = CommandTestFactory.createBuilder().bodyObject(Map.of(AttachedItem.PROPERTY_CLIENT, AttachedItemTestFactory.CLIENT)).build();
 
 		var client = Utils.extractClient(command);
 
-		assertThat(client).isEqualTo(BescheidItemTestFactory.CLIENT);
+		assertThat(client).isEqualTo(AttachedItemTestFactory.CLIENT);
 	}
 }
\ No newline at end of file

bescheid-manager/src/test/java/de/ozgcloud/bescheid/attacheditem/VorgangAttachedItemRemoteServiceTest.java

@@ -28,11 +28,11 @@ package de.ozgcloud.bescheid.attacheditem;
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
-import java.util.Map;
+import java.util.Collections;
+import java.util.List;
 import java.util.Optional;
 import java.util.stream.Stream;
 
-import org.apache.commons.collections.MapUtils;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
@@ -41,8 +41,12 @@ import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Spy;
 
+import de.ozgcloud.bescheid.Bescheid;
 import de.ozgcloud.bescheid.BescheidCallContextAttachingInterceptor;
+import de.ozgcloud.bescheid.vorgang.VorgangTestFactory;
 import de.ozgcloud.command.CommandTestFactory;
+import de.ozgcloud.vorgang.common.GrpcObject;
+import de.ozgcloud.vorgang.common.GrpcProperty;
 import de.ozgcloud.vorgang.vorgangAttachedItem.GrpcFindVorgangAttachedItemRequest;
 import de.ozgcloud.vorgang.vorgangAttachedItem.GrpcFindVorgangAttachedItemResponse;
 import de.ozgcloud.vorgang.vorgangAttachedItem.GrpcVorgangAttachedItem;
@@ -64,8 +68,6 @@ class VorgangAttachedItemRemoteServiceTest {
 	@Mock
 	private ClientInterceptor bescheidCallContextInterceptor;
 	@Mock
-	private BescheidItemMapper bescheidItemMapper;
-	@Mock
 	private AttachedItemMapper attachedItemMapper;
 
 	@Nested
@@ -74,15 +76,18 @@ class VorgangAttachedItemRemoteServiceTest {
 		@Mock
 		private GrpcFindVorgangAttachedItemRequest request;
 
-		@BeforeEach
-		void init() {
-			doReturn(serviceStub).when(service).getServiceStub();
-		}
-
 		@Nested
 		@DisplayName("by vorgangId")
 		class TestGetByVorgangId {
 
+			private static final AttachedItem BESCHEID_ITEM = AttachedItemTestFactory.createBescheid();
+
+			@BeforeEach
+			void init() {
+				doReturn(request).when(service).buildFindRequest(any());
+				doReturn(Optional.of(BESCHEID_ITEM)).when(service).findBescheidDraft(any(GrpcFindVorgangAttachedItemRequest.class));
+			}
+
 			@Test
 			void shouldCallCreateFindRequestBuilder() {
 				service.findBescheidDraft(VORGANG_ID);
@@ -92,68 +97,63 @@ class VorgangAttachedItemRemoteServiceTest {
 
 			@Test
 			void shouldCallGetBescheidDraft() {
-				doReturn(request).when(service).buildFindRequest(any());
-
 				service.findBescheidDraft(VORGANG_ID);
 
 				verify(service).findBescheidDraft(request);
 			}
+
+			@Test
+			void shouldReturnResult() {
+				var result = service.findBescheidDraft(VORGANG_ID);
+
+				assertThat(result).contains(BESCHEID_ITEM);
+			}
 		}
 
 		@Nested
 		@DisplayName("by grpc request")
 		class TestByGrpcRequest {
 
+			private static final AttachedItem BESCHEID_ITEM = AttachedItemTestFactory.createBescheid();
+
 			@Mock
 			private GrpcFindVorgangAttachedItemResponse response;
 
-			@Test
-			void shouldCallGetServiceStub() {
-				service.findBescheidDraft(request);
-
-				verify(service).getServiceStub();
-			}
-
-			@Test
-			void shouldCallFind() {
-				service.findBescheidDraft(request);
-
-				verify(serviceStub).find(request);
+			@BeforeEach
+			void init() {
 			}
 
 			@Test
-			void shouldCallMapper() {
-				when(serviceStub.find(any())).thenReturn(response);
+			void shouldCallFindAllBescheid() {
+				doReturn(Stream.of(BESCHEID_ITEM)).when(service).findAllBescheid(any(GrpcFindVorgangAttachedItemRequest.class));
 
 				service.findBescheidDraft(request);
 
-				verify(bescheidItemMapper).fromFindVorgangAttachedItemResponse(response);
+				verify(service).findAllBescheid(request);
 			}
 
 			@Test
 			void shouldCallHasStatusDraft() {
-				var item = BescheidItemTestFactory.create();
-				when(bescheidItemMapper.fromFindVorgangAttachedItemResponse(any())).thenReturn(Stream.of(item));
+				doReturn(Stream.of(BESCHEID_ITEM)).when(service).findAllBescheid(any(GrpcFindVorgangAttachedItemRequest.class));
 
 				service.findBescheidDraft(request);
 
-				verify(service).hasStatusDraft(item);
+				verify(service).hasStatusDraft(BESCHEID_ITEM);
 			}
 
 			@Test
 			void shouldFilterDraftItems() {
-				var item = BescheidItemTestFactory.create();
-				when(bescheidItemMapper.fromFindVorgangAttachedItemResponse(any())).thenReturn(Stream.of(item));
+				doReturn(Stream.of(BESCHEID_ITEM)).when(service).findAllBescheid(any(GrpcFindVorgangAttachedItemRequest.class));
 				doReturn(true).when(service).hasStatusDraft(any());
 
 				var result = service.findBescheidDraft(request);
 
-				assertThat(result).contains(item);
+				assertThat(result).contains(BESCHEID_ITEM);
 			}
 
 			@Test
 			void shouldReturnEmptyWhenNotFound() {
-				when(bescheidItemMapper.fromFindVorgangAttachedItemResponse(any())).thenReturn(Stream.empty());
+				doReturn(Stream.empty()).when(service).findAllBescheid(any(GrpcFindVorgangAttachedItemRequest.class));
 
 				var result = service.findBescheidDraft(request);
 
@@ -162,7 +162,7 @@ class VorgangAttachedItemRemoteServiceTest {
 
 			@Test
 			void shouldReturnEmptyWhenNotDraft() {
-				when(bescheidItemMapper.fromFindVorgangAttachedItemResponse(any())).thenReturn(Stream.of(BescheidItemTestFactory.create()));
+				doReturn(Stream.of(BESCHEID_ITEM)).when(service).findAllBescheid(any(GrpcFindVorgangAttachedItemRequest.class));
 				doReturn(false).when(service).hasStatusDraft(any());
 
 				var result = service.findBescheidDraft(request);
@@ -170,25 +170,45 @@ class VorgangAttachedItemRemoteServiceTest {
 				assertThat(result).isEmpty();
 			}
 
-			@Test
-			void shouldReturnLastBescheid() {
-				var item1 = BescheidItemTestFactory.createBuilder().bescheidData(Map.of(
-						BescheidItem.FIELD_BESCHIEDEN_AM, "2021-01-01")).build();
-				var item2 = BescheidItemTestFactory.create();
-				when(bescheidItemMapper.fromFindVorgangAttachedItemResponse(any())).thenReturn(Stream.of(item1, item2));
-				doReturn(true).when(service).hasStatusDraft(any());
+		}
 
-				var result = service.findBescheidDraft(request);
+	}
+
+	@Nested
+	class TestFindAllBescheid {
+
+		private static final AttachedItem RESULT_BESCHEID_ITEM = AttachedItemTestFactory.createBescheid();
+
+		@Mock
+		private GrpcFindVorgangAttachedItemRequest request;
 
-				assertThat(getBeschiedenAm(result)).isEqualTo(BescheidItemTestFactory.BESCHEIDEN_AM);
+		@BeforeEach
+		void init() {
+			doReturn(Stream.of(RESULT_BESCHEID_ITEM)).when(service).findAllBescheid(any(GrpcFindVorgangAttachedItemRequest.class));
 		}
 
-			private String getBeschiedenAm(Optional<BescheidItem> item) {
-				assertThat(item).isPresent();
-				return MapUtils.getString(item.get().getBescheidData(), BescheidItem.FIELD_BESCHIEDEN_AM);
+		@Test
+		void shouldCallBuildFindRequest() {
+			service.findAllBescheid(VorgangTestFactory.ID);
+
+			verify(service).buildFindRequest(VorgangTestFactory.ID.toString());
 		}
+
+		@Test
+		void shouldCallFindAllBescheid() {
+			doReturn(request).when(service).buildFindRequest(any());
+
+			service.findAllBescheid(VorgangTestFactory.ID);
+
+			verify(service).findAllBescheid(request);
 		}
 
+		@Test
+		void shouldReturnResult() {
+			var result = service.findAllBescheid(VorgangTestFactory.ID);
+
+			assertThat(result).containsExactly(RESULT_BESCHEID_ITEM);
+		}
 	}
 
 	@Nested
@@ -220,12 +240,75 @@ class VorgangAttachedItemRemoteServiceTest {
 		}
 	}
 
+	@Nested
+	class TestFindAllBescheidWithGrpcRequest {
+
+		@Mock
+		private GrpcFindVorgangAttachedItemRequest request;
+		@Mock
+		private GrpcFindVorgangAttachedItemResponse response;
+		@Mock
+		private GrpcVorgangAttachedItem grpcVorgangAttachedItem;
+
+		@BeforeEach
+		void init() {
+			doReturn(serviceStub).when(service).getServiceStub();
+			when(serviceStub.find(any())).thenReturn(response);
+		}
+
+		@Test
+		void shouldCallGetServiceStub() {
+			service.findAllBescheid(request);
+
+			verify(service).getServiceStub();
+		}
+
+		@Test
+		void shouldCallMapper() {
+			when(response.getVorgangAttachedItemsList()).thenReturn(Collections.singletonList(grpcVorgangAttachedItem));
+
+			service.findAllBescheid(request).toList();
+
+			verify(attachedItemMapper).mapFromVorgangAttachedItem(grpcVorgangAttachedItem);
+		}
+
+		@Test
+		void shouldReturnSortedResult() {
+			var beschiedenAmFirst = "2021-01-01";
+			var beschiedenAmLast = "2024-01-01";
+			createItems(beschiedenAmFirst, beschiedenAmLast);
+
+			var result = service.findAllBescheid(request).toList();
+
+			assertThat(result).hasSize(2);
+			assertThat(result.get(0).getItem()).containsEntry(Bescheid.FIELD_BESCHIEDEN_AM, beschiedenAmLast);
+			assertThat(result.get(1).getItem()).containsEntry(Bescheid.FIELD_BESCHIEDEN_AM, beschiedenAmFirst);
+		}
+
+		private void createItems(String beschiedenAmFirst, String beschiedenAmLast) {
+			var itemBeschiedenFirst = createGrpcAttachedItem(beschiedenAmLast);
+			when(attachedItemMapper.mapFromVorgangAttachedItem(itemBeschiedenFirst)).thenReturn(createAttachedItem(beschiedenAmLast));
+			var itemBeschiedenLast = createGrpcAttachedItem(beschiedenAmFirst);
+			when(attachedItemMapper.mapFromVorgangAttachedItem(itemBeschiedenLast)).thenReturn(createAttachedItem(beschiedenAmFirst));
+			when(response.getVorgangAttachedItemsList()).thenReturn(List.of(itemBeschiedenFirst, itemBeschiedenLast));
+		}
+
+		private GrpcVorgangAttachedItem createGrpcAttachedItem(String beschiedenAm) {
+			return GrpcVorgangAttachedItemTestFactory.createBuilder().clearItem().setItem(GrpcObject.newBuilder().addProperty(
+					GrpcProperty.newBuilder().setName(Bescheid.FIELD_BESCHIEDEN_AM).addValue(beschiedenAm))).build();
+		}
+
+		private AttachedItem createAttachedItem(String beschiedenAm) {
+			return AttachedItemTestFactory.createBescheidBuilder().clearItem().itemEntry(Bescheid.FIELD_BESCHIEDEN_AM, beschiedenAm).build();
+		}
+	}
+
 	@Nested
 	class TestHasStatusDraft {
 
 		@Test
 		void shouldReturnTrueIfDraft() {
-			var item = BescheidItemTestFactory.createBuilder().bescheidData(Map.of(BescheidItem.FIELD_STATUS, BescheidItem.Status.DRAFT.name()))
+			var item = AttachedItemTestFactory.createBescheidBuilder().clearItem().itemEntry(Bescheid.FIELD_STATUS, Bescheid.Status.DRAFT.name())
 					.build();
 
 			var result = service.hasStatusDraft(item);
@@ -235,7 +318,7 @@ class VorgangAttachedItemRemoteServiceTest {
 
 		@Test
 		void shouldReturnFalseIfNotDraft() {
-			var item = BescheidItemTestFactory.createBuilder().bescheidData(Map.of(BescheidItem.FIELD_STATUS, BescheidItem.Status.BESCHEID.name()))
+			var item = AttachedItemTestFactory.createBescheidBuilder().clearItem().itemEntry(Bescheid.FIELD_STATUS, Bescheid.Status.SENT.name())
 					.build();
 
 			var result = service.hasStatusDraft(item);
@@ -275,7 +358,7 @@ class VorgangAttachedItemRemoteServiceTest {
 
 			getBescheid();
 
-			verify(service).buildGetByIdRequest(BescheidItemTestFactory.ID);
+			verify(service).buildGetByIdRequest(AttachedItemTestFactory.ID);
 		}
 
 		@Test
@@ -294,13 +377,13 @@ class VorgangAttachedItemRemoteServiceTest {
 
 			getBescheid();
 
-			verify(bescheidItemMapper).mapFromVorgangAttachedItem(grpcVorgangAttachedItem);
+			verify(attachedItemMapper).mapFromVorgangAttachedItem(grpcVorgangAttachedItem);
 		}
 
 		@Test
 		void shouldReturnFoundBescheid() {
-			var expectedBescheid = BescheidItemTestFactory.create();
-			when(bescheidItemMapper.mapFromVorgangAttachedItem(any())).thenReturn(expectedBescheid);
+			var expectedBescheid = AttachedItemTestFactory.createBescheid();
+			when(attachedItemMapper.mapFromVorgangAttachedItem(any())).thenReturn(expectedBescheid);
 			when(grpcVorgangAttachedItemResponse.getVorgangAttachedItem()).thenReturn(grpcVorgangAttachedItem);
 
 			var result = getBescheid();
@@ -308,8 +391,8 @@ class VorgangAttachedItemRemoteServiceTest {
 			assertThat(result).isEqualTo(expectedBescheid);
 		}
 
-		private BescheidItem getBescheid() {
-			return service.getBescheid(BescheidItemTestFactory.ID);
+		private AttachedItem getBescheid() {
+			return service.getBescheid(AttachedItemTestFactory.ID);
 		}
 	}
 
@@ -378,7 +461,7 @@ class VorgangAttachedItemRemoteServiceTest {
 		}
 
 		private AttachedItem getItem() {
-			return service.getItem(BescheidItemTestFactory.ID);
+			return service.getItem(AttachedItemTestFactory.ID);
 		}
 	}
 
@@ -387,9 +470,9 @@ class VorgangAttachedItemRemoteServiceTest {
 
 		@Test
 		void shouldSetBescheidId() {
-			var request = service.buildGetByIdRequest(BescheidItemTestFactory.ID);
+			var request = service.buildGetByIdRequest(AttachedItemTestFactory.ID);
 
-			assertThat(request.getId()).isEqualTo(BescheidItemTestFactory.ID);
+			assertThat(request.getId()).isEqualTo(AttachedItemTestFactory.ID);
 		}
 	}
 

bescheid-manager/src/test/java/de/ozgcloud/bescheid/nachricht/NachrichtServiceITCase.java

@@ -7,6 +7,7 @@ import java.util.Optional;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.info.BuildProperties;
 import org.springframework.boot.test.mock.mockito.MockBean;
 
 import de.ozgcloud.apilib.common.command.OzgCloudCommandService;
@@ -23,6 +24,8 @@ class NachrichtServiceITCase {
 	private OzgCloudCommandService commandService;
 	@MockBean
 	private CommandMapper commandMapper;
+	@MockBean
+	private BuildProperties buildProperties;
 
 	@Nested
 	class TestBuildMessage {

bescheid-manager/src/test/java/de/ozgcloud/bescheid/nachricht/NachrichtServiceTest.java

 package de.ozgcloud.bescheid.nachricht;
 
 import static org.assertj.core.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
+import java.util.Map;
 import java.util.Optional;
 
 import org.junit.jupiter.api.BeforeEach;
@@ -13,8 +15,18 @@ import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Spy;
 
+import de.ozgcloud.apilib.common.command.OzgCloudCommand;
+import de.ozgcloud.apilib.common.command.OzgCloudCommandService;
+import de.ozgcloud.apilib.common.command.grpc.CommandMapper;
+import de.ozgcloud.apilib.common.datatypes.GenericId;
+import de.ozgcloud.apilib.user.OzgCloudUserId;
+import de.ozgcloud.apilib.vorgang.OzgCloudVorgangId;
+import de.ozgcloud.bescheid.Bescheid;
 import de.ozgcloud.bescheid.BescheidTestFactory;
+import de.ozgcloud.bescheid.vorgang.PostfachAddressTestFactory;
+import de.ozgcloud.bescheid.vorgang.Vorgang;
 import de.ozgcloud.bescheid.vorgang.VorgangTestFactory;
+import de.ozgcloud.common.errorhandling.TechnicalException;
 
 class NachrichtServiceTest {
 
@@ -24,6 +36,10 @@ class NachrichtServiceTest {
 
 	@Mock
 	private NachrichtRemoteService remoteService;
+	@Mock
+	private OzgCloudCommandService commandService;
+	@Mock
+	private CommandMapper commandMapper;
 
 	@Nested
 	class TestCreateNachrichtDraft {
@@ -104,4 +120,222 @@ class NachrichtServiceTest {
 			assertThat(message).isEqualTo("FROM_TEMPLATE");
 		}
 	}
+
+	@Nested
+	class TestSendNachricht {
+
+		@Mock
+		private OzgCloudCommand ozgCloudCommand;
+
+		@BeforeEach
+		void init() {
+			doReturn(ozgCloudCommand).when(service).buildSendBescheidCommand(any());
+		}
+
+		@Test
+		void shouldCallBuildBescheidCommand() {
+			var bescheid = BescheidTestFactory.create();
+
+			service.sendNachricht(bescheid);
+
+			verify(service).buildSendBescheidCommand(bescheid);
+		}
+
+		@Test
+		void shouldCallCommandService() {
+			service.sendNachricht(BescheidTestFactory.create());
+
+			verify(commandService).createAndWaitUntilDone(ozgCloudCommand);
+		}
+
+	}
+
+	@Nested
+	class TestBuildSendBescheidCommand {
+
+		private static final Map<String, Object> bodyObject = Map.of("key", "value");
+		private final Bescheid bescheid = BescheidTestFactory.create();
+
+		@BeforeEach
+		void init() {
+			doReturn(bodyObject).when(service).buildSendNachrichtCommandBody(any());
+		}
+
+		@Test
+		void shouldCallVorgangIdMapper() {
+			buildCommand();
+
+			verify(commandMapper).toOzgCloudVorgangId(VorgangTestFactory.ID.toString());
+		}
+
+		@Test
+		void shouldSetVorgangId() {
+			var vorgangId = OzgCloudVorgangId.from(VorgangTestFactory.ID.toString());
+			when(commandMapper.toOzgCloudVorgangId(anyString())).thenReturn(vorgangId);
+
+			var result = buildCommand();
+
+			assertThat(result.getVorgangId()).isEqualTo(vorgangId);
+		}
+
+		@Test
+		void shouldCallMapRelationId() {
+			buildCommand();
+
+			verify(commandMapper).mapRelationId(VorgangTestFactory.ID.toString());
+		}
+
+		@Test
+		void shouldSetRelationId() {
+			var relationId = GenericId.from("relation-id");
+			when(commandMapper.mapRelationId(anyString())).thenReturn(relationId);
+
+			var result = buildCommand();
+
+			assertThat(result.getRelationId()).isEqualTo(relationId);
+		}
+
+		@Test
+		void shouldSetOrder() {
+			var result = buildCommand();
+
+			assertThat(result.getOrder()).isEqualTo(NachrichtService.SEND_POSTFACH_NACHRICHT_ORDER);
+		}
+
+		@Test
+		void shouldCallCreatedBy() {
+			buildCommand();
+
+			verify(commandMapper).toOzgCloudUserId(BescheidTestFactory.CREATED_BY.toString());
+		}
+
+		@Test
+		void shouldSetCreatedBy() {
+			var userId = OzgCloudUserId.from(BescheidTestFactory.CREATED_BY.toString());
+			when(commandMapper.toOzgCloudUserId(anyString())).thenReturn(userId);
+
+			var result = buildCommand();
+
+			assertThat(result.getCreatedBy()).isEqualTo(userId);
+		}
+
+		@Test
+		void shouldCallBuildSendNachrichtCommandBody() {
+			buildCommand();
+
+			verify(service).buildSendNachrichtCommandBody(bescheid);
+		}
+
+		@Test
+		void shouldSetBodyObject() {
+			var result = buildCommand();
+
+			assertThat(result.getBodyObject()).isEqualTo(bodyObject);
+		}
+
+		private OzgCloudCommand buildCommand() {
+			return service.buildSendBescheidCommand(bescheid);
+		}
+	}
+
+	@Nested
+	class TestBuildSendNachrichtCommandBody {
+
+		private static final String POSTFACH_ID = "postfach-id";
+
+		private final Bescheid bescheid = BescheidTestFactory.create();
+
+		@BeforeEach
+		void init() {
+			doReturn(POSTFACH_ID).when(service).getPostfachId(any());
+		}
+
+		@Test
+		void shouldSetPostfachId() {
+			var result = service.buildSendNachrichtCommandBody(bescheid);
+
+			assertThat(result).containsEntry(NachrichtService.FIELD_POSTFACH_ID, POSTFACH_ID);
+		}
+
+		@Test
+		void shouldSetReplyOption() {
+			var result = service.buildSendNachrichtCommandBody(bescheid);
+
+			assertThat(result).containsEntry(NachrichtService.FIELD_REPLY_OPTION, NachrichtService.REPLY_OPTION);
+		}
+
+		@Test
+		void shouldSetSubject() {
+			var result = service.buildSendNachrichtCommandBody(bescheid);
+
+			assertThat(result).containsEntry(NachrichtService.FIELD_SUBJECT, BescheidTestFactory.NACHRICHT_SUBJECT);
+		}
+
+		@Test
+		void shouldSetMailBody() {
+			var result = service.buildSendNachrichtCommandBody(bescheid);
+
+			assertThat(result).containsEntry(NachrichtService.FIELD_MAIL_BODY, BescheidTestFactory.NACHRICHT_TEXT);
+		}
+
+		@Test
+		void shouldSetAttachments() {
+			var result = service.buildSendNachrichtCommandBody(bescheid);
+
+			assertThat(result).containsEntry(NachrichtService.FIELD_ATTACHMENTS, BescheidTestFactory.BESCHEID_FILE_ID);
+		}
+	}
+
+	@Nested
+	class TestGetPostfachId {
+
+		private static final Vorgang.PostfachAddress POSTFACH_ADDRESS = PostfachAddressTestFactory.create();
+
+		@BeforeEach
+		void init() {
+			doReturn(Optional.of(POSTFACH_ADDRESS)).when(service).getAddress(any());
+		}
+
+		@Test
+		void shouldCallGetAddress() {
+			var bescheid = BescheidTestFactory.create();
+
+			service.getPostfachId(bescheid);
+
+			verify(service).getAddress(bescheid);
+		}
+
+		@Test
+		void shouldReturnPostfachId() {
+			var bescheid = BescheidTestFactory.create();
+
+			var result = service.getPostfachId(bescheid);
+
+			assertThat(result).isEqualTo(PostfachAddressTestFactory.POSTFACH_ID);
+		}
+
+	}
+
+	@Nested
+	class TestNoPostfachId {
+
+		@Test
+		void shouldThrowExceptionIfNoPostfachAddress() {
+			doReturn(Optional.empty()).when(service).getAddress(any());
+
+			assertThrows(TechnicalException.class, this::getPostfachId);
+		}
+
+		@Test
+		void shouldThrowExceptionIfNoPostfachId() {
+			var postfachAddress = PostfachAddressTestFactory.createBuilder().identifier(Map.of()).build();
+			doReturn(Optional.of(postfachAddress)).when(service).getAddress(any());
+
+			assertThrows(TechnicalException.class, this::getPostfachId);
+		}
+
+		private void getPostfachId() {
+			service.getPostfachId(BescheidTestFactory.create());
+		}
+	}
 }

bescheid-manager/src/test/java/de/ozgcloud/bescheid/smartdocuments/SmartDocumentsBescheidRemoteServiceTest.java

@@ -37,7 +37,7 @@ class SmartDocumentsBescheidRemoteServiceTest {
 		void shouldFillBescheid() {
 			var bescheid = service.buildBescheid(BescheidRequestTestFactory.create(), SmartDocumentsResponseTestFactory.create());
 
-			assertThat(bescheid).usingRecursiveComparison().ignoringFields("serviceKonto", "nachrichtSubject")
+			assertThat(bescheid).usingRecursiveComparison().ignoringFields("serviceKonto", "nachrichtSubject", "bescheidFileId")
 					.isEqualTo(BescheidTestFactory.createBuilder().nachrichtText(Optional.empty()).build());
 		}
 	}

nachrichten-bayernid-proxy/bayernid-proxy-impl/src/test/java/de/ozgcloud/nachrichten/postfach/bayernid/proxy/message/AttachmentTestFactory.java → bescheid-manager/src/test/java/de/ozgcloud/bescheid/vorgang/PostfachAddressTestFactory.java

@@ -21,26 +21,28 @@
  * Die sprachspezifischen Genehmigungen und Beschränkungen
  * unter der Lizenz sind dem Lizenztext zu entnehmen.
  */
-package de.ozgcloud.nachrichten.postfach.bayernid.proxy.message;
+package de.ozgcloud.bescheid.vorgang;
 
-import java.io.ByteArrayInputStream;
+import java.util.Map;
+import java.util.UUID;
 
-import de.ozgcloud.nachrichten.postfach.bayernid.proxy.message.Attachment.AttachmentBuilder;
+import de.ozgcloud.bescheid.nachricht.NachrichtService;
+import de.ozgcloud.bescheid.vorgang.Vorgang.PostfachAddress.PostfachAddressBuilder;
 
-public class AttachmentTestFactory {
+public class PostfachAddressTestFactory {
 
-	public static final String FILE_NAME = "test.txt";
-	public static final String TYPE = "plain/text";
-	public static final byte[] CONTENT = "test".getBytes();
+	public static final String POSTFACH_ID = UUID.randomUUID().toString();
+	public static final int TYPE = 1;
+	public static final String VERSION = "1.0";
 
-	public static Attachment create() {
+	public static Vorgang.PostfachAddress create() {
 		return createBuilder().build();
 	}
 
-	public static AttachmentBuilder createBuilder() {
-		return Attachment.builder()
-				.name(FILE_NAME)
+	public static PostfachAddressBuilder createBuilder() {
+		return Vorgang.PostfachAddress.builder()
 				.type(TYPE)
-				.content(new ByteArrayInputStream(CONTENT));
+				.version(VERSION)
+				.identifier(Map.of(NachrichtService.FIELD_POSTFACH_ID, POSTFACH_ID));
 	}
 }

bescheid-manager/src/test/java/de/ozgcloud/bescheid/vorgang/ServiceKontoTestFactory.java

 package de.ozgcloud.bescheid.vorgang;
 
-import de.ozgcloud.bescheid.vorgang.Vorgang.PostfachAddress;
 import de.ozgcloud.bescheid.vorgang.Vorgang.ServiceKonto;
 
 public class ServiceKontoTestFactory {
@@ -11,6 +10,6 @@ public class ServiceKontoTestFactory {
 
 	public static ServiceKonto.ServiceKontoBuilder createBuilder() {
 		return ServiceKonto.builder()
-				.postfachAddress(PostfachAddress.builder().build());
+				.postfachAddress(PostfachAddressTestFactory.create());
 	}
 }

bescheid-manager/src/test/java/de/ozgcloud/document/DocumentServiceTest.java

@@ -47,10 +47,9 @@ import de.ozgcloud.apilib.vorgang.OzgCloudVorgangId;
 import de.ozgcloud.bescheid.Bescheid;
 import de.ozgcloud.bescheid.BescheidCallContextAttachingInterceptor;
 import de.ozgcloud.bescheid.BescheidTestFactory;
+import de.ozgcloud.bescheid.attacheditem.AttachedItem;
 import de.ozgcloud.bescheid.attacheditem.AttachedItemService;
 import de.ozgcloud.bescheid.attacheditem.AttachedItemTestFactory;
-import de.ozgcloud.bescheid.attacheditem.BescheidItem;
-import de.ozgcloud.bescheid.attacheditem.BescheidItemTestFactory;
 import de.ozgcloud.command.Command;
 import de.ozgcloud.command.CommandTestFactory;
 import de.ozgcloud.common.binaryfile.FileId;
@@ -74,7 +73,7 @@ class DocumentServiceTest {
 	@Mock
 	private DocumentMapper documentMapper;
 
-	private Command command = CommandTestFactory.createBuilder().relationId(RELATION_ID).build();
+	private final Command command = CommandTestFactory.createBuilder().relationId(RELATION_ID).build();
 
 	@Nested
 	class TestCreateBescheidDocument {
@@ -87,7 +86,7 @@ class DocumentServiceTest {
 		@Nested
 		class TestWithCommand {
 
-			private Command command = CommandTestFactory.createBuilder().relationId(RELATION_ID)
+			private final Command command = CommandTestFactory.createBuilder().relationId(RELATION_ID)
 					.bodyObject(Map.of(DocumentService.FIELD_DOCUMENT_FILE, FILE_ID)).build();
 
 			@BeforeEach
@@ -123,7 +122,7 @@ class DocumentServiceTest {
 		@Nested
 		class TestWithBescheid {
 
-			private Bescheid bescheid = BescheidTestFactory.create().withBescheidFileId(FileId.from(BescheidTestFactory.BESCHEID_FILE_ID));
+			private final Bescheid bescheid = BescheidTestFactory.create().withBescheidFileId(FileId.from(BescheidTestFactory.BESCHEID_FILE_ID));
 
 			@BeforeEach
 			void init() {
@@ -198,11 +197,11 @@ class DocumentServiceTest {
 
 		@Test
 		void shouldCallGetBescheidItem() {
-			when(attachedItemService.getBescheidItem(any())).thenReturn(BescheidItemTestFactory.create());
+			when(attachedItemService.getBescheidItem(any())).thenReturn(AttachedItemTestFactory.createBescheid());
 
 			validateBescheidItem();
 
-			verify(attachedItemService).getBescheidItem(BescheidItemTestFactory.ID);
+			verify(attachedItemService).getBescheidItem(AttachedItemTestFactory.ID);
 		}
 
 		@Test
@@ -215,20 +214,20 @@ class DocumentServiceTest {
 		@Test
 		void shouldNotThrowExceptionIfNotDraft() {
 			when(attachedItemService.getBescheidItem(any())).thenReturn(
-					BescheidItemTestFactory.createBuilder().bescheidData(Map.of(BescheidItem.FIELD_STATUS, "not-draft")).build());
+					AttachedItemTestFactory.createBescheidBuilder().clearItem().itemEntry(Bescheid.FIELD_STATUS, "not-draft").build());
 
 			assertThrows(TechnicalException.class, this::validateBescheidItem);
 		}
 
 		@Test
 		void shouldValidateBescheidItem() {
-			when(attachedItemService.getBescheidItem(any())).thenReturn(BescheidItemTestFactory.create());
+			when(attachedItemService.getBescheidItem(any())).thenReturn(AttachedItemTestFactory.createBescheid());
 
 			assertDoesNotThrow(this::validateBescheidItem);
 		}
 
 		void validateBescheidItem() {
-			service.validateBescheidItem(BescheidItemTestFactory.ID);
+			service.validateBescheidItem(AttachedItemTestFactory.ID);
 		}
 	}
 
@@ -293,20 +292,20 @@ class DocumentServiceTest {
 	@Nested
 	class TestBuildAttachedItem {
 
-		private static final Map<String, Object> ITEM_MAP = Map.of("key", (Object) "value");
+		private static final Map<String, Object> ITEM_MAP = Map.of("key", "value");
 
 		@Test
 		void shouldSetVorgangId() {
 			var attachedItem = buildAttachedItem();
 
-			assertThat(attachedItem).containsEntry(BescheidItem.PROPERTY_VORGANG_ID, CommandTestFactory.VORGANG_ID);
+			assertThat(attachedItem).containsEntry(AttachedItem.PROPERTY_VORGANG_ID, CommandTestFactory.VORGANG_ID);
 		}
 
 		@Test
 		void shouldSetClient() {
 			var attachedItem = buildAttachedItem();
 
-			assertThat(attachedItem).containsEntry(BescheidItem.PROPERTY_CLIENT,
+			assertThat(attachedItem).containsEntry(AttachedItem.PROPERTY_CLIENT,
 					BescheidCallContextAttachingInterceptor.BESCHEID_MANAGER_CLIENT_NAME);
 		}
 
@@ -314,14 +313,14 @@ class DocumentServiceTest {
 		void shouldSetItemName() {
 			var attachedItem = buildAttachedItem();
 
-			assertThat(attachedItem).containsEntry(BescheidItem.PROPERTY_ITEM_NAME, DocumentService.DOCUMENT_ITEM_NAME);
+			assertThat(attachedItem).containsEntry(AttachedItem.PROPERTY_ITEM_NAME, DocumentService.DOCUMENT_ITEM_NAME);
 		}
 
 		@Test
 		void shouldSetItem() {
 			var attachedItem = buildAttachedItem();
 
-			assertThat(attachedItem).containsEntry(BescheidItem.PROPERTY_ITEM, ITEM_MAP);
+			assertThat(attachedItem).containsEntry(AttachedItem.PROPERTY_ITEM, ITEM_MAP);
 		}
 
 		private Map<String, Object> buildAttachedItem() {
@@ -402,7 +401,7 @@ class DocumentServiceTest {
 
 			@Test
 			void shouldThrowExceptionIfFileIdMissing() {
-				bescheid = BescheidTestFactory.create();
+				bescheid = BescheidTestFactory.createBuilder().bescheidFileId(null).build();
 
 				assertThrows(TechnicalException.class, () -> service.buildItemMap(bescheid));
 

nachrichten-bayernid-proxy/bayernid-proxy-impl/pom.xml

-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
-    Copyright (C) 2024 Das Land Schleswig-Holstein vertreten durch den
-    Ministerpräsidenten des Landes Schleswig-Holstein
-    Staatskanzlei
-    Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
-
-    Lizenziert unter der EUPL, Version 1.2 oder - sobald
-    diese von der Europäischen Kommission genehmigt wurden -
-    Folgeversionen der EUPL ("Lizenz");
-    Sie dürfen dieses Werk ausschließlich gemäß
-    dieser Lizenz nutzen.
-    Eine Kopie der Lizenz finden Sie hier:
-
-    https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
-
-    Sofern nicht durch anwendbare Rechtsvorschriften
-    gefordert oder in schriftlicher Form vereinbart, wird
-    die unter der Lizenz verbreitete Software "so wie sie
-    ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
-    ausdrücklich oder stillschweigend - verbreitet.
-    Die sprachspezifischen Genehmigungen und Beschränkungen
-    unter der Lizenz sind dem Lizenztext zu entnehmen.
-
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-	<modelVersion>4.0.0</modelVersion>
-
-	<parent>
-		<groupId>de.ozgcloud.nachrichten</groupId>
-		<artifactId>nachrichten-bayernid-proxy</artifactId>
-		<version>0.3.0-SNAPSHOT</version>
-		<relativePath>../</relativePath>
-	</parent>
-
-	<artifactId>bayernid-proxy-impl</artifactId>
-	<name>OZG Cloud BayernID Proxy Implementation</name>
-
-	<properties>
-		<jaxb-maven-plugin.version>4.0.0</jaxb-maven-plugin.version>
-
-		<spring-boot.build-image.imageName>docker.ozg-sh.de/bayernid-proxy:build-latest</spring-boot.build-image.imageName>
-	</properties>
-
-	<dependencies>
-		<dependency>
-			<groupId>de.ozgcloud.nachrichten</groupId>
-			<artifactId>bayernid-proxy-interface</artifactId>
-			<version>${project.version}</version>
-		</dependency>
-
-		<!-- Spring -->
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter</artifactId>
-		</dependency>
-		<dependency>
-		<groupId>org.springframework.boot</groupId>
-		<artifactId>spring-boot-starter-web</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-actuator</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-validation</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework.ws</groupId>
-			<artifactId>spring-ws-core</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-oxm</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework.ws</groupId>
-			<artifactId>spring-xml</artifactId>
-		</dependency>
-
-		<!-- commons -->
-		<dependency>
-			<groupId>org.apache.httpcomponents.client5</groupId>
-			<artifactId>httpclient5</artifactId>
-		</dependency>
-
-		<!-- grpc -->
-		<dependency>
-			<groupId>net.devh</groupId>
-			<artifactId>grpc-server-spring-boot-starter</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>io.grpc</groupId>
-			<artifactId>grpc-inprocess</artifactId>
-		</dependency>
-
-		<!-- aspectJ -->
-		<dependency>
-			<groupId>org.aspectj</groupId>
-			<artifactId>aspectjweaver</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>org.aspectj</groupId>
-			<artifactId>aspectjrt</artifactId>
-		</dependency>
-
-		<!-- Tools -->
-		<dependency>
-			<groupId>org.mapstruct</groupId>
-			<artifactId>mapstruct</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>org.glassfish.jaxb</groupId>
-			<artifactId>jaxb-runtime</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>com.fasterxml.jackson.dataformat</groupId>
-			<artifactId>jackson-dataformat-xml</artifactId>
-		</dependency>
-
-		<!-- Dev -->
-		<dependency>
-			<groupId>org.projectlombok</groupId>
-			<artifactId>lombok</artifactId>
-			<optional>true</optional>
-			<scope>provided</scope>
-		</dependency>
-
-		<!-- Test -->
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-test</artifactId>
-			<scope>test</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>org.junit.vintage</groupId>
-					<artifactId>junit-vintage-engine</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-		<dependency>
-			<groupId>org.junit.jupiter</groupId>
-			<artifactId>junit-jupiter-engine</artifactId>
-			<scope>test</scope>
-		</dependency>
-		<dependency>
-			<groupId>org.junit.jupiter</groupId>
-			<artifactId>junit-jupiter-params</artifactId>
-			<scope>test</scope>
-		</dependency>
-		<dependency>
-			<groupId>org.wiremock</groupId>
-			<artifactId>wiremock-standalone</artifactId>
-			<version>${wiremock.version}</version>
-			<scope>test</scope>
-		</dependency>
-		<dependency>
-			<groupId>net.devh</groupId>
-			<artifactId>grpc-client-spring-boot-starter</artifactId>
-			<scope>test</scope>
-		</dependency>
-
-	</dependencies>
-
-	<build>
-		<finalName>${project.artifactId}</finalName>
-		<plugins>
-			<plugin>
-				<groupId>org.springframework.boot</groupId>
-				<artifactId>spring-boot-maven-plugin</artifactId>
-			</plugin>
-
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
-			</plugin>
-
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-failsafe-plugin</artifactId>
-			</plugin>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-compiler-plugin</artifactId>
-			</plugin>
-			<plugin>
-				<groupId>org.jacoco</groupId>
-				<artifactId>jacoco-maven-plugin</artifactId>
-			</plugin>
-			<plugin>
-				<groupId>org.jvnet.jaxb</groupId>
-				<artifactId>jaxb-maven-plugin</artifactId>
-				<version>${jaxb-maven-plugin.version}</version>
-				<configuration>
-					<schemas>
-						<schema>
-							<fileset>
-								<directory>${basedir}/src/main/resources/bayernid</directory>
-								<includes>
-									<include>*.wsdl</include>
-								</includes>
-							</fileset>
-						</schema>
-						<schema>
-							<fileset>
-								<directory>${basedir}/src/main/resources/bayernid</directory>
-								<includes>
-									<include>*.xsd</include>
-								</includes>
-							</fileset>
-						</schema>
-					</schemas>
-					<episode>false</episode>
-				</configuration>
-				<executions>
-					<execution>
-						<goals>
-							<goal>generate</goal>
-						</goals>
-					</execution>
-				</executions>
-			</plugin>
-		</plugins>
-	</build>
-</project>
\ No newline at end of file

nachrichten-bayernid-proxy/bayernid-proxy-impl/src/main/java/de/ozgcloud/nachrichten/postfach/bayernid/proxy/BayernIdProperties.java

-/*
- * Copyright (C) 2024 Das Land Schleswig-Holstein vertreten durch den
- * Ministerpräsidenten des Landes Schleswig-Holstein
- * Staatskanzlei
- * Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
- *
- * Lizenziert unter der EUPL, Version 1.2 oder - sobald
- * diese von der Europäischen Kommission genehmigt wurden -
- * Folgeversionen der EUPL ("Lizenz");
- * Sie dürfen dieses Werk ausschließlich gemäß
- * dieser Lizenz nutzen.
- * Eine Kopie der Lizenz finden Sie hier:
- *
- * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
- *
- * Sofern nicht durch anwendbare Rechtsvorschriften
- * gefordert oder in schriftlicher Form vereinbart, wird
- * die unter der Lizenz verbreitete Software "so wie sie
- * ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
- * ausdrücklich oder stillschweigend - verbreitet.
- * Die sprachspezifischen Genehmigungen und Beschränkungen
- * unter der Lizenz sind dem Lizenztext zu entnehmen.
- */
-package de.ozgcloud.nachrichten.postfach.bayernid.proxy;
-
-import jakarta.validation.constraints.NotBlank;
-
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.validation.annotation.Validated;
-
-import lombok.Getter;
-import lombok.Setter;
-
-@Getter
-@Setter
-@Validated
-@Configuration
-@ConfigurationProperties(prefix = "ozgcloud.bayernid")
-public class BayernIdProperties {
-
-	@NotBlank
-	private String server;
-
-	private boolean useSsl = true;
-}