diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DateConverter.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DateConverter.java
index af27e007db7a9f7cf6e530ab0be9442a0af1f6fd..bce094fc04399c0c5202ada3250837afdaf7b38e 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DateConverter.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DateConverter.java
@@ -46,6 +46,10 @@ public class DateConverter {
return null;
}
+ public static XMLGregorianCalendar createEmpty() {
+ return DateConverter.createDatatypeFactory().newXMLGregorianCalendar();
+ }
+
static DatatypeFactory createDatatypeFactory() {
try {
return DatatypeFactory.newInstance();
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilder.java
index ac48de62dda65cb160e37d62a03be7583ff7ab37..b97093224e299529603354f5f9a2d03172753cd6 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilder.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilder.java
@@ -35,11 +35,15 @@ public class PrimaerdokumentTypeBuilder {
throw new IllegalStateException("Can not build Primaerdokument when ozg file is null");
}
- var primaerdokumentType = new PrimaerdokumentType();
- primaerdokumentType.setDateiname(ExportFilenameGenerator.generateExportFilename(ozgFile));
- primaerdokumentType.setDateinameOriginal(ozgFile.getName());
- primaerdokumentType.setErsteller(ersteller);
- primaerdokumentType.setDatumUhrzeit(DateConverter.toXmlGregorianCalendar(createdAt));
- return primaerdokumentType;
+ var primaerdokument = new PrimaerdokumentType();
+ primaerdokument.setDateiname(ExportFilenameGenerator.generateExportFilename(ozgFile));
+ primaerdokument.setDateinameOriginal(ozgFile.getName());
+ primaerdokument.setErsteller(ersteller);
+ if (createdAt != null) {
+ primaerdokument.setDatumUhrzeit(DateConverter.toXmlGregorianCalendar(createdAt));
+ } else {
+ primaerdokument.setDatumUhrzeit(DateConverter.createEmpty());
+ }
+ return primaerdokument;
}
}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportService.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportService.java
index efc201e0be72099cfa5f53361e6cfa038b41875f..95015618af8cf272e6a03120e4890a5304adf5cd 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportService.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportService.java
@@ -18,6 +18,7 @@ import org.springframework.stereotype.Service;
import de.ozgcloud.alfa.common.ExportFilenameGenerator;
import de.ozgcloud.alfa.common.file.OzgFile;
import de.ozgcloud.alfa.file.ExportFileService;
+import de.ozgcloud.alfa.kommentar.ExportKommentarService;
import de.ozgcloud.alfa.vorgang.Eingang;
import de.ozgcloud.alfa.vorgang.EingangHeader;
import de.ozgcloud.alfa.vorgang.ExportVorgangService;
@@ -38,6 +39,7 @@ class ExportService {
private final ExportFileService exportFileService;
private final ExportVorgangService exportVorgangService;
+ private final ExportKommentarService exportKommentarService;
public void writeExport(String vorgangId, String filenameId, OutputStream out) {
var exportData = collectExportData(vorgangId, filenameId);
@@ -56,6 +58,7 @@ class ExportService {
.withAktenzeichen(exportVorgangService.createAkteType(vorgang))
.withRepresentations(exportFileService.createDokumentTypes(representations, formEngineName).toList())
.withAttachments(exportFileService.createDokumentTypes(attachments, formEngineName).toList())
+ .withKommentare(exportKommentarService.createDokumentTypes(vorgang).toList())
.build();
var exportFiles = Stream.concat(representations.stream(), attachments.stream()).toList();
return ExportData.builder().abgabe(abgabe).exportFilename(buildXmlFilename(filenameId)).exportFiles(exportFiles).build();
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilder.java
index 50adf69cc56c4f60726e072cdd6ac09e278f473e..1f0e6db45378dda2b1e8a2d07d99a071f03fb821 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilder.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilder.java
@@ -1,5 +1,6 @@
package de.ozgcloud.alfa.export;
+import java.util.Collections;
import java.util.List;
import de.xoev.xdomea.AbgabeAbgabe0401;
@@ -16,8 +17,9 @@ class XdomeaNachrichtBuilder {
private VorgangType vorgang;
private NkAbgabeType kopf;
- private List<DokumentType> representations = List.of();
- private List<DokumentType> attachments = List.of();
+ private List<DokumentType> representations = Collections.emptyList();
+ private List<DokumentType> attachments = Collections.emptyList();
+ private List<DokumentType> kommentare = Collections.emptyList();
private AkteType aktenzeichen;
public static XdomeaNachrichtBuilder builder() {
@@ -49,6 +51,11 @@ class XdomeaNachrichtBuilder {
return this;
}
+ public XdomeaNachrichtBuilder withKommentare(List<DokumentType> kommentare) {
+ this.kommentare = kommentare;
+ return this;
+ }
+
public AbgabeAbgabe0401 build() {
var schriftgutobjekt = createSchriftgutobjekt();
addVorgangDokumente();
@@ -69,6 +76,7 @@ class XdomeaNachrichtBuilder {
void addVorgangDokumente() {
representations.forEach(vorgang.getDokument()::add);
attachments.forEach(vorgang.getDokument()::add);
+ kommentare.forEach(vorgang.getDokument()::add);
}
}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DateiformatCode.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/file/DateiformatCode.java
similarity index 89%
rename from alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DateiformatCode.java
rename to alfa-xdomea/src/main/java/de/ozgcloud/alfa/file/DateiformatCode.java
index b68bc80926cd283240a9f08a60ecfcfab2e8f285..2a86aaf9795820d72912c9fe063464fea282a4fe 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DateiformatCode.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/file/DateiformatCode.java
@@ -1,4 +1,4 @@
-package de.ozgcloud.alfa.common;
+package de.ozgcloud.alfa.file;
import de.xoev.xdomea.DateiformatCodeType;
import lombok.Getter;
@@ -6,7 +6,7 @@ import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Getter
-public enum DateiformatCode {
+enum DateiformatCode {
PDF("vCBzR", "018");
static final String LIST_URI = "urn:xoev-de:xdomea:codeliste:dateiformat";
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/file/DokumentTypeBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/file/DokumentTypeBuilder.java
index 625313a85d2365950b6e7d0295bc8bb520b9ff72..e927b380f5a9ea4731a30347a20091404f23a0aa 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/file/DokumentTypeBuilder.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/file/DokumentTypeBuilder.java
@@ -2,7 +2,6 @@ package de.ozgcloud.alfa.file;
import org.apache.commons.lang3.StringUtils;
-import de.ozgcloud.alfa.common.DateiformatCode;
import de.ozgcloud.alfa.common.PrimaerdokumentTypeBuilder;
import de.ozgcloud.alfa.common.UUIDConverter;
import de.ozgcloud.alfa.common.file.OzgFile;
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/DateiformatCode.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/DateiformatCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..e1ad860eaea329cfadb1e112eab9f5a8cbb357b1
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/DateiformatCode.java
@@ -0,0 +1,84 @@
+package de.ozgcloud.alfa.kommentar;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import org.apache.commons.lang3.StringUtils;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class DateiformatCode {
+
+ static final String SONSTIGES_CODE = "100";
+
+ // MIME type -> file extension -> xdomea code
+ private static final Map<String, Map<String, String>> mimeTypesMapping = new HashMap<>();
+
+ static {
+ mimeTypesMapping.put("image/bmp", Map.of("bmp", "001"));
+ mimeTypesMapping.put("text/csv", Map.of("csv", "002"));
+ mimeTypesMapping.put("application/msword", Map.of("doc", "003", "dot", "032"));
+ mimeTypesMapping.put("message/rfc822", Map.of("eml", "006"));
+ mimeTypesMapping.put("text/html", Map.of("htm", "007", "html", "008"));
+ mimeTypesMapping.put("image/jpeg", Map.of("jpe", "009", "jpeg", "010", "jpg", "011"));
+ mimeTypesMapping.put("application/vnd.ms-outlook", Map.of("msg", "012"));
+ mimeTypesMapping.put("application/vnd.oasis.opendocument.presentation", Map.of("odp", "013"));
+ mimeTypesMapping.put("application/vnd.oasis.opendocument.spreadsheet", Map.of("ods", "014"));
+ mimeTypesMapping.put("application/vnd.oasis.opendocument.text", Map.of("odt", "015"));
+ mimeTypesMapping.put("application/vnd.oasis.opendocument.presentation-template", Map.of("otp", "016"));
+ mimeTypesMapping.put("application/vnd.oasis.opendocument.spreadsheet-template", Map.of("ots", "017"));
+ mimeTypesMapping.put("application/pdf", Map.of("pdf", "018"));
+ mimeTypesMapping.put("image/png", Map.of("png", "019"));
+ mimeTypesMapping.put("application/vnd.ms-powerpoint", Map.of("ppt", "020", "pot", "033"));
+ mimeTypesMapping.put("application/postscript", Map.of("ps", "021"));
+ mimeTypesMapping.put("application/rtf", Map.of("rtf", "022"));
+ mimeTypesMapping.put("image/tiff", Map.of("tif", "023", "tiff", "024"));
+ mimeTypesMapping.put("application/vnd.ms-works", Map.of("wps", "025"));
+ mimeTypesMapping.put("application/vnd.ms-excel", Map.of("xlc", "026", "xlm", "027", "xls", "028", "xlw", "029", "xlt", "034"));
+ mimeTypesMapping.put("application/xml", Map.of("xml", "030", "xsd", "031"));
+ mimeTypesMapping.put("application/vnd.openxmlformats-officedocument.wordprocessingml.document", Map.of("docx", "035"));
+ mimeTypesMapping.put("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", Map.of("xlsx", "036"));
+ mimeTypesMapping.put("application/vnd.openxmlformats-officedocument.presentationml.presentation", Map.of("pptx", "037"));
+ mimeTypesMapping.put("application/vnd.openxmlformats-officedocument.wordprocessingml.template", Map.of("dotx", "038"));
+ mimeTypesMapping.put("application/vnd.openxmlformats-officedocument.spreadsheetml.template", Map.of("xltx", "039"));
+ mimeTypesMapping.put("application/vnd.openxmlformats-officedocument.presentationml.template", Map.of("potx", "040"));
+ mimeTypesMapping.put("application/xml-dtd", Map.of("dtd", "041"));
+ mimeTypesMapping.put("application/vnd.ms-project", Map.of("mpp", "042"));
+ mimeTypesMapping.put("application/vnd.oasis.opendocument.text-template", Map.of("ott", "043"));
+ mimeTypesMapping.put("text/plain", Map.of("txt", "045"));
+ mimeTypesMapping.put("application/x-pkcs7-certificates", Map.of("p7b", "046"));
+ mimeTypesMapping.put("application/pkcs7-mime", Map.of("p7c", "047", "p7m", "048"));
+ mimeTypesMapping.put("application/pkcs7-signature", Map.of("p7s", "049"));
+ mimeTypesMapping.put("application/vnd.etsi.asic-s+zip", Map.of("asics", "050"));
+ mimeTypesMapping.put("application/scvp-cv-response", Map.of("scs", "051"));
+ }
+
+ public static String getXdomeaCode(String mimeType, String extension) {
+ var fileExtensionToCodeMapping = getFileExtensionToCodeMapping(mimeType);
+ if (hasSingleExtensionMapping(fileExtensionToCodeMapping)) {
+ return getCodeOrDefault(fileExtensionToCodeMapping);
+ }
+ return getCodeForExtensionOrDefault(extension, fileExtensionToCodeMapping);
+ }
+
+ private static Map<String, String> getFileExtensionToCodeMapping(String mimeType) {
+ return mimeTypesMapping.getOrDefault(Objects.requireNonNullElse(mimeType, StringUtils.EMPTY), Collections.emptyMap());
+ }
+
+ private static boolean hasSingleExtensionMapping(Map<String, String> fileExtensionToCodeMapping) {
+ return fileExtensionToCodeMapping.entrySet().size() == 1;
+ }
+
+ private static String getCodeOrDefault(Map<String, String> fileExtensionToCodeMapping) {
+ return fileExtensionToCodeMapping.values().stream().findFirst().orElse(SONSTIGES_CODE);
+ }
+
+ private static String getCodeForExtensionOrDefault(String extension, Map<String, String> fileExtensionToCodeMapping) {
+ return fileExtensionToCodeMapping.getOrDefault(Objects.requireNonNullElse(extension, StringUtils.EMPTY), SONSTIGES_CODE);
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e3fea0fdc91ea49cf2b4d3efd1386c94b460952
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilder.java
@@ -0,0 +1,96 @@
+package de.ozgcloud.alfa.kommentar;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.commons.io.FilenameUtils;
+import org.apache.commons.lang3.StringUtils;
+
+import de.ozgcloud.alfa.common.PrimaerdokumentTypeBuilder;
+import de.ozgcloud.alfa.common.UUIDConverter;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.xoev.xdomea.AnlageDokumentType;
+import de.xoev.xdomea.DateiformatCodeType;
+import de.xoev.xdomea.DokumentType;
+import de.xoev.xdomea.FormatType;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.VersionType;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+class DokumentTypeBuilder {
+
+ static final String VERSION_NUMMER = "1";
+ static final String TYP = "Notiz";
+ static final String DATEI_FORMAT_LIST_URI = "urn:xoev-de:xdomea:codeliste:dateiformat";
+
+ private Kommentar kommentar;
+ private List<OzgFile> kommentarAttachments = Collections.emptyList();
+
+ public static DokumentTypeBuilder builder() {
+ return new DokumentTypeBuilder();
+ }
+
+ public DokumentTypeBuilder withKommentar(Kommentar kommentar) {
+ this.kommentar = kommentar;
+ return this;
+ }
+
+ public DokumentTypeBuilder withKommentarAttachments(List<OzgFile> kommentarAttachments) {
+ this.kommentarAttachments = kommentarAttachments;
+ return this;
+ }
+
+ public DokumentType build() {
+ var dokumentType = new DokumentType();
+ dokumentType.setIdentifikation(createKommentarIdentifikation());
+ dokumentType.setTyp(TYP);
+ kommentarAttachments.stream().map(this::createAnlage).forEach(dokumentType.getAnlage()::add);
+ return dokumentType;
+ }
+
+ IdentifikationObjektType createKommentarIdentifikation() {
+ var identifikation = new IdentifikationObjektType();
+ identifikation.setID(UUIDConverter.fromObjectId(kommentar.getId()));
+ return identifikation;
+ }
+
+ AnlageDokumentType createAnlage(OzgFile ozgFile) {
+ var anlage = new AnlageDokumentType();
+ anlage.setIdentifikation(createKommentarAttachmentIdentifikation(ozgFile));
+ anlage.getVersion().add(createVersionType(ozgFile));
+ return anlage;
+ }
+
+ IdentifikationObjektType createKommentarAttachmentIdentifikation(OzgFile attachment) {
+ var identifikation = new IdentifikationObjektType();
+ identifikation.setID(UUIDConverter.fromObjectId(attachment.getId().toString()));
+ return identifikation;
+ }
+
+ VersionType createVersionType(OzgFile ozgFile) {
+ var versionType = new VersionType();
+ versionType.setNummer(VERSION_NUMMER);
+ versionType.getFormat().add(createFormatType(ozgFile));
+ return versionType;
+ }
+
+ FormatType createFormatType(OzgFile ozgFile) {
+ var formatType = new FormatType();
+ formatType.setName(createDateiformatCodeType(ozgFile));
+ formatType.setVersion(StringUtils.EMPTY);
+ formatType.setPrimaerdokument(PrimaerdokumentTypeBuilder.builder()
+ .withOzgFile(ozgFile)
+ .build());
+ return formatType;
+ }
+
+ DateiformatCodeType createDateiformatCodeType(OzgFile ozgFile) {
+ var dateiformatCode = new DateiformatCodeType();
+ dateiformatCode.setCode(DateiformatCode.getXdomeaCode(ozgFile.getContentType(), FilenameUtils.getExtension(ozgFile.getName())));
+ dateiformatCode.setListURI(DATEI_FORMAT_LIST_URI);
+ return dateiformatCode;
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/ExportKommentarService.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/ExportKommentarService.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4729eaee8a153c3d472af9d4c00e56d88e30a10
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/ExportKommentarService.java
@@ -0,0 +1,27 @@
+package de.ozgcloud.alfa.kommentar;
+
+import java.util.stream.Stream;
+
+import org.springframework.stereotype.Service;
+
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.DokumentType;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Service
+public class ExportKommentarService {
+
+ private final KommentarService kommentarService;
+ private final BinaryFileService binaryFileService;
+
+ public Stream<DokumentType> createDokumentTypes(VorgangWithEingang vorgang) {
+ return kommentarService.findByVorgangId(vorgang.getId())
+ .map(kommentar -> DokumentTypeBuilder.builder()
+ .withKommentarAttachments(binaryFileService.getFiles(kommentar.getAttachments()).toList())
+ .withKommentar(kommentar)
+ .build());
+ }
+
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateiformatCodeTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateiformatCodeTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..299391ad928a9c7bacba0101e474592f55874c8a
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateiformatCodeTypeTestFactory.java
@@ -0,0 +1,11 @@
+package de.ozgcloud.alfa.common;
+
+import de.xoev.xdomea.DateiformatCodeType;
+
+public class DateiformatCodeTypeTestFactory {
+
+ public static DateiformatCodeType create() {
+ return new DateiformatCodeType();
+ }
+
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/FormTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/FormatTypeTestFactory.java
similarity index 78%
rename from alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/FormTypeTestFactory.java
rename to alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/FormatTypeTestFactory.java
index da7e15a4d08aa00085d957dc7b4b24a80568014f..ea0393aea974a6b7f00fad540c30e630d9e6e520 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/FormTypeTestFactory.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/FormatTypeTestFactory.java
@@ -2,7 +2,7 @@ package de.ozgcloud.alfa.common;
import de.xoev.xdomea.FormatType;
-public class FormTypeTestFactory {
+public class FormatTypeTestFactory {
public static FormatType create() {
return new FormatType();
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilderTest.java
index 51447d711d95bd24c947899d9339d36b03e548c1..7aaed847f38d88d37475f545f0bae44fda467aaf 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilderTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilderTest.java
@@ -92,12 +92,14 @@ class PrimaerdokumentTypeBuilderTest {
void shouldNotHaveDatumUhrzeit() {
var primaerdokumentType = builder.build();
- assertThat(primaerdokumentType.getDatumUhrzeit()).isNull();
+ assertThat(primaerdokumentType.getDatumUhrzeit().getYear()).isNegative();
}
@Test
void shouldThrowIllegalgStateException() {
- assertThatThrownBy(() -> builder.withOzgFile(null).build()).isInstanceOf(IllegalStateException.class);
+ builder.withOzgFile(null);
+
+ assertThatThrownBy(builder::build).isInstanceOf(IllegalStateException.class);
}
}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/VersionTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/VersionTypeTestFactory.java
index 8baf8b26e6691208b3c292c1189a4d04a34bab87..f2fcd270fad8435d51170bd8963b3883baf7aa27 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/VersionTypeTestFactory.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/VersionTypeTestFactory.java
@@ -6,7 +6,7 @@ public class VersionTypeTestFactory {
public static VersionType create() {
var versionType = new VersionType();
- versionType.getFormat().add(FormTypeTestFactory.create());
+ versionType.getFormat().add(FormatTypeTestFactory.create());
return versionType;
}
}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceITCase.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceITCase.java
index de5eb64ef80434dd12d08b42bae0f0e8008c9bb9..5707c63e0fcb2168c4b5792be7ec6de3c40482ad 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceITCase.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceITCase.java
@@ -14,12 +14,14 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.boot.test.mock.mockito.SpyBean;
import de.ozgcloud.alfa.common.binaryfile.FileId;
import de.ozgcloud.alfa.common.file.OzgFile;
import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
import de.ozgcloud.alfa.file.ExportFileService;
+import de.ozgcloud.alfa.kommentar.ExportKommentarService;
import de.ozgcloud.alfa.vorgang.ExportVorgangService;
import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
@@ -33,6 +35,8 @@ class ExportServiceITCase {
private ExportFileService exportFileService;
@SpyBean
private ExportVorgangService exportVorgangService;
+ @MockBean
+ private ExportKommentarService exportKommentarService;
@Autowired
private ExportService exportService;
@@ -47,6 +51,7 @@ class ExportServiceITCase {
doReturn(Stream.of(createOzgFile())).when(exportFileService).getRepresentations(vorgang);
doReturn(Stream.of(createOzgFile())).when(exportFileService).getAttachments(vorgang);
doNothing().when(exportFileService).writeOzgFile(any(), any());
+ when(exportKommentarService.createDokumentTypes(vorgang)).thenReturn(Stream.empty());
}
@Test
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceTest.java
index d1e6e41a4bc5354cd9891f94900baef47c35d54d..ff7fb7bdd34403759f8ca946d467d3b59ba1654e 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceTest.java
@@ -31,6 +31,7 @@ import de.ozgcloud.alfa.common.TestUtils;
import de.ozgcloud.alfa.common.file.OzgFile;
import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
import de.ozgcloud.alfa.file.ExportFileService;
+import de.ozgcloud.alfa.kommentar.ExportKommentarService;
import de.ozgcloud.alfa.vorgang.EingangHeaderTestFactory;
import de.ozgcloud.alfa.vorgang.EingangTestFactory;
import de.ozgcloud.alfa.vorgang.ExportVorgangService;
@@ -57,9 +58,10 @@ class ExportServiceTest {
@Mock
private ExportFileService exportFileService;
-
@Mock
private ExportVorgangService exportVorgangService;
+ @Mock
+ private ExportKommentarService exportKommentarService;
@DisplayName("Write exportToXdomea")
@Nested
@@ -121,6 +123,7 @@ class ExportServiceTest {
private final List<OzgFile> attachments = List.of(OzgFileTestFactory.create());
private final List<DokumentType> representationsDokumentTypes = List.of(DokumentTypeTestFactory.create());
private final List<DokumentType> attachmentsDokumentTypes = List.of(DokumentTypeTestFactory.create());
+ private final List<DokumentType> kommentareDokumentTypes = List.of(DokumentTypeTestFactory.create());
@Mock
private XdomeaNachrichtBuilder xdomeaNachrichtBuilder;
@@ -150,6 +153,7 @@ class ExportServiceTest {
when(xdomeaNachrichtBuilder.withAktenzeichen(akteType)).thenReturn(xdomeaNachrichtBuilder);
when(xdomeaNachrichtBuilder.withRepresentations(representationsDokumentTypes)).thenReturn(xdomeaNachrichtBuilder);
when(xdomeaNachrichtBuilder.withAttachments(attachmentsDokumentTypes)).thenReturn(xdomeaNachrichtBuilder);
+ when(xdomeaNachrichtBuilder.withKommentare(kommentareDokumentTypes)).thenReturn(xdomeaNachrichtBuilder);
xdomeaNachrichtBuilderMockedStatic.when(XdomeaNachrichtBuilder::builder).thenReturn(xdomeaNachrichtBuilder);
when(xdomeaNachrichtBuilder.build()).thenReturn(abgabe);
}
@@ -163,6 +167,7 @@ class ExportServiceTest {
.thenReturn(stream));
mockStreamToList(attachmentsDokumentTypes, stream ->
when(exportFileService.createDokumentTypes(attachments, EingangHeaderTestFactory.FORM_ENGINE_NAME)).thenReturn(stream));
+ mockStreamToList(kommentareDokumentTypes, stream -> when(exportKommentarService.createDokumentTypes(vorgang)).thenReturn(stream));
}
@AfterEach
@@ -297,7 +302,13 @@ class ExportServiceTest {
.hasSize(2)
.containsAll(representations)
.containsAll(attachments);
+ }
+
+ @Test
+ void shouldExportKommentare() {
+ callService();
+ verify(exportKommentarService).createDokumentTypes(vorgang);
}
private ExportData callService() {
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilderTest.java
index e68698cd40f973d31472f1388373e50c531a3b52..9a71c4d90605dc701a3d044fcaa954e7022abefb 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilderTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilderTest.java
@@ -17,6 +17,7 @@ class XdomeaNachrichtBuilderTest {
private final VorgangType vorgangType = VorgangTypeTestFactory.create();
private final List<DokumentType> representations = List.of(DokumentTypeTestFactory.create(), DokumentTypeTestFactory.create());
private final List<DokumentType> attachments = List.of(DokumentTypeTestFactory.create(), DokumentTypeTestFactory.create());
+ private final List<DokumentType> kommentare = List.of(DokumentTypeTestFactory.create(), DokumentTypeTestFactory.create());
private final XdomeaNachrichtBuilder builder = XdomeaNachrichtBuilder.builder().withVorgang(vorgangType);
@Test
@@ -53,4 +54,11 @@ class XdomeaNachrichtBuilderTest {
assertThat(abgabeType.getSchriftgutobjekt().get(0).getVorgang().getDokument()).isEqualTo(attachments);
}
+
+ @Test
+ void shouldAddKommentare() {
+ var abgabeType = builder.withKommentare(kommentare).build();
+
+ assertThat(abgabeType.getSchriftgutobjekt().get(0).getVorgang().getDokument()).isEqualTo(kommentare);
+ }
}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateiformatCodeTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/DateiformatCodeTest.java
similarity index 96%
rename from alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateiformatCodeTest.java
rename to alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/DateiformatCodeTest.java
index 1046b0606bee88d99e2d7856ae8df31aa37534d1..2bc5492714bb1ee3a0e19d9e237624ec16d382c8 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateiformatCodeTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/DateiformatCodeTest.java
@@ -1,4 +1,4 @@
-package de.ozgcloud.alfa.common;
+package de.ozgcloud.alfa.file;
import static org.assertj.core.api.Assertions.*;
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/DokumentTypeBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/DokumentTypeBuilderTest.java
index 332cfc515421594b8613b79ce54b31effcf7ec04..1a7988fe6f09396cbbeb0068ff87ca5455b3a0f2 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/DokumentTypeBuilderTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/DokumentTypeBuilderTest.java
@@ -11,9 +11,9 @@ import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockedStatic;
+import org.mockito.Spy;
-import de.ozgcloud.alfa.common.DateiformatCode;
-import de.ozgcloud.alfa.common.FormTypeTestFactory;
+import de.ozgcloud.alfa.common.FormatTypeTestFactory;
import de.ozgcloud.alfa.common.PrimaerdokumentTypeBuilder;
import de.ozgcloud.alfa.common.PrimaerdokumentTypeTestFactory;
import de.ozgcloud.alfa.common.TestUtils;
@@ -35,10 +35,11 @@ class DokumentTypeBuilderTest {
private static final String FORM_ENGINE_NAME = "DUMMY_NAME";
private final OzgFile ozgFile = OzgFileTestFactory.create();
- private final DokumentTypeBuilder builder = spy(DokumentTypeBuilder.builder()
+ @Spy
+ private final DokumentTypeBuilder builder = DokumentTypeBuilder.builder()
.withOzgFile(ozgFile)
.withFormEngineName(FORM_ENGINE_NAME)
- .withOrdinalNumber(DOKUMENT_ORDINAL_NUMBER));
+ .withOrdinalNumber(DOKUMENT_ORDINAL_NUMBER);
private MockedStatic<UUIDConverter> uuidConverter;
@@ -220,7 +221,7 @@ class DokumentTypeBuilderTest {
@Nested
class CreateVersionType {
- private final FormatType formatType = FormTypeTestFactory.create();
+ private final FormatType formatType = FormatTypeTestFactory.create();
@BeforeEach
void setUp() {
@@ -297,7 +298,7 @@ class DokumentTypeBuilderTest {
void shouldReturnBuildPrimaerdokument() {
var primaerdokument = builder.createPrimaerdokument();
- assertThat(primaerdokument).isEqualTo(primaerdokument);
+ assertThat(primaerdokument).isEqualTo(primaerdokumentType);
}
}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/AnlageDokumentTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/AnlageDokumentTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..96b3a7117bdd5383ff7faade939ba52c5c958f8c
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/AnlageDokumentTypeTestFactory.java
@@ -0,0 +1,11 @@
+package de.ozgcloud.alfa.kommentar;
+
+import de.xoev.xdomea.AnlageDokumentType;
+
+class AnlageDokumentTypeTestFactory {
+
+ public static AnlageDokumentType create() {
+ return new AnlageDokumentType();
+ }
+
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/DateiformatCodeTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/DateiformatCodeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0eabf7f3eae85bd16d2ad5af6dce9e2f01e012e7
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/DateiformatCodeTest.java
@@ -0,0 +1,61 @@
+package de.ozgcloud.alfa.kommentar;
+
+import static org.assertj.core.api.Assertions.*;
+
+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;
+
+class DateiformatCodeTest {
+
+ @Nested
+ class TestGetXdomeaCode {
+
+ @Test
+ void shouldReturnCode() {
+ var code = DateiformatCode.getXdomeaCode("application/pdf", "pdf");
+
+ assertThat(code).isEqualTo("018");
+ }
+
+ @Test
+ void shouldReturnSonstiges() {
+ var code = DateiformatCode.getXdomeaCode("abc", "abc");
+
+ assertThat(code).isEqualTo(DateiformatCode.SONSTIGES_CODE);
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldReturnCodeOnSingleFileExtensionMapping(String extension) {
+ var code = DateiformatCode.getXdomeaCode("application/pdf", extension);
+
+ assertThat(code).isEqualTo("018");
+ }
+
+ @Test
+ void shouldReturnCodeOnMultipleFileExtensionMapping() {
+ var code = DateiformatCode.getXdomeaCode("image/jpeg", "jpg");
+
+ assertThat(code).isEqualTo("011");
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldReturnSonstigesOnMultipleFileExtensionMapping(String extension) {
+ var code = DateiformatCode.getXdomeaCode("image/jpeg", extension);
+
+ assertThat(code).isEqualTo(DateiformatCode.SONSTIGES_CODE);
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldReturnSonstigesOnEmptyMimeType(String mimeType) {
+ var code = DateiformatCode.getXdomeaCode(mimeType, "pdf");
+
+ assertThat(code).isEqualTo(DateiformatCode.SONSTIGES_CODE);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ffdbfe13311c17991ca085411d3d45f95ffea397
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilderTest.java
@@ -0,0 +1,338 @@
+package de.ozgcloud.alfa.kommentar;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+
+import org.apache.commons.io.FilenameUtils;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.common.DateiformatCodeTypeTestFactory;
+import de.ozgcloud.alfa.common.FormatTypeTestFactory;
+import de.ozgcloud.alfa.common.PrimaerdokumentTypeBuilder;
+import de.ozgcloud.alfa.common.UUIDConverter;
+import de.ozgcloud.alfa.common.VersionTypeTestFactory;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.export.IdentifikationObjektTypeTestFactory;
+import de.xoev.xdomea.AnlageDokumentType;
+import de.xoev.xdomea.DateiformatCodeType;
+import de.xoev.xdomea.FormatType;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.VersionType;
+
+class DokumentTypeBuilderTest {
+
+ @Spy
+ private DokumentTypeBuilder builder = DokumentTypeBuilder.builder();
+
+ @Nested
+ class TestBuild {
+
+ private final IdentifikationObjektType identifikationObjektType = IdentifikationObjektTypeTestFactory.create();
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+ private final AnlageDokumentType anlageDokumentType = AnlageDokumentTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ doReturn(identifikationObjektType).when(builder).createKommentarIdentifikation();
+ }
+
+ @Test
+ void shouldCreateIdentifikation() {
+ builder.build();
+
+ verify(builder).createKommentarIdentifikation();
+ }
+
+ @Nested
+ class WithoutKommentareAttachments {
+
+ @Test
+ void shouldHaveIdentifikation() {
+ var dokumentType = builder.build();
+
+ assertThat(dokumentType.getIdentifikation()).isEqualTo(identifikationObjektType);
+ }
+
+ @Test
+ void shouldHaveTypNotiz() {
+ var dokumentType = builder.build();
+
+ assertThat(dokumentType.getTyp()).isEqualTo(DokumentTypeBuilder.TYP);
+ }
+ }
+
+ @Nested
+ class WithKommentareAttachments {
+
+ @BeforeEach
+ void setUp() {
+ doReturn(anlageDokumentType).when(builder).createAnlage(ozgFile);
+ }
+
+ @Test
+ void shouldCreateAnlagenForKommentarAttachments() {
+ builder.withKommentarAttachments(List.of(ozgFile)).build();
+
+ verify(builder).createAnlage(ozgFile);
+ }
+
+ @Test
+ void shouldHaveAnlagen() {
+ var dokumentType = builder.withKommentarAttachments(List.of(ozgFile)).build();
+
+ assertThat(dokumentType.getAnlage()).contains(anlageDokumentType);
+ }
+ }
+ }
+
+ @Nested
+ class TestCreateKommentarIdentifikation {
+
+ private MockedStatic<UUIDConverter> uuidConverterMockedStatic;
+
+ @BeforeEach
+ void setUp() {
+ uuidConverterMockedStatic = mockStatic(UUIDConverter.class);
+ uuidConverterMockedStatic.when(() -> UUIDConverter.fromObjectId(KommentarTestFactory.ID))
+ .thenReturn(IdentifikationObjektTypeTestFactory.ID);
+ }
+
+ @AfterEach
+ void tearDown() {
+ uuidConverterMockedStatic.close();
+ }
+
+ @Test
+ void shouldConvertKommentarId() {
+ builder.withKommentar(KommentarTestFactory.create()).createKommentarIdentifikation();
+
+ uuidConverterMockedStatic.verify(() -> UUIDConverter.fromObjectId(KommentarTestFactory.ID));
+ }
+
+ @Test
+ void shouldHaveId() {
+ var identifikation = builder.withKommentar(KommentarTestFactory.create()).createKommentarIdentifikation();
+
+ assertThat(identifikation.getID()).isEqualTo(IdentifikationObjektTypeTestFactory.ID);
+ }
+ }
+
+ @Nested
+ class TestCreateKommentarAttachmentIdentifikation {
+
+ private MockedStatic<UUIDConverter> uuidConverterMockedStatic;
+
+ @BeforeEach
+ void setUp() {
+ uuidConverterMockedStatic = mockStatic(UUIDConverter.class);
+ uuidConverterMockedStatic.when(() -> UUIDConverter.fromObjectId(OzgFileTestFactory.ID.toString()))
+ .thenReturn(IdentifikationObjektTypeTestFactory.ID);
+ }
+
+ @AfterEach
+ void tearDown() {
+ uuidConverterMockedStatic.close();
+ }
+
+ @Test
+ void shouldConvertOzgFileId() {
+ builder.createKommentarAttachmentIdentifikation(OzgFileTestFactory.create());
+
+ uuidConverterMockedStatic.verify(() -> UUIDConverter.fromObjectId(OzgFileTestFactory.ID.toString()));
+ }
+
+ @Test
+ void shouldHaveId() {
+ var identifikation = builder.createKommentarAttachmentIdentifikation(OzgFileTestFactory.create());
+
+ assertThat(identifikation.getID()).isEqualTo(IdentifikationObjektTypeTestFactory.ID);
+ }
+ }
+
+ @Nested
+ class TestCreateAnlage {
+
+ private final IdentifikationObjektType identifikationObjektType = IdentifikationObjektTypeTestFactory.create();
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+ private final VersionType version = VersionTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ doReturn(identifikationObjektType).when(builder).createKommentarAttachmentIdentifikation(ozgFile);
+ doReturn(version).when(builder).createVersionType(ozgFile);
+ }
+
+ @Test
+ void shouldCreateIdentifikation() {
+ builder.createAnlage(ozgFile);
+
+ verify(builder).createKommentarAttachmentIdentifikation(ozgFile);
+ }
+
+ @Test
+ void shouldHaveIdentifikation() {
+ var anlage = builder.createAnlage(ozgFile);
+
+ assertThat(anlage.getIdentifikation()).isEqualTo(identifikationObjektType);
+ }
+
+ @Test
+ void shouldCreateVersion() {
+ builder.createAnlage(ozgFile);
+
+ verify(builder).createVersionType(ozgFile);
+ }
+
+ @Test
+ void shouldHaveVersion() {
+ var anlage = builder.createAnlage(ozgFile);
+
+ assertThat(anlage.getVersion()).contains(version);
+ }
+ }
+
+ @Nested
+ class TestCreateFormatType {
+
+ private MockedStatic<PrimaerdokumentTypeBuilder> primaerdokumentTypeBuilderMockedStatic;
+ @Mock
+ private PrimaerdokumentTypeBuilder primaerdokumentTypeBuilder;
+
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+ private final DateiformatCodeType dateiformatCodeType = DateiformatCodeTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ primaerdokumentTypeBuilderMockedStatic = mockStatic(PrimaerdokumentTypeBuilder.class);
+ primaerdokumentTypeBuilderMockedStatic.when(PrimaerdokumentTypeBuilder::builder).thenReturn(primaerdokumentTypeBuilder);
+ when(primaerdokumentTypeBuilder.withOzgFile(ozgFile)).thenReturn(primaerdokumentTypeBuilder);
+ doReturn(dateiformatCodeType).when(builder).createDateiformatCodeType(ozgFile);
+ }
+
+ @AfterEach
+ void tearDown() {
+ primaerdokumentTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldBuildPrimaerdokument() {
+ builder.createFormatType(ozgFile);
+
+ verify(primaerdokumentTypeBuilder).build();
+ }
+
+ @Test
+ void shouldSetOzgFile() {
+ builder.createFormatType(ozgFile);
+
+ verify(primaerdokumentTypeBuilder).withOzgFile(ozgFile);
+ }
+
+ @Test
+ void shouldSetDatumUhrzeit() {
+ var formatType = builder.createFormatType(ozgFile);
+
+ assertThat(formatType.getVersion()).isEmpty();
+ }
+
+ @Test
+ void shouldCreateDateiformatCode() {
+ builder.createFormatType(ozgFile);
+
+ verify(builder).createDateiformatCodeType(ozgFile);
+ }
+
+ @Test
+ void shouldHaveName() {
+ var formatType = builder.createFormatType(ozgFile);
+
+ assertThat(formatType.getName()).isEqualTo(dateiformatCodeType);
+ }
+ }
+
+ @Nested
+ class TestCreateVersionType {
+
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+ private final FormatType formatType = FormatTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ doReturn(formatType).when(builder).createFormatType(ozgFile);
+ }
+
+ @Test
+ void shouldHaveNummer() {
+ var version = builder.createVersionType(ozgFile);
+
+ assertThat(version.getNummer()).isEqualTo(DokumentTypeBuilder.VERSION_NUMMER);
+ }
+
+ @Test
+ void shouldCreateFormaType() {
+ builder.createVersionType(ozgFile);
+
+ verify(builder).createFormatType(ozgFile);
+ }
+
+ @Test
+ void shouldHaveFormatType() {
+ var version = builder.createVersionType(ozgFile);
+
+ assertThat(version.getFormat()).contains(formatType);
+ }
+ }
+
+ @Nested
+ class TestCreateDateiformatCodeType {
+
+ private static final String CODE = "111";
+
+ private MockedStatic<DateiformatCode> dateiformatCodeMockedStatic;
+
+ @BeforeEach
+ void setUp() {
+ dateiformatCodeMockedStatic = mockStatic(DateiformatCode.class);
+ dateiformatCodeMockedStatic.when(
+ () -> DateiformatCode.getXdomeaCode(OzgFileTestFactory.CONTENT_TYPE, FilenameUtils.getExtension(OzgFileTestFactory.NAME)))
+ .thenReturn(CODE);
+ }
+
+ @AfterEach
+ void tearDown() {
+ dateiformatCodeMockedStatic.close();
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var dateiformatCode = builder.createDateiformatCodeType(OzgFileTestFactory.create());
+
+ assertThat(dateiformatCode.getListURI()).isEqualTo(DokumentTypeBuilder.DATEI_FORMAT_LIST_URI);
+ }
+
+ @Test
+ void shouldGetXdomeaCode() {
+ builder.createDateiformatCodeType(OzgFileTestFactory.create());
+
+ dateiformatCodeMockedStatic.verify(
+ () -> DateiformatCode.getXdomeaCode(OzgFileTestFactory.CONTENT_TYPE, FilenameUtils.getExtension(OzgFileTestFactory.NAME)));
+ }
+
+ @Test
+ void shouldHaveCode() {
+ var dateiformatCode = builder.createDateiformatCodeType(OzgFileTestFactory.create());
+
+ assertThat(dateiformatCode.getCode()).isEqualTo(CODE);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/ExportKommentarServiceTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/ExportKommentarServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..529d4d332ff9fa266e5d3022b3d8fc53b8191e2f
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/ExportKommentarServiceTest.java
@@ -0,0 +1,101 @@
+package de.ozgcloud.alfa.kommentar;
+
+import static de.ozgcloud.alfa.common.TestUtils.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.export.DokumentTypeTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.DokumentType;
+
+class ExportKommentarServiceTest {
+
+ @InjectMocks
+ private ExportKommentarService service;
+
+ @Mock
+ private KommentarService kommentarService;
+ @Mock
+ private BinaryFileService binaryFileService;
+
+ @Nested
+ class TestCreateDokumentTypes {
+
+ private MockedStatic<DokumentTypeBuilder> dokumentTypeBuilderMockedStatic;
+
+ private final Kommentar kommentar = KommentarTestFactory.create();
+ private final List<OzgFile> ozgFiles = List.of(OzgFileTestFactory.create());
+ private final DokumentType dokumentType = DokumentTypeTestFactory.create();
+
+ @Mock
+ private DokumentTypeBuilder dokumentTypeBuilder;
+
+ @BeforeEach
+ void setUp() {
+ when(kommentarService.findByVorgangId(VorgangHeaderTestFactory.ID)).thenReturn(Stream.of(kommentar));
+
+ dokumentTypeBuilderMockedStatic = mockStatic(DokumentTypeBuilder.class);
+ dokumentTypeBuilderMockedStatic.when(DokumentTypeBuilder::builder).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.withKommentarAttachments(ozgFiles)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.withKommentar(kommentar)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.build()).thenReturn(dokumentType);
+
+ mockStreamToList(ozgFiles, stream -> when(binaryFileService.getFiles(KommentarTestFactory.ATTACHMENTS)).thenReturn(stream));
+ }
+
+ @AfterEach
+ void tearDown() {
+ dokumentTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldLoadKommentare() {
+ service.createDokumentTypes(VorgangWithEingangTestFactory.create()).toList();
+
+ verify(kommentarService).findByVorgangId(VorgangHeaderTestFactory.ID);
+ }
+
+ @Test
+ void shouldLoadOzgFilesForKommentareAttachments() {
+ service.createDokumentTypes(VorgangWithEingangTestFactory.create()).toList();
+
+ verify(binaryFileService).getFiles(KommentarTestFactory.ATTACHMENTS);
+ }
+
+ @Test
+ void shouldBuildDokumentType() {
+ service.createDokumentTypes(VorgangWithEingangTestFactory.create()).toList();
+
+ verify(dokumentTypeBuilder).build();
+ }
+
+ @Test
+ void shouldSetOzgFile() {
+ service.createDokumentTypes(VorgangWithEingangTestFactory.create()).toList();
+
+ verify(dokumentTypeBuilder).withKommentarAttachments(ozgFiles);
+ }
+
+ @Test
+ void shouldSetKommentar() {
+ service.createDokumentTypes(VorgangWithEingangTestFactory.create()).toList();
+
+ verify(dokumentTypeBuilder).withKommentar(kommentar);
+ }
+ }
+
+}
\ No newline at end of file