OZG-3665 implement xta service

xta-adapter/pom.xml

@@ -19,6 +19,11 @@
 				</exclusion>
 			</exclusions>
 		</dependency>
+		<!-- own projects -->
+		<dependency>
+			<groupId>de.itvsh.kop.eingangsadapter</groupId>
+			<artifactId>common</artifactId>
+		</dependency>
 		<!--mapstruct-->
 		<dependency>
 			<groupId>org.mapstruct</groupId>

xta-adapter/src/main/java/de/ozgcloud/eingang/xta/XtaMessage.java

 package de.ozgcloud.eingang.xta;
 
-public record XtaMessage(
-		XtaMessageMetaData metaData,
-		XtaFile messageFile) {
+import lombok.Builder;
+import lombok.Getter;
 
+@Builder
+@Getter
+public class XtaMessage {
+	private XtaMessageMetaData metaData;
+	private XtaFile messageFile;
 }

xta-adapter/src/main/java/de/ozgcloud/eingang/xta/XtaMessageMapper.java

+package de.ozgcloud.eingang.xta;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Objects;
+
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+
+import de.itvsh.kop.eingangsadapter.common.errorhandling.TechnicalException;
+import de.itvsh.kop.eingangsadapter.common.formdata.DeleteOnCloseInputStream;
+import de.itvsh.kop.eingangsadapter.common.formdata.FormData;
+import de.itvsh.kop.eingangsadapter.common.formdata.FormHeader;
+import de.itvsh.kop.eingangsadapter.common.formdata.IncomingFile;
+
+@Mapper
+interface XtaMessageMapper {
+
+	@Mapping(target = "antragsteller", ignore = true)
+	@Mapping(target = "attachment", ignore = true)
+	@Mapping(target = "attachments", ignore = true)
+	@Mapping(target = "formData", ignore = true)
+	@Mapping(target = "id", ignore = true)
+	@Mapping(target = "numberOfAttachments", ignore = true)
+	@Mapping(target = "numberOfRepresentations", ignore = true)
+	@Mapping(target = "representation", source = "messageFile")
+	@Mapping(target = "representations", ignore = true)
+	@Mapping(target = "zustaendigeStelle", ignore = true)
+	@Mapping(target = "header", source = "metaData")
+	FormData toFormData(XtaMessage message);
+
+	@Mapping(target = "formEngineName", ignore = true)
+	@Mapping(target = "formId", source = "messageType")
+	@Mapping(target = "requestId", ignore = true)
+	@Mapping(target = "serviceKonto", ignore = true)
+	@Mapping(target = "createdAt", source = "origin")
+	@Mapping(target = "sender", constant = "XTA")
+	@Mapping(target = "formName", source = "messageType")
+	FormHeader formHeaderFromMetaData(XtaMessageMetaData metaData);
+
+	default IncomingFile toIncomingFile(XtaFile messageFile) {
+		if (Objects.nonNull(messageFile)) {
+			return IncomingFile.builder()
+					.name(messageFile.name())
+					.contentType("application/zip")
+					.contentStream(openFile(messageFile.file()))
+					.size(messageFile.file().length())
+					.build();
+		}
+		return null;
+	}
+
+	default InputStream openFile(File file) {
+		try {
+			return new DeleteOnCloseInputStream(file);
+		} catch (IOException e) {
+			throw new TechnicalException("Error opening xta message file.");
+		}
+	}
+}

xta-adapter/src/main/java/de/ozgcloud/eingang/xta/XtaMessageMetaData.java

@@ -3,15 +3,18 @@ package de.ozgcloud.eingang.xta;
 import java.time.ZonedDateTime;
 
 import lombok.Builder;
+import lombok.Getter;
 
 @Builder
-record XtaMessageMetaData(
+@Getter
+class XtaMessageMetaData {
 	// MsgIdentification.MessageId
-		XtaMessageId messageId,
+	private XtaMessageId messageId;
 	// DeliveryAttributes.origin
-		ZonedDateTime origin,
+	private ZonedDateTime origin;
 	// DeliveryAttributes.delivery
-		ZonedDateTime delivery,
+	private ZonedDateTime delivery;
 	// Qualifier.MessageType.code
-		String messageType) {
+	private String messageType;
+
 }

xta-adapter/src/main/java/de/ozgcloud/eingang/xta/XtaService.java

@@ -6,6 +6,7 @@ import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
+import de.itvsh.kop.eingangsadapter.common.formdata.FormData;
 import lombok.extern.log4j.Log4j2;
 
 @Service
@@ -16,19 +17,29 @@ class XtaService {
 
 	@Autowired
 	private XtaRemoteService remoteService;
+	@Autowired
+	private XtaMessageMapper mapper;
+
+	public Stream<FormData> getMessagesAsFormData() {
+		return getMessagesMetaData().map(XtaMessageMetaData::getMessageId).map(this::getFormData);
+	}
 
-	Stream<XtaMessageMetaData> getMessages() {
+	public Stream<XtaMessageMetaData> getMessagesMetaData() {
 		return remoteService.getMessagesMetadata().filter(this::filterByMessageType);
 	}
 
 	// filter criteria for dFoerdermittelantrag
 	// https://jira.mgm-tp.com/jira/browse/OZG-3659
 	private boolean filterByMessageType(XtaMessageMetaData metaData) {
-		if (StringUtils.equals(metaData.messageType(), DFOERDERMITTELANTRAG_MESSAGE_TYPE)) {
+		if (StringUtils.equals(metaData.getMessageType(), DFOERDERMITTELANTRAG_MESSAGE_TYPE)) {
 			return true;
 		}
 
-		LOG.warn("Ignoring XTA-Message of type '{}'.", metaData.messageType());
+		LOG.warn("Ignoring XTA-Message of type '{}'.", metaData.getMessageType());
 		return false;
 	}
+
+	public FormData getFormData(XtaMessageId messageId) {
+		return mapper.toFormData(remoteService.getMessage(messageId));
+	}
 }

xta-adapter/src/test/java/de/ozgcloud/eingang/xta/FormDataTestFactory.java

+package de.ozgcloud.eingang.xta;
+
+import de.itvsh.kop.eingangsadapter.common.formdata.FormData;
+import de.itvsh.kop.eingangsadapter.common.formdata.FormHeader;
+
+class FormDataTestFactory {
+
+	static FormData create() {
+		return createBuilder().build();
+	}
+
+	static FormData.FormDataBuilder createBuilder() {
+		return FormData.builder()
+				.header(createHeader());
+	}
+
+	static FormHeader createHeader() {
+		return FormHeader.builder()
+				.sender("XTA")
+				.formName(XtaMessageMetaDataTestFactory.MESSAGE_TYPE)
+				.formId(XtaMessageMetaDataTestFactory.MESSAGE_TYPE)
+				.createdAt(XtaMessageMetaDataTestFactory.ORIGIN)
+				.build();
+	}
+}

xta-adapter/src/test/java/de/ozgcloud/eingang/xta/MessageMetaDataTestFactory.java

 package de.ozgcloud.eingang.xta;
 
-import static de.ozgcloud.eingang.xta.XtaMessageMetaDataTestFactory.*;
+import static de.ozgcloud.eingang.xta.XtaMessageTestFactory.*;
 
 import org.w3._2005._08.addressing.AttributedURIType;
 

xta-adapter/src/test/java/de/ozgcloud/eingang/xta/XtaFileTestFactory.java

+package de.ozgcloud.eingang.xta;
+
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+
+import org.apache.commons.io.FileUtils;
+
+import lombok.SneakyThrows;
+
+class XtaFileTestFactory {
+
+	static final String NAME = "Test_File";
+	static final String CONTENT = "slkafj3jifsdasx";
+
+	static XtaFile create() {
+		return createBuilder().build();
+	}
+
+	static XtaFile.XtaFileBuilder createBuilder() {
+		return XtaFile.builder().name(NAME).file(createFile());
+	}
+
+	@SneakyThrows
+	private static File createFile() {
+		File tFile = File.createTempFile("test", "txt");
+		tFile.deleteOnExit();
+
+		FileUtils.write(tFile, CONTENT, StandardCharsets.UTF_8);
+
+		return tFile;
+	}
+}

xta-adapter/src/test/java/de/ozgcloud/eingang/xta/XtaMessageMapperTest.java

+package de.ozgcloud.eingang.xta;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mapstruct.factory.Mappers;
+import org.mockito.InjectMocks;
+import org.mockito.Spy;
+
+class XtaMessageMapperTest {
+
+	@Spy
+	@InjectMocks
+	private XtaMessageMapper mapper = Mappers.getMapper(XtaMessageMapper.class);
+
+	@Nested
+	class TestToFormData {
+
+		@Test
+		void shouldMapAllToForm() {
+			var formData = mapper.toFormData(XtaMessageTestFactory.create());
+
+			assertThat(formData).usingRecursiveComparison().ignoringFields("id", "representations")
+					.isEqualTo(FormDataTestFactory.create());
+		}
+
+		@Test
+		void shouldHaveMessageFileAsRepresentation() {
+			var formData = mapper.toFormData(XtaMessageTestFactory.create());
+
+			assertThat(formData.getRepresentations()).hasSize(1);
+		}
+
+		@Test
+		void shouldCallToIncomingFile() {
+			XtaMessage message = XtaMessageTestFactory.create();
+
+			mapper.toFormData(message);
+
+			verify(mapper).toIncomingFile(message.getMessageFile());
+		}
+
+		@Nested
+		class ToIncomingFile {
+			@Test
+			void shouldHaveMessageFile() {
+				var inFile = mapper.toIncomingFile(XtaFileTestFactory.create());
+
+				assertThat(inFile.getContentStream()).isNotNull();
+			}
+
+			@Test
+			void shouldHaveFileName() {
+				var inFile = mapper.toIncomingFile(XtaFileTestFactory.create());
+
+				assertThat(inFile.getName()).isEqualTo(XtaFileTestFactory.NAME);
+			}
+
+			@Test
+			void shouldHaveZipContentType() {
+				var inFile = mapper.toIncomingFile(XtaFileTestFactory.create());
+
+				assertThat(inFile.getContentType()).isEqualTo("application/zip");
+			}
+
+			@Test
+			void shouldHaveSize() {
+				var inFile = mapper.toIncomingFile(XtaFileTestFactory.create());
+
+				assertThat(inFile.getSize()).isEqualTo(XtaFileTestFactory.CONTENT.length());
+			}
+
+			@Test
+			void shouldHandleMissingMessageFile() {
+				var fileGroup = mapper.toIncomingFile(null);
+
+				assertThat(fileGroup).isNull();
+			}
+		}
+
+	}
+}

xta-adapter/src/test/java/de/ozgcloud/eingang/xta/XtaMessageMetaDataTestFactory.java

 package de.ozgcloud.eingang.xta;
 
-import java.util.UUID;
+import static de.ozgcloud.eingang.xta.XtaMessageTestFactory.*;
+
+import java.time.ZonedDateTime;
 
 class XtaMessageMetaDataTestFactory {
 
-	static final XtaMessageId MESSAGE_ID = XtaMessageId.from(UUID.randomUUID().toString());
+	static final String MESSAGE_TYPE = "Geschaeftsgang.Geschaeftsgang.0201";
+	static final ZonedDateTime ORIGIN = ZonedDateTime.parse("2022-10-29T15:45:52.4942149+02:00");
 
 	static XtaMessageMetaData create() {
 		return createBuilder().build();
@@ -12,6 +15,8 @@ class XtaMessageMetaDataTestFactory {
 
 	static XtaMessageMetaData.XtaMessageMetaDataBuilder createBuilder() {
 		return XtaMessageMetaData.builder()
-				.messageId(MESSAGE_ID);
+				.messageId(MESSAGE_ID)
+				.messageType(MESSAGE_TYPE)
+				.origin(ORIGIN);
 	}
 }

xta-adapter/src/test/java/de/ozgcloud/eingang/xta/XtaMessageTestFactory.java

+package de.ozgcloud.eingang.xta;
+
+import java.util.UUID;
+
+class XtaMessageTestFactory {
+
+	static final XtaMessageId MESSAGE_ID = XtaMessageId.from(UUID.randomUUID().toString());
+
+	static XtaMessage create() {
+		return createBuilder().build();
+	}
+
+	static XtaMessage.XtaMessageBuilder createBuilder() {
+		return XtaMessage.builder()
+				.metaData(XtaMessageMetaDataTestFactory.create())
+				.messageFile(XtaFileTestFactory.create());
+
+	}
+}

xta-adapter/src/test/java/de/ozgcloud/eingang/xta/XtaServiceTest.java

@@ -2,6 +2,7 @@ package de.ozgcloud.eingang.xta;
 
 import static de.ozgcloud.eingang.xta.XtaService.*;
 import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.stream.Stream;
@@ -11,14 +12,44 @@ import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.Spy;
 
 class XtaServiceTest {
 
+	@Spy
 	@InjectMocks
 	private XtaService service;
 
 	@Mock
 	private XtaRemoteService remoteService;
+	@Mock
+	private XtaMessageMapper mapper;
+
+	@Nested
+	class TestGetMessagesAsFormData {
+
+		@BeforeEach
+		void init() {
+			when(service.getMessagesMetaData()).thenReturn(Stream.of(XtaMessageMetaDataTestFactory.create()));
+		}
+
+		@Test
+		void shouldCallGetFormData() {
+			service.getMessagesAsFormData().toList();
+
+			verify(service).getFormData(XtaMessageTestFactory.MESSAGE_ID);
+		}
+
+		@Test
+		void shouldReturnFormData() {
+			var formData = FormDataTestFactory.create();
+			when(service.getFormData(any())).thenReturn(formData);
+
+			var result = service.getMessagesAsFormData();
+
+			assertThat(result).hasSize(1).contains(formData);
+		}
+	}
 
 	@Nested
 	class TestGetMessages {
@@ -32,14 +63,14 @@ class XtaServiceTest {
 
 		@Test
 		void shouldCallRemoteService() {
-			service.getMessages();
+			service.getMessagesMetaData();
 
 			verify(remoteService).getMessagesMetadata();
 		}
 
 		@Test
 		void shouldReturnMetaData() {
-			var result = service.getMessages();
+			var result = service.getMessagesMetaData();
 
 			assertThat(result).hasSize(1).contains(metaData);
 		}
@@ -48,10 +79,45 @@ class XtaServiceTest {
 		void shouldOnlyReturnMatchingMessageCode() {
 			when(remoteService.getMessagesMetadata()).thenReturn(Stream.of(XtaMessageMetaDataTestFactory.createBuilder().messageType("other").build()));
 			
-			var result = service.getMessages();
+			var result = service.getMessagesMetaData();
 
 			assertThat(result).isEmpty();
 		}
 	}
 
+	@Nested
+	class TestFetFormData {
+
+		private XtaMessage message = XtaMessageTestFactory.create();
+
+		@BeforeEach
+		void init() {
+			when(remoteService.getMessage(any())).thenReturn(message);
+		}
+
+		@Test
+		void shouldCallRemoteService() {
+			service.getFormData(XtaMessageTestFactory.MESSAGE_ID);
+
+			verify(remoteService).getMessage(XtaMessageTestFactory.MESSAGE_ID);
+		}
+
+		@Test
+		void shouldCallMapper() {
+			service.getFormData(XtaMessageTestFactory.MESSAGE_ID);
+
+			verify(mapper).toFormData(message);
+		}
+
+		@Test
+		void shouldReturnMappedResult() {
+			var mapped = FormDataTestFactory.create();
+			when(mapper.toFormData(any())).thenReturn(mapped);
+
+			var result = service.getFormData(XtaMessageTestFactory.MESSAGE_ID);
+
+			assertThat(result).isSameAs(mapped);
+		}
+	}
+
 }