OZG-5988 use subCommands to send bescheid

bescheid-manager/src/main/java/de/ozgcloud/bescheid/BescheidEventListener.java

@@ -81,6 +81,7 @@ class BescheidEventListener {
 
 	public static final Predicate<Command> IS_SEND_BESCHEID_COMMAND = command -> SEND_BESCHEID_ORDER.equals(command.getOrder());
 	private static final String IS_SEND_BESCHEID = "{T(de.ozgcloud.bescheid.BescheidEventListener).IS_SEND_BESCHEID_COMMAND.test(event.getSource())}";
+	private static final String IS_SEND_BESCHEID_ORDER = "{T(de.ozgcloud.bescheid.BescheidEventListener).IS_SEND_BESCHEID_COMMAND.test(event.getCommand())}";
 
 	static final String VORGANG_ID_BODY_KEY = "vorgangId";
 	static final String BESCHEID_VOM_BODY_KEY = "bescheidVom";
@@ -191,7 +192,7 @@ class BescheidEventListener {
 		return builder.build();
 	}
 
-	@EventListener(condition = IS_SEND_BESCHEID)
+	@EventListener(condition = IS_SEND_BESCHEID_ORDER)
 	public void onBescheidSent(CommandExecutedEvent event) {
 		runWithSecurityContext(event.getCommand(), this::setAntragBewilligung);
 	}

bescheid-manager/src/main/java/de/ozgcloud/bescheid/BescheidService.java

@@ -91,8 +91,7 @@ class BescheidService {
 	public void sendBescheidManually(AttachedItem bescheidItem, Command parentCommand) {
 		validateBescheidSendManually(bescheidItem, parentCommand.getRelationVersion());
 		var vorgang = vorgangService.getById(VorgangId.from(bescheidItem.getVorgangId()));
-		var subCommands = buildSetBescheidSentSubCommands(bescheidItem, vorgang, getUserId());
-		commandService.addSubCommands(buildCreateSubCommandsRequest(parentCommand.getId(), subCommands));
+		addSubCommands(parentCommand.getId(), buildSetBescheidSentSubCommands(bescheidItem, vorgang, getUserId()));
 	}
 
 	void validateBescheidSendManually(AttachedItem bescheidItem, long version) {
@@ -109,11 +108,7 @@ class BescheidService {
 		var userId = getUserId();
 		var subCommands = buildSetBescheidSentSubCommands(bescheidItem, vorgang, userId);
 		subCommands.add(buildSendPostfachNachrichtCommand(bescheidItem, vorgang.getServiceKonto(), userId));
-		commandService.addSubCommands(buildCreateSubCommandsRequest(parentCommand.getId(), subCommands));
-	}
-
-	String getUserId() {
-		return userProfileService.getUserProfile().getId().toString();
+		addSubCommands(parentCommand.getId(), subCommands);
 	}
 
 	public void validateBescheidSendPostfach(AttachedItem bescheidItem, long version) {
@@ -122,10 +117,10 @@ class BescheidService {
 		if (Bescheid.SendBy.NACHRICHT.notValue(sendBy)) {
 			throw new TechnicalException("Bescheid has unexpected sendBy value: '%s'. Expected is %s".formatted(sendBy, Bescheid.SendBy.NACHRICHT));
 		}
-		if (StringUtils.isBlank(getNachrichtSubject(bescheidItem))) {
+		if (getNachrichtSubject(bescheidItem).isEmpty()) {
 			throw new TechnicalException("Bescheid has no nachricht subject");
 		}
-		if (StringUtils.isBlank(getNachrichtText(bescheidItem))) {
+		if (getNachrichtText(bescheidItem).isEmpty()) {
 			throw new TechnicalException("Bescheid has no nachricht text");
 		}
 	}
@@ -143,32 +138,16 @@ class BescheidService {
 		}
 	}
 
-	FileId getBescheidFileId(AttachedItem bescheidItem) {
-		var bescheidDocument = attachedItemService.getItem(MapUtils.getString(bescheidItem.getItem(), Bescheid.FIELD_BESCHEID_DOCUMENT));
-		return FileId.from(MapUtils.getString(bescheidDocument.getItem(), Document.FIELD_DOCUMENT_FILE));
-	}
-
-	String getNachrichtSubject(AttachedItem bescheidItem) {
-		return MapUtils.getString(bescheidItem.getItem(), Bescheid.FIELD_NACHRICHT_SUBJECT);
-	}
-
-	String getNachrichtText(AttachedItem bescheidItem) {
-		return MapUtils.getString(bescheidItem.getItem(), Bescheid.FIELD_NACHRICHT_TEXT);
+	Optional<String> getNachrichtSubject(AttachedItem bescheidItem) {
+		return Optional.ofNullable(MapUtils.getString(bescheidItem.getItem(), Bescheid.FIELD_NACHRICHT_SUBJECT)).map(StringUtils::trimToNull);
 	}
 
-	List<FileId> getAttachments(AttachedItem bescheidItem) {
-		var attachmentsObject = bescheidItem.getItem().get(Bescheid.FIELD_ATTACHMENTS);
-		if (attachmentsObject instanceof Collection<?> attachments) {
-			return attachments.stream().map(String::valueOf).map(FileId::from).toList();
-		}
-		return getStringAsList(attachmentsObject);
+	Optional<String> getNachrichtText(AttachedItem bescheidItem) {
+		return Optional.ofNullable(MapUtils.getString(bescheidItem.getItem(), Bescheid.FIELD_NACHRICHT_TEXT)).map(StringUtils::trimToNull);
 	}
 
-	List<FileId> getStringAsList(Object attachmentsObject) {
-		if (attachmentsObject instanceof String attachment && StringUtils.isNotBlank(attachment)) {
-			return Collections.singletonList(FileId.from(attachment));
-		}
-		return Collections.emptyList();
+	String getUserId() {
+		return userProfileService.getUserProfile().getId().toString();
 	}
 
 	List<OzgCloudCommand> buildSetBescheidSentSubCommands(AttachedItem bescheidItem, Vorgang vorgang, String userId) {
@@ -222,13 +201,20 @@ class BescheidService {
 				.build();
 	}
 
-	Map<String, Object> buildSendNachrichtCommandBody(AttachedItem bescheidItem, Map<String, Object> serviceKonto) {
+	Map<String, Object> buildPostfachAddress(Vorgang.PostfachAddress postfachAddress, String serviceKontoType) {
+		return Map.of(Vorgang.PostfachAddress.FIELD_TYPE, postfachAddress.getType(),
+				Vorgang.PostfachAddress.FIELD_VERSION, postfachAddress.getVersion(),
+				Vorgang.PostfachAddress.FIELD_IDENTIFIER, postfachAddress.getIdentifier(),
+				Vorgang.ServiceKonto.FIELD_SERVICEKONTO_TYPE, serviceKontoType);
+	}
+
+	Map<String, Object> buildSendNachrichtCommandBody(AttachedItem bescheidItem, Map<String, Object> postfachAddress) {
 		return Map.of(
 				NachrichtService.FIELD_REPLY_OPTION, NachrichtService.REPLY_OPTION,
-				NachrichtService.FIELD_SUBJECT, Optional.ofNullable(getNachrichtSubject(bescheidItem)).orElse(NachrichtService.SUBJECT),
-				NachrichtService.FIELD_MAIL_BODY, Optional.ofNullable(getNachrichtText(bescheidItem)).orElse(StringUtils.EMPTY),
+				NachrichtService.FIELD_SUBJECT, getNachrichtSubject(bescheidItem).orElse(NachrichtService.SUBJECT),
+				NachrichtService.FIELD_MAIL_BODY, getNachrichtText(bescheidItem).orElse(StringUtils.EMPTY),
 				NachrichtService.FIELD_ATTACHMENTS, buildAttachments(bescheidItem),
-				Vorgang.ServiceKonto.FIELD_POSTFACH_ADDRESS, serviceKonto);
+				Vorgang.ServiceKonto.FIELD_POSTFACH_ADDRESS, postfachAddress);
 
 	}
 
@@ -236,11 +222,28 @@ class BescheidService {
 		return Stream.concat(Stream.of(getBescheidFileId(bescheidItem)), getAttachments(bescheidItem).stream()).map(FileId::toString).toList();
 	}
 
-	Map<String, Object> buildPostfachAddress(Vorgang.PostfachAddress postfachAddress, String serviceKontoType) {
-		return Map.of(Vorgang.PostfachAddress.FIELD_TYPE, postfachAddress.getType(),
-				Vorgang.PostfachAddress.FIELD_VERSION, postfachAddress.getVersion(),
-				Vorgang.PostfachAddress.FIELD_IDENTIFIER, postfachAddress.getIdentifier(),
-				Vorgang.ServiceKonto.FIELD_SERVICEKONTO_TYPE, serviceKontoType);
+	FileId getBescheidFileId(AttachedItem bescheidItem) {
+		var bescheidDocument = attachedItemService.getItem(MapUtils.getString(bescheidItem.getItem(), Bescheid.FIELD_BESCHEID_DOCUMENT));
+		return FileId.from(MapUtils.getString(bescheidDocument.getItem(), Document.FIELD_DOCUMENT_FILE));
+	}
+
+	List<FileId> getAttachments(AttachedItem bescheidItem) {
+		var attachmentsObject = bescheidItem.getItem().get(Bescheid.FIELD_ATTACHMENTS);
+		if (attachmentsObject instanceof Collection<?> attachments) {
+			return attachments.stream().map(String::valueOf).map(FileId::from).toList();
+		}
+		return getStringAsList(attachmentsObject);
+	}
+
+	List<FileId> getStringAsList(Object attachmentsObject) {
+		if (attachmentsObject instanceof String attachment && StringUtils.isNotBlank(attachment)) {
+			return Collections.singletonList(FileId.from(attachment));
+		}
+		return Collections.emptyList();
+	}
+
+	void addSubCommands(String parentCommandId, List<OzgCloudCommand> subCommands) {
+		commandService.addSubCommands(buildCreateSubCommandsRequest(parentCommandId, subCommands));
 	}
 
 	OzgCloudCreateSubCommandsRequest buildCreateSubCommandsRequest(String parentCommandId, List<OzgCloudCommand> subCommands) {

bescheid-manager/src/main/java/de/ozgcloud/bescheid/attacheditem/AttachedItemService.java

@@ -35,7 +35,6 @@ import java.util.stream.Collectors;
 
 import org.apache.commons.collections.MapUtils;
 import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
 
@@ -45,16 +44,17 @@ import de.ozgcloud.apilib.common.command.grpc.CommandMapper;
 import de.ozgcloud.bescheid.Bescheid;
 import de.ozgcloud.bescheid.BescheidCallContextAttachingInterceptor;
 import de.ozgcloud.bescheid.BescheidManagerConfiguration;
-import de.ozgcloud.bescheid.common.callcontext.CurrentUserService;
 import de.ozgcloud.bescheid.common.freemarker.TemplateHandler;
 import de.ozgcloud.bescheid.vorgang.VorgangId;
 import de.ozgcloud.command.Command;
 import de.ozgcloud.common.errorhandling.TechnicalException;
 import de.ozgcloud.document.Document;
+import lombok.RequiredArgsConstructor;
 import lombok.extern.log4j.Log4j2;
 
 @Log4j2
 @Service
+@RequiredArgsConstructor
 public class AttachedItemService {
 
 	public static final String BESCHEID_ITEM_NAME = "Bescheid";
@@ -67,16 +67,10 @@ public class AttachedItemService {
 	static final String DEFAULT_TEMPLATE_FILE = "bescheid.nachrichtTemplate.txt.ftlh";
 
 	@Qualifier(BescheidManagerConfiguration.COMMAND_SERVICE_NAME)
-	@Autowired
-	private OzgCloudCommandService commandService;
-	@Autowired
-	private VorgangAttachedItemRemoteService remoteService;
-	@Autowired
-	private CommandMapper commandMapper;
-	@Autowired
-	private CurrentUserService currentUserService;
-	@Autowired
-	private TemplateHandler templateHandler;
+	private final OzgCloudCommandService commandService;
+	private final VorgangAttachedItemRemoteService remoteService;
+	private final CommandMapper commandMapper;
+	private final TemplateHandler templateHandler;
 
 	public Optional<AttachedItem> findBescheidItem(String vorgangId) {
 		return remoteService.findBescheidDraft(vorgangId);

bescheid-manager/src/main/java/de/ozgcloud/bescheid/vorgang/VorgangService.java

 package de.ozgcloud.bescheid.vorgang;
 
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
 
-import de.ozgcloud.apilib.common.command.OzgCloudCommandService;
-import de.ozgcloud.apilib.common.command.grpc.CommandMapper;
 import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
 
 @Service("bescheid_VorgangService")
+@RequiredArgsConstructor
 public class VorgangService {
 
-	@Autowired
-	private VorgangRemoteService remoteService;
-	@Autowired
-	@Qualifier("bescheid_OzgCloudCommandService")
-	private OzgCloudCommandService commandService;
-	@Autowired
-	private CommandMapper commandMapper;
+	private final VorgangRemoteService remoteService;
 
 	public Vorgang getById(@NonNull VorgangId id) {
 		return remoteService.getById(id);

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

@@ -28,15 +28,12 @@ import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
-import java.time.ZonedDateTime;
-import java.time.temporal.ChronoUnit;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
-import org.apache.commons.collections.MapUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
@@ -61,8 +58,6 @@ import de.ozgcloud.apilib.vorgang.OzgCloudVorgangId;
 import de.ozgcloud.bescheid.Bescheid;
 import de.ozgcloud.bescheid.Bescheid.SendBy;
 import de.ozgcloud.bescheid.BescheidCallContextAttachingInterceptor;
-import de.ozgcloud.bescheid.common.callcontext.CallContextUser;
-import de.ozgcloud.bescheid.common.callcontext.CurrentUserService;
 import de.ozgcloud.bescheid.common.freemarker.TemplateHandler;
 import de.ozgcloud.bescheid.vorgang.VorgangId;
 import de.ozgcloud.bescheid.vorgang.VorgangTestFactory;
@@ -86,8 +81,6 @@ class AttachedItemServiceTest {
 	@Mock
 	private VorgangAttachedItemRemoteService remoteService;
 	@Mock
-	private CurrentUserService currentUserService;
-	@Mock
 	private TemplateHandler templateHandler;
 
 	@Nested
@@ -1039,257 +1032,6 @@ class AttachedItemServiceTest {
 		}
 	}
 
-	@Nested
-	class TestSetBescheidSentStatus {
-
-		private static final Map<String, Object> BODY_OBJECT_MAP = Map.of("key", "value");
-
-		@Mock
-		private OzgCloudCommand command;
-
-		@BeforeEach
-		void init() {
-			doReturn(BODY_OBJECT_MAP).when(service).buildBescheidSentStatusBodyObject(any());
-		}
-
-		@Test
-		void shouldCallBuildPatchBescheidCommand() {
-			setBescheidStatusSent();
-
-			verify(service).buildPatchBescheidCommand(AttachedItemTestFactory.ID, AttachedItemTestFactory.VERSION, BODY_OBJECT_MAP);
-		}
-
-		@Test
-		void shouldCallCommandService() {
-			doReturn(command).when(service).buildPatchBescheidCommand(any(), anyLong(), any());
-
-			setBescheidStatusSent();
-
-			verify(commandService).createAndWaitUntilDone(command);
-		}
-
-		private void setBescheidStatusSent() {
-			service.setBescheidSentStatus(AttachedItemTestFactory.ID, AttachedItemTestFactory.VERSION);
-		}
-	}
-
-	@Nested
-	class TestBuildBescheidSentStatusBodyObject {
-
-		@Test
-		void shouldSetId() {
-			var result = service.buildBescheidSentStatusBodyObject(AttachedItemTestFactory.ID);
-
-			assertThat(result).containsEntry(AttachedItem.PROPERTY_ID, AttachedItemTestFactory.ID);
-		}
-
-		@Test
-		void shouldCallBuildBescheidSentStatusItem() {
-			service.buildBescheidSentStatusBodyObject(AttachedItemTestFactory.ID);
-
-			verify(service).buildBescheidSentStatusItem();
-		}
-
-		@Test
-		void shouldSetBescheidBodyObject() {
-			var expectedItemMap = Map.of("key", "value");
-			doReturn(expectedItemMap).when(service).buildBescheidSentStatusItem();
-
-			var result = service.buildBescheidSentStatusBodyObject(AttachedItemTestFactory.ID);
-
-			assertThat(result).containsEntry(AttachedItem.PROPERTY_ITEM, expectedItemMap);
-		}
-
-	}
-
-	@Nested
-	class TestBuildBescheidSentStatusItem {
-
-		@Test
-		void shouldSetStatus() {
-			var result = service.buildBescheidSentStatusItem();
-
-			assertThat(result).containsEntry(Bescheid.FIELD_STATUS, Bescheid.Status.SENT.name());
-		}
-	}
-
-	@Nested
-	class TestBuildSentInfoMap {
-
-		@Test
-		void shouldSetSentAt() {
-			var result = service.buildSentInfoMap();
-
-			assertThat(getSentAt(result)).isCloseTo(ZonedDateTime.now(), within(2, ChronoUnit.SECONDS));
-		}
-
-		@Test
-		void shouldCallGetUser() {
-			service.buildSentInfoMap();
-
-			verify(currentUserService).findUser();
-		}
-
-		@Test
-		void shouldSetSentBy() {
-			var userId = "user-id";
-			doReturn(userId).when(service).getUserId();
-
-			var result = service.buildSentInfoMap();
-
-			assertThat(result).containsEntry(Bescheid.FIELD_SENT_BY, userId);
-		}
-
-		private ZonedDateTime getSentAt(Map<String, Object> sentInfo) {
-			return ZonedDateTime.parse(MapUtils.getString(sentInfo, Bescheid.FIELD_SENT_AT));
-		}
-	}
-
-	@Nested
-	class TestGetUserId {
-
-		@Mock
-		private CallContextUser callContextUser;
-
-		@Test
-		void shouldCallFindUser() {
-			service.getUserId();
-
-			verify(currentUserService).findUser();
-		}
-
-		@Test
-		void shouldCallGetUserIdOnCallContexUser() {
-			when(currentUserService.findUser()).thenReturn(Optional.of(callContextUser));
-
-			service.getUserId();
-
-			verify(callContextUser).getUserId();
-		}
-
-		@Test
-		void shouldReturnUserId() {
-			var expectedUserId = "user-id";
-			when(callContextUser.getUserId()).thenReturn(Optional.of(expectedUserId));
-			when(currentUserService.findUser()).thenReturn(Optional.of(callContextUser));
-
-			var result = service.getUserId();
-
-			assertThat(result).isEqualTo(expectedUserId);
-		}
-
-		@Test
-		void shouldReturnEmptyWhenNoUserFound() {
-			var result = service.getUserId();
-
-			assertThat(result).isEmpty();
-		}
-
-		@Test
-		void shouldReturnEmptyWhenNoUserIdFound() {
-			when(currentUserService.findUser()).thenReturn(Optional.of(callContextUser));
-
-			var result = service.getUserId();
-
-			assertThat(result).isEmpty();
-		}
-	}
-
-	@Nested
-	class TestRevertBescheidStatusSent {
-
-		private static final Map<String, Object> BODY_OBJECT_MAP = Map.of("key", "value");
-
-		@Mock
-		private OzgCloudCommand command;
-
-		@Test
-		void shouldCallBuildRevertBescheidSentStatusBodyObject() {
-			revertBescheidStatusSent();
-
-			verify(service).buildRevertBescheidSentStatusBodyObject(AttachedItemTestFactory.ID);
-		}
-
-		@Test
-		void shouldCallBuildPatchBescheidCommand() {
-			doReturn(BODY_OBJECT_MAP).when(service).buildRevertBescheidSentStatusBodyObject(any());
-
-			revertBescheidStatusSent();
-
-			verify(service).buildPatchBescheidCommand(AttachedItemTestFactory.ID, AttachedItemTestFactory.VERSION, BODY_OBJECT_MAP);
-		}
-
-		@Test
-		void shouldCallCommandService() {
-			doReturn(command).when(service).buildPatchBescheidCommand(any(), anyLong(), any());
-
-			revertBescheidStatusSent();
-
-			verify(commandService).createAndWaitUntilDone(command);
-		}
-
-		private void revertBescheidStatusSent() {
-			service.revertBescheidSendStatus(AttachedItemTestFactory.ID, AttachedItemTestFactory.VERSION);
-		}
-
-	}
-
-	@Nested
-	class TestBuildRevertBescheidSentStatusBodyObject {
-
-		@Test
-		void shouldSetId() {
-			var result = service.buildRevertBescheidSentStatusBodyObject(AttachedItemTestFactory.ID);
-
-			assertThat(result).containsEntry(AttachedItem.PROPERTY_ID, AttachedItemTestFactory.ID);
-		}
-
-		@Test
-		void shouldCallBuildRevertBescheidSentStatusItem() {
-			service.buildRevertBescheidSentStatusBodyObject(AttachedItemTestFactory.ID);
-
-			verify(service).buildRevertBescheidSentStatusItem();
-		}
-
-		@Test
-		void shouldSetBescheidBodyObject() {
-			var expectedItemMap = Map.of("key", "value");
-			doReturn(expectedItemMap).when(service).buildRevertBescheidSentStatusItem();
-
-			var result = service.buildRevertBescheidSentStatusBodyObject(AttachedItemTestFactory.ID);
-
-			assertThat(result).containsEntry(AttachedItem.PROPERTY_ITEM, expectedItemMap);
-		}
-	}
-
-	@Nested
-	class TestBuildRevertBescheidSentStatusItem {
-
-		@Test
-		void shouldCallBuildItemMap() {
-			service.buildRevertBescheidSentStatusItem();
-
-			verify(service).buildItemMap(Bescheid.Status.DRAFT);
-		}
-
-		@Test
-		void shouldReturnResultsOfBuildItemMap() {
-			var expectedItemMap = new HashMap<String, Object>(Map.of("key", "value"));
-			doReturn(expectedItemMap).when(service).buildItemMap(any());
-
-			var result = service.buildRevertBescheidSentStatusItem();
-
-			assertThat(result).containsEntry("key", "value");
-		}
-
-		@Test
-		void shouldSetSentInfoNull() {
-			var result = service.buildRevertBescheidSentStatusItem();
-
-			assertThat(result).containsEntry(Bescheid.FIELD_SENT_INFO, null);
-		}
-	}
-
 	@Nested
 	class TestBuildItemMap {
 
@@ -1301,54 +1043,6 @@ class AttachedItemServiceTest {
 		}
 	}
 
-	@Nested
-	class TestBuildPatchBescheidCommand {
-
-		private static final Map<String, Object> BODY_OBJECT_MAP = Map.of("key", "value");
-
-		@Test
-		void shouldCallRelationIdMapper() {
-			buildPatchBescheidCommand();
-
-			verify(commandMapper).mapRelationId(AttachedItemTestFactory.ID);
-		}
-
-		@Test
-		void shouldSetRelationId() {
-			var expectedId = GenericId.from(AttachedItemTestFactory.ID);
-			when(commandMapper.mapRelationId(any())).thenReturn(expectedId);
-
-			var result = buildPatchBescheidCommand();
-
-			assertThat(result.getRelationId()).isEqualTo(expectedId);
-		}
-
-		@Test
-		void shouldSetRelationVersion() {
-			var result = buildPatchBescheidCommand();
-
-			assertThat(result.getRelationVersion()).isEqualTo(AttachedItemTestFactory.VERSION);
-		}
-
-		@Test
-		void shouldSetOrder() {
-			var result = buildPatchBescheidCommand();
-
-			assertThat(result.getOrder()).isEqualTo(AttachedItemService.PATCH_ATTACHED_ITEM);
-		}
-
-		@Test
-		void shouldSetBodyObject() {
-			var result = buildPatchBescheidCommand();
-
-			assertThat(result.getBodyObject()).isSameAs(BODY_OBJECT_MAP);
-		}
-
-		private OzgCloudCommand buildPatchBescheidCommand() {
-			return service.buildPatchBescheidCommand(AttachedItemTestFactory.ID, AttachedItemTestFactory.VERSION, BODY_OBJECT_MAP);
-		}
-	}
-
 	@Nested
 	class TestFindAllBescheid {
 

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.List;
-import java.util.Map;
 import java.util.Optional;
 
 import org.junit.jupiter.api.BeforeEach;
@@ -16,21 +13,9 @@ 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.attacheditem.AttachedItemTestFactory;
 import de.ozgcloud.bescheid.common.freemarker.TemplateHandler;
-import de.ozgcloud.bescheid.vorgang.PostfachAddressTestFactory;
-import de.ozgcloud.bescheid.vorgang.ServiceKontoTestFactory;
-import de.ozgcloud.bescheid.vorgang.Vorgang;
 import de.ozgcloud.bescheid.vorgang.VorgangTestFactory;
-import de.ozgcloud.common.errorhandling.TechnicalException;
 
 class NachrichtServiceTest {
 
@@ -41,10 +26,6 @@ class NachrichtServiceTest {
 	@Mock
 	private NachrichtRemoteService remoteService;
 	@Mock
-	private OzgCloudCommandService commandService;
-	@Mock
-	private CommandMapper commandMapper;
-	@Mock
 	private TemplateHandler templateHandler;
 
 	@Nested
@@ -126,225 +107,4 @@ 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 final Bescheid bescheid = BescheidTestFactory.create();
-
-		@Test
-		void shouldCallBuildPostfachAddress() {
-			service.buildSendNachrichtCommandBody(bescheid);
-
-			verify(service).buildPostfachAddress(bescheid);
-		}
-
-		@Test
-		void shouldSetPostfachAddress() {
-			var postfachAddressMap = Map.<String, Object>of("key", "value");
-			doReturn(postfachAddressMap).when(service).buildPostfachAddress(any());
-
-			var result = service.buildSendNachrichtCommandBody(bescheid);
-
-			assertThat(result).containsEntry(Vorgang.ServiceKonto.FIELD_POSTFACH_ADDRESS, postfachAddressMap);
-		}
-
-		@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,
-					List.of(BescheidTestFactory.BESCHEID_FILE_ID, AttachedItemTestFactory.ATTACHMENT));
-		}
-	}
-
-	@Nested
-	class TestBuildPostfachAddress {
-
-		@Test
-		void shouldCallGetAddress() {
-			var bescheid = BescheidTestFactory.create();
-
-			service.buildPostfachAddress(bescheid);
-
-			verify(service).getAddress(bescheid);
-		}
-
-		@Test
-		void shouldThrowExceptionIfNoServiceKonto() {
-			doReturn(Optional.empty()).when(service).getAddress(any());
-			var bescheid = BescheidTestFactory.create();
-
-			assertThrows(TechnicalException.class, () -> service.buildPostfachAddress(bescheid));
-		}
-
-		@Test
-		void shouldSetAddressType() {
-			var result = service.buildPostfachAddress(BescheidTestFactory.create());
-
-			assertThat(result).containsEntry(Vorgang.PostfachAddress.FIELD_TYPE, PostfachAddressTestFactory.TYPE);
-		}
-
-		@Test
-		void shouldSetAddressVersion() {
-			var result = service.buildPostfachAddress(BescheidTestFactory.create());
-
-			assertThat(result).containsEntry(Vorgang.PostfachAddress.FIELD_VERSION, PostfachAddressTestFactory.VERSION);
-		}
-
-		@Test
-		void shouldSetAddressIdentifier() {
-			var result = service.buildPostfachAddress(BescheidTestFactory.create());
-
-			assertThat(result).extracting(Vorgang.PostfachAddress.FIELD_IDENTIFIER, MAP)
-					.containsEntry(NachrichtService.FIELD_POSTFACH_ID, PostfachAddressTestFactory.POSTFACH_ID);
-		}
-
-		@Test
-		void shouldSetServiceKontoType() {
-			var result = service.buildPostfachAddress(BescheidTestFactory.create());
-
-			assertThat(result).containsEntry(Vorgang.ServiceKonto.FIELD_SERVICEKONTO_TYPE, ServiceKontoTestFactory.TYPE);
-		}
-
-	}
-
 }

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

@@ -11,12 +11,6 @@ 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.vorgang.OzgCloudVorgangId;
-
 class VorgangServiceTest {
 
 	@Spy
@@ -25,10 +19,6 @@ class VorgangServiceTest {
 
 	@Mock
 	private VorgangRemoteService remoteService;
-	@Mock
-	private OzgCloudCommandService commandService;
-	@Mock
-	private CommandMapper commandMapper;
 
 	@Nested
 	class TestGetById {
@@ -54,99 +44,4 @@ class VorgangServiceTest {
 			assertThat(result).isEqualTo(vorgang);
 		}
 	}
-
-	@Nested
-	class TestBescheiden {
-
-		private final static Vorgang VORGANG = VorgangTestFactory.create();
-
-		@Mock
-		private OzgCloudCommand ozgCloudCommand;
-
-		@BeforeEach
-		void init() {
-			doReturn(VORGANG).when(service).getById(any(VorgangId.class));
-		}
-
-		@Test
-		void shouldCallGetBeyId() {
-			service.bescheiden(VorgangTestFactory.ID.toString());
-
-			verify(service).getById(VorgangTestFactory.ID);
-		}
-
-		@Test
-		void shouldCallBuildBescheidenCommand() {
-			service.bescheiden(VorgangTestFactory.ID.toString());
-
-			verify(service).buildVorgangBescheidenCommand(VORGANG);
-		}
-
-		@Test
-		void shouldCallCommandService() {
-			//			doReturn(ozgCloudCommand).when(service).buildVorgangBescheidenCommand(any());
-
-			service.bescheiden(VorgangTestFactory.ID.toString());
-
-			verify(commandService).createAndWaitUntilDone(ozgCloudCommand);
-		}
-	}
-
-	@Nested
-	class TestBuildBescheidenCommand {
-
-		private final static Vorgang VORGANG = VorgangTestFactory.create();
-
-		@Test
-		void shouldCallCommandMapperToOzgCloudVorgangId() {
-			service.buildVorgangBescheidenCommand(VORGANG);
-
-			verify(commandMapper).toOzgCloudVorgangId(VorgangTestFactory.ID.toString());
-		}
-
-		@Test
-		void shouldSetVorgangId() {
-			var expectedId = OzgCloudVorgangId.from(VorgangTestFactory.ID.toString());
-			when(commandMapper.toOzgCloudVorgangId(any())).thenReturn(expectedId);
-
-			var result = service.buildVorgangBescheidenCommand(VORGANG);
-
-			assertThat(result.getVorgangId()).isEqualTo(expectedId);
-		}
-
-		@Test
-		void shouldCallCommandMapperMapRelationId() {
-			service.buildVorgangBescheidenCommand(VORGANG);
-
-			verify(commandMapper).mapRelationId(VorgangTestFactory.ID.toString());
-		}
-
-		@Test
-		void shouldSetRelationId() {
-			var expectedId = GenericId.from(VorgangTestFactory.ID.toString());
-			when(commandMapper.mapRelationId(any())).thenReturn(expectedId);
-
-			var result = service.buildVorgangBescheidenCommand(VORGANG);
-
-			assertThat(result.getRelationId()).isEqualTo(expectedId);
-		}
-
-		@Test
-		void shouldSetRelationVersion() {
-			var expectedVersion = VORGANG.getVersion();
-
-			var result = service.buildVorgangBescheidenCommand(VORGANG);
-
-			assertThat(result.getRelationVersion()).isEqualTo(expectedVersion);
-		}
-
-		@Test
-		void shouldSetOrder() {
-			var expectedOrder = VorgangService.VORGANG_BESCHEIDEN;
-
-			var result = service.buildVorgangBescheidenCommand(VORGANG);
-
-			assertThat(result.getOrder()).isEqualTo(expectedOrder);
-		}
-	}
 }