diff --git a/alfa-service/src/main/java/de/ozgcloud/alfa/vorgang/EingangHeader.java b/alfa-service/src/main/java/de/ozgcloud/alfa/vorgang/EingangHeader.java
index 9b701e231c2108190bd93c7ac969ab7a80cc89e0..2a52a44273b9131774cdeab95bf968d1948c8678 100644
--- a/alfa-service/src/main/java/de/ozgcloud/alfa/vorgang/EingangHeader.java
+++ b/alfa-service/src/main/java/de/ozgcloud/alfa/vorgang/EingangHeader.java
@@ -41,4 +41,5 @@ public class EingangHeader {
private String customerId;
private String client;
private String clientId;
+ private String formEngineName;
}
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/vorgang/EingangHeaderMapperTest.java b/alfa-service/src/test/java/de/ozgcloud/alfa/vorgang/EingangHeaderMapperTest.java
index a046aa542c3610d65ecd1cf7b27121e5f078e5d6..343dcaf5ce9b50d92c72d67721a6d465aae719ee 100644
--- a/alfa-service/src/test/java/de/ozgcloud/alfa/vorgang/EingangHeaderMapperTest.java
+++ b/alfa-service/src/test/java/de/ozgcloud/alfa/vorgang/EingangHeaderMapperTest.java
@@ -50,6 +50,13 @@ class EingangHeaderMapperTest {
assertThat(eingang.getRequestId()).isEqualTo(GrpcEingangHeaderTestFactory.REQUEST_ID);
}
+ @Test
+ void shouldMapFormEngineName() {
+ var eingang = callMapper();
+
+ assertThat(eingang.getFormEngineName()).isEqualTo(GrpcEingangHeaderTestFactory.FORM_ENGINE_NAME);
+ }
+
private EingangHeader callMapper() {
return mapper.toEingangHeader(GrpcEingangHeaderTestFactory.create());
}
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/vorgang/EingangHeaderTestFactory.java b/alfa-service/src/test/java/de/ozgcloud/alfa/vorgang/EingangHeaderTestFactory.java
index 0ddbf2ebebda91c5f0ecc570d4ebf90084c953ba..cb7cde735df4f3d45b8615fb6dc17dfc53732ee2 100644
--- a/alfa-service/src/test/java/de/ozgcloud/alfa/vorgang/EingangHeaderTestFactory.java
+++ b/alfa-service/src/test/java/de/ozgcloud/alfa/vorgang/EingangHeaderTestFactory.java
@@ -29,12 +29,13 @@ public class EingangHeaderTestFactory {
public static final String CREATED_AT_STR = "2020-01-10T10:30:00Z";
public static final ZonedDateTime CREATED_AT = ZonedDateTime.parse(CREATED_AT_STR);
+ public static final String FORM_ENGINE_NAME = "AFM";
public static EingangHeader create() {
return createBuilder().build();
}
public static EingangHeader.EingangHeaderBuilder createBuilder() {
- return EingangHeader.builder().createdAt(CREATED_AT);
+ return EingangHeader.builder().createdAt(CREATED_AT).formEngineName(FORM_ENGINE_NAME);
}
}
\ No newline at end of file
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/vorgang/GrpcEingangHeaderTestFactory.java b/alfa-service/src/test/java/de/ozgcloud/alfa/vorgang/GrpcEingangHeaderTestFactory.java
index ffb62f0b4e0b5465c7c45bf8dc1223d297e03386..3f19726f0c68a31b94efe606aff29d9d08c6bad6 100644
--- a/alfa-service/src/test/java/de/ozgcloud/alfa/vorgang/GrpcEingangHeaderTestFactory.java
+++ b/alfa-service/src/test/java/de/ozgcloud/alfa/vorgang/GrpcEingangHeaderTestFactory.java
@@ -42,6 +42,7 @@ public class GrpcEingangHeaderTestFactory {
private final static String CUSTOMER_ID = UUID.randomUUID().toString();
private final static String CLIENT = LoremIpsum.getInstance().getName();
private final static String CLIENT_ID = UUID.randomUUID().toString();
+ public final static String FORM_ENGINE_NAME = "AFM";
public static GrpcEingangHeader create() {
return createBuilder().build();
@@ -57,6 +58,7 @@ public class GrpcEingangHeaderTestFactory {
.setCustomer(CUSTOMER)
.setCustomerId(CUSTOMER_ID)
.setClient(CLIENT)
- .setClientId(CLIENT_ID);
+ .setClientId(CLIENT_ID)
+ .setFormEngineName(FORM_ENGINE_NAME);
}
}
\ No newline at end of file
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401Creator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401Creator.java
new file mode 100644
index 0000000000000000000000000000000000000000..e47a7eb2ac47d2380c2b07484122c89e9ac6b86e
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401Creator.java
@@ -0,0 +1,26 @@
+package de.ozgcloud.alfa.export;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.AbgabeAbgabe0401;
+
+@Component
+class AbgabeAbgabe0401Creator {
+
+ @Autowired
+ private SchriftgutobjektCreator schriftgutobjektCreator;
+
+ @Autowired
+ private AnwendungsspezifischeErweiterungMapper anwendungsspezifischeErweiterungMapper;
+
+ public AbgabeAbgabe0401 createAbgabe(VorgangWithEingang vorgang) {
+ var erweiterung = anwendungsspezifischeErweiterungMapper.map(vorgang);
+
+ var abgabe = new AbgabeAbgabe0401();
+ abgabe.getSchriftgutobjekt().add(schriftgutobjektCreator.createSchriftgutobjekt(vorgang, erweiterung));
+ return abgabe;
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/DateiformatCode.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/DateiformatCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..c7f4b8f86717fb9646e9a32f8b1b28318297c278
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/DateiformatCode.java
@@ -0,0 +1,24 @@
+package de.ozgcloud.alfa.export;
+
+import de.xoev.xdomea.DateiformatCodeType;
+
+enum DateiformatCode {
+ PDF("vCBzR", "018");
+
+ static final String LIST_URI = "urn:xoev-de:xdomea:codeliste:dateiformat";
+ final String listVersionID;
+ final String code;
+
+ DateiformatCode(String listVersionID, String code) {
+ this.listVersionID = listVersionID;
+ this.code = code;
+ }
+
+ public DateiformatCodeType createDateiformatCodeType() {
+ var dateiformatCode = new DateiformatCodeType();
+ dateiformatCode.setCode(code);
+ dateiformatCode.setListURI(LIST_URI);
+ dateiformatCode.setListVersionID(listVersionID);
+ return dateiformatCode;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/DokumentTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/DokumentTypeCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..240735b34501fe979d02f97e8b45a7f848faf3db
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/DokumentTypeCreator.java
@@ -0,0 +1,70 @@
+package de.ozgcloud.alfa.export;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.DokumentType;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.MediumCodeType;
+
+@Component
+class DokumentTypeCreator {
+
+ static final String ALLGEMEINE_METADATEN_MEDIUM_CODE = "001";
+
+ @Autowired
+ private ExportFileService exportFileService;
+
+ @Autowired
+ private UUIDConverter uuidConverter;
+
+ @Autowired
+ private VersionTypeCreator versionTypeCreator;
+
+ public Stream<DokumentType> createDokumentTypen(VorgangWithEingang vorgang) {
+ var ozgFiles = exportFileService.getAllPdfs(vorgang.getEingang().getId()).toList();
+ List<DokumentType> dokumenten = new ArrayList<>(ozgFiles.size());
+ for (var i = 0; i < ozgFiles.size(); i++) {
+ dokumenten.add(createDokumentType(i + 1, vorgang, ozgFiles.get(i)));
+ }
+ return dokumenten.stream();
+ }
+
+ DokumentType createDokumentType(int dokumentOrdinalNumber, VorgangWithEingang vorgang, OzgFile ozgFile) {
+ var dokument = new DokumentType();
+ dokument.setIdentifikation(createIdentifikation(dokumentOrdinalNumber, ozgFile.getId().toString()));
+ dokument.setAllgemeineMetadaten(createAllgemeineMetadaten(ozgFile));
+ dokument.getVersion().add(versionTypeCreator.createVersionType(vorgang, ozgFile));
+ return dokument;
+ }
+
+ IdentifikationObjektType createIdentifikation(int dokumentOrdinalNumber, String fileId) {
+ var identifikation = new IdentifikationObjektType();
+ identifikation.setID(uuidConverter.fromObjectId(fileId));
+ identifikation.setNummerImUebergeordnetenContainer(Long.valueOf(dokumentOrdinalNumber));
+ return identifikation;
+ }
+
+ AllgemeineMetadatenType createAllgemeineMetadaten(OzgFile ozgFile) {
+ var allgemeineMetadaten = new AllgemeineMetadatenType();
+ allgemeineMetadaten.setBetreff(ozgFile.getName());
+ allgemeineMetadaten.setKennzeichen(StringUtils.EMPTY);
+ allgemeineMetadaten.setBemerkung(StringUtils.EMPTY);
+ allgemeineMetadaten.setMedium(createMediumCode());
+ return allgemeineMetadaten;
+ }
+
+ private MediumCodeType createMediumCode() {
+ var mediumCode = new MediumCodeType();
+ mediumCode.setCode(ALLGEMEINE_METADATEN_MEDIUM_CODE);
+ return mediumCode;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportFileService.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportFileService.java
new file mode 100644
index 0000000000000000000000000000000000000000..163ae563403e615c1f3c8eaba1e493fad643101f
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportFileService.java
@@ -0,0 +1,26 @@
+package de.ozgcloud.alfa.export;
+
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Service;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileService;
+
+@Service
+class ExportFileService {
+
+ private static final Predicate<OzgFile> IS_PDF_FILE = file -> file.getContentType().equals(MediaType.APPLICATION_PDF_VALUE);
+
+ @Autowired
+ private OzgFileService ozgFileService;
+
+ public Stream<OzgFile> getAllPdfs(String eingangId) {
+ var representations = ozgFileService.getRepresentationsByEingang(eingangId);
+ var attachments = ozgFileService.getAttachmentsByEingang(eingangId);
+ return Stream.concat(representations, attachments).filter(IS_PDF_FILE);
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/FormatTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/FormatTypeCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..fa96295d753da3780a9f9f7ed5f6639309ac5034
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/FormatTypeCreator.java
@@ -0,0 +1,25 @@
+package de.ozgcloud.alfa.export;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.FormatType;
+
+@Component
+class FormatTypeCreator {
+
+ @Autowired
+ private PrimaerdokumentTypeCreator primaerdokumentTypeCreator;
+
+ public FormatType createFormatType(VorgangWithEingang vorgang, OzgFile ozgFile) {
+ var format = new FormatType();
+ format.setPrimaerdokument(primaerdokumentTypeCreator.createPrimaerdokumentType(vorgang, ozgFile));
+ format.setName(DateiformatCode.PDF.createDateiformatCodeType());
+ format.setSonstigerName(StringUtils.EMPTY);
+ format.setVersion(StringUtils.EMPTY);
+ return format;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb2878a6743cb451eae8412552e5ca2be7725f30
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreator.java
@@ -0,0 +1,27 @@
+package de.ozgcloud.alfa.export;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.PrimaerdokumentType;
+
+@Component
+class PrimaerdokumentTypeCreator {
+
+ @Autowired
+ private UUIDConverter uuidConverter;
+
+ public PrimaerdokumentType createPrimaerdokumentType(VorgangWithEingang vorgang, OzgFile ozgFile) {
+ var primaerdokument = new PrimaerdokumentType();
+ primaerdokument.setDateiname(createDateiname(ozgFile));
+ primaerdokument.setDateinameOriginal(ozgFile.getName());
+ primaerdokument.setErsteller(vorgang.getEingang().getHeader().getFormEngineName());
+ return primaerdokument;
+ }
+
+ String createDateiname(OzgFile ozgFile) {
+ return String.format("%s_%s", uuidConverter.fromObjectId(ozgFile.getId().toString()), ozgFile.getName());
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/SchriftgutobjektCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/SchriftgutobjektCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa49273d7ff0b1bb012ecf2f900fb31f456f792a
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/SchriftgutobjektCreator.java
@@ -0,0 +1,22 @@
+package de.ozgcloud.alfa.export;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.AbgabeAbgabe0401.Schriftgutobjekt;
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
+
+@Component
+class SchriftgutobjektCreator {
+
+ @Autowired
+ private VorgangTypeCreator vorgangTypeCreator;
+
+ public Schriftgutobjekt createSchriftgutobjekt(VorgangWithEingang vorgang, AnwendungsspezifischeErweiterungType erweiterung) {
+ var schritftgutobjekt = new Schriftgutobjekt();
+ schritftgutobjekt.setVorgang(vorgangTypeCreator.createVorgangType(vorgang, erweiterung));
+ return schritftgutobjekt;
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/UUIDConverter.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/UUIDConverter.java
new file mode 100644
index 0000000000000000000000000000000000000000..ad28c0ea96923a9567330fed9fa1bea30cc3f15c
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/UUIDConverter.java
@@ -0,0 +1,23 @@
+package de.ozgcloud.alfa.export;
+
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+
+@Component
+class UUIDConverter {
+
+ private static final Pattern UUID_SPLIT_PATTERN = Pattern.compile(
+ "^([a-fA-F0-9]{8})([a-fA-F0-9]{4})([a-fA-F0-9]{4})([a-fA-F0-9]{4})([a-fA-F0-9]+)$");
+
+ public String fromObjectId(String objectId) {
+ var matcher = UUID_SPLIT_PATTERN.matcher(objectId);
+ if (matcher.find()) {
+ var lastGroup = StringUtils.leftPad(matcher.group(5), 12, "0");
+ return String.format("%s-%s-%s-%s-%s", matcher.group(1), matcher.group(2), matcher.group(3), matcher.group(4), lastGroup);
+ }
+ throw new IllegalArgumentException(String.format("Invalid object id %s", objectId));
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VersionTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VersionTypeCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..ca91a6714794dce0261877e75540dcd46f29fc14
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VersionTypeCreator.java
@@ -0,0 +1,24 @@
+package de.ozgcloud.alfa.export;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.VersionType;
+
+@Component
+class VersionTypeCreator {
+
+ static final String NUMMER = "1";
+
+ @Autowired
+ private FormatTypeCreator formatTypeCreator;
+
+ public VersionType createVersionType(VorgangWithEingang vorgang, OzgFile ozgFile) {
+ var version = new VersionType();
+ version.setNummer(NUMMER);
+ version.getFormat().add(formatTypeCreator.createFormatType(vorgang, ozgFile));
+ return version;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VorgangTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VorgangTypeCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..3dc73649b576bed5ca7f349c0b79b27152025fa0
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/VorgangTypeCreator.java
@@ -0,0 +1,56 @@
+package de.ozgcloud.alfa.export;
+
+import java.util.UUID;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.MediumCodeType;
+import de.xoev.xdomea.VorgangType;
+
+@Component
+class VorgangTypeCreator {
+
+ static final Long NUMMER_IM_UEBERGEORDNETEN_CONTAINER = 1L;
+ static final String ALLGEMEINE_METADATEN_MEDIUM_CODE = "001";
+
+ @Autowired
+ private DokumentTypeCreator dokumentTypeCreator;
+
+ public VorgangType createVorgangType(VorgangWithEingang vorgangWithEingang, AnwendungsspezifischeErweiterungType erweiterung) {
+ var vorgang = new VorgangType();
+ vorgang.setAnwendungsspezifischeErweiterung(erweiterung);
+ vorgang.setIdentifikation(createIdentifikation());
+ vorgang.setAllgemeineMetadaten(createAllgemeineMetadaten(vorgangWithEingang));
+ vorgang.getDokument().addAll(dokumentTypeCreator.createDokumentTypen(vorgangWithEingang).toList());
+ return vorgang;
+ }
+
+ IdentifikationObjektType createIdentifikation() {
+ var identifikation = new IdentifikationObjektType();
+ identifikation.setID(UUID.randomUUID().toString());
+ identifikation.setNummerImUebergeordnetenContainer(NUMMER_IM_UEBERGEORDNETEN_CONTAINER);
+ return identifikation;
+ }
+
+ AllgemeineMetadatenType createAllgemeineMetadaten(VorgangWithEingang vorgang) {
+ var allgemeineMetadaten = new AllgemeineMetadatenType();
+ allgemeineMetadaten.setBetreff(vorgang.getName());
+ allgemeineMetadaten.setKennzeichen(vorgang.getNummer());
+ allgemeineMetadaten.setBemerkung(StringUtils.EMPTY);
+ allgemeineMetadaten.setMedium(createMediumCode());
+ return allgemeineMetadaten;
+ }
+
+ private MediumCodeType createMediumCode() {
+ var mediumCode = new MediumCodeType();
+ mediumCode.setCode(ALLGEMEINE_METADATEN_MEDIUM_CODE);
+ return mediumCode;
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XDomeaService.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XDomeaService.java
index 9ec571bd5be635ea746403fab49a435861e69a8b..e138d057359e76396ab7d09463c8ee81dcfd5962 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XDomeaService.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XDomeaService.java
@@ -3,42 +3,32 @@ package de.ozgcloud.alfa.export;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
-import java.util.UUID;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
-import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import de.itvsh.kop.common.errorhandling.TechnicalException;
import de.ozgcloud.alfa.vorgang.VorgangController;
import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
-import de.xoev.xdomea.AbgabeAbgabe0401;
-import de.xoev.xdomea.AbgabeAbgabe0401.Schriftgutobjekt;
-import de.xoev.xdomea.AllgemeineMetadatenType;
-import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
-import de.xoev.xdomea.IdentifikationObjektType;
-import de.xoev.xdomea.MediumCodeType;
-import de.xoev.xdomea.VorgangType;
@Service
class XDomeaService {
static final String EXPORT_FILENAME_SUFFIX = "_Abgabe.Abgabe.0401.xml";
- static final Long NUMMER_IM_UEBERGEORDNETEN_CONTAINER = 1L;
private static final String EXPORT_FILENAME_TEMPLATE = "%s" + EXPORT_FILENAME_SUFFIX;
- @Autowired
- private AnwendungsspezifischeErweiterungMapper anwendungsspezifischeErweiterungMapper;
-
@Autowired
private XDomeaXmlMarshaller xDomeaXmlMarshaller;
@Autowired
private VorgangController vorgangController;
+ @Autowired
+ private AbgabeAbgabe0401Creator abgabeCreator;
+
public void writeExport(String vorgangId, String filenameId, OutputStream out) {
var vorgang = vorgangController.getVorgang(vorgangId);
try (var zipOutputStream = new ZipOutputStream(out)) {
@@ -60,50 +50,6 @@ class XDomeaService {
}
String createXmlContent(VorgangWithEingang vorgang) {
- var erweiterung = anwendungsspezifischeErweiterungMapper.map(vorgang);
- var abgabe = buildAbgabe(vorgang, erweiterung);
- return xDomeaXmlMarshaller.marshal(abgabe);
- }
-
- AbgabeAbgabe0401 buildAbgabe(VorgangWithEingang vorgang, AnwendungsspezifischeErweiterungType erweiterung) {
- var root = new AbgabeAbgabe0401();
- root.getSchriftgutobjekt().add(buildSchriftgutobjekt(vorgang, erweiterung));
- return root;
- }
-
- Schriftgutobjekt buildSchriftgutobjekt(VorgangWithEingang vorgang, AnwendungsspezifischeErweiterungType erweiterung) {
- var schritftgutobjekt = new Schriftgutobjekt();
- schritftgutobjekt.setVorgang(buildVorgangType(vorgang, erweiterung));
- return schritftgutobjekt;
- }
-
- VorgangType buildVorgangType(VorgangWithEingang vorgangWithEingang, AnwendungsspezifischeErweiterungType erweiterung) {
- var vorgang = new VorgangType();
- vorgang.setAnwendungsspezifischeErweiterung(erweiterung);
- vorgang.setIdentifikation(buildIdentifikation());
- vorgang.setAllgemeineMetadaten(buildAllgemeineMetadaten(vorgangWithEingang));
- return vorgang;
- }
-
- IdentifikationObjektType buildIdentifikation() {
- var identifikation = new IdentifikationObjektType();
- identifikation.setID(UUID.randomUUID().toString());
- identifikation.setNummerImUebergeordnetenContainer(NUMMER_IM_UEBERGEORDNETEN_CONTAINER);
- return identifikation;
- }
-
- public AllgemeineMetadatenType buildAllgemeineMetadaten(VorgangWithEingang vorgang) {
- var allgemeineMetadaten = new AllgemeineMetadatenType();
- allgemeineMetadaten.setBetreff(vorgang.getName());
- allgemeineMetadaten.setKennzeichen(vorgang.getNummer());
- allgemeineMetadaten.setBemerkung(StringUtils.EMPTY);
- allgemeineMetadaten.setMedium(buildMediumCode());
- return allgemeineMetadaten;
- }
-
- private MediumCodeType buildMediumCode() {
- var mediumCode = new MediumCodeType();
- mediumCode.setCode(XDomeaMedienart.ELEKTRONISCHES_DOKUMENT.getCode());
- return mediumCode;
+ return xDomeaXmlMarshaller.marshal(abgabeCreator.createAbgabe(vorgang));
}
}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401CreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401CreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb9780158500c6922aa7e5a05e369e80abaedcb0
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401CreatorTest.java
@@ -0,0 +1,65 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+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 de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.AbgabeAbgabe0401.Schriftgutobjekt;
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
+
+class AbgabeAbgabe0401CreatorTest {
+
+ @InjectMocks
+ private AbgabeAbgabe0401Creator creator;
+
+ @Mock
+ private SchriftgutobjektCreator schriftgutobjektCreator;
+
+ @Mock
+ private AnwendungsspezifischeErweiterungMapper anwendungsspezifischeErweiterungMapper;
+
+ @Nested
+ class TestCreateAbgabe {
+
+ private final VorgangWithEingang vorgangWithEingang = VorgangWithEingangTestFactory.create();
+
+ private final AnwendungsspezifischeErweiterungType anwendungsspezifischeErweiterung = AnwendungsspezifischeErweiterungTypeTestFactory.create();
+ private final Schriftgutobjekt schriftgutobjekt = SchriftgutobjektTestFactory.create();
+
+ @BeforeEach
+ void init() {
+ when(anwendungsspezifischeErweiterungMapper.map(vorgangWithEingang)).thenReturn(anwendungsspezifischeErweiterung);
+ }
+
+ @Test
+ void shouldCallMapper() {
+ creator.createAbgabe(vorgangWithEingang);
+
+ verify(anwendungsspezifischeErweiterungMapper).map(vorgangWithEingang);
+ }
+
+ @Test
+ void shouldCreateSchriftgutobjekt() {
+ creator.createAbgabe(vorgangWithEingang);
+
+ verify(schriftgutobjektCreator).createSchriftgutobjekt(vorgangWithEingang, anwendungsspezifischeErweiterung);
+ }
+
+ @Test
+ void shouldHaveSchriftgutobjekt() {
+ doReturn(schriftgutobjekt).when(schriftgutobjektCreator).createSchriftgutobjekt(vorgangWithEingang, anwendungsspezifischeErweiterung);
+
+ var abgabe = creator.createAbgabe(vorgangWithEingang);
+
+ assertThat(abgabe.getSchriftgutobjekt().get(0)).isEqualTo(schriftgutobjekt);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DateiformatCodeTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DateiformatCodeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8fefefe8e4ae869abfc6a4242d233accb64cdef4
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DateiformatCodeTest.java
@@ -0,0 +1,35 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+class DateiformatCodeTest {
+
+ @Nested
+ class TestCreateDateiformatCodeType {
+
+ @Test
+ void shouldHaveCode() {
+ var dateiformatCode = DateiformatCode.PDF.createDateiformatCodeType();
+
+ assertThat(dateiformatCode.getCode()).isEqualTo(DateiformatCode.PDF.code);
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var dateiformatCode = DateiformatCode.PDF.createDateiformatCodeType();
+
+ assertThat(dateiformatCode.getListURI()).isEqualTo(DateiformatCode.LIST_URI);
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var dateiformatCode = DateiformatCode.PDF.createDateiformatCodeType();
+
+ assertThat(dateiformatCode.getListVersionID()).isEqualTo(DateiformatCode.PDF.listVersionID);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DokumentTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DokumentTypeCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..743f719d02220b470dc129ad4151a68f4c8a8b17
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DokumentTypeCreatorTest.java
@@ -0,0 +1,207 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.stream.Stream;
+
+import org.apache.commons.lang3.StringUtils;
+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.Spy;
+
+import de.ozgcloud.alfa.common.TestUtils;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.vorgang.EingangTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.DokumentType;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.VersionType;
+
+class DokumentTypeCreatorTest {
+
+ @Spy
+ @InjectMocks
+ private DokumentTypeCreator creator;
+
+ @Mock
+ private ExportFileService exportFileService;
+
+ @Mock
+ private UUIDConverter uuidConverter;
+
+ @Mock
+ private VersionTypeCreator versionTypeCreator;
+
+ @Nested
+ class CreateDokumentTypen {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+
+ @BeforeEach
+ void init() {
+ when(exportFileService.getAllPdfs(EingangTestFactory.ID)).thenReturn(Stream.of(ozgFile));
+ }
+
+ @Test
+ void shouldLoadlAllPdfs() {
+ creator.createDokumentTypen(vorgang);
+
+ verify(exportFileService).getAllPdfs(EingangTestFactory.ID);
+ }
+
+ @Test
+ void shouldCreateDokumentType() {
+ creator.createDokumentTypen(vorgang);
+
+ verify(creator).createDokumentType(1, vorgang, ozgFile);
+ }
+
+ }
+
+ @Nested
+ class CreateDokumentType {
+
+ private final IdentifikationObjektType identifikationObjekt = IdentifikationObjektTypeTestFactory.create();
+ private final AllgemeineMetadatenType allgemeineMetadaten = AllgemeineMetadatenTypeTestFactory.create();
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final VersionType version = VersionTypeTestFactory.create();
+ private final int DOKUMENT_ORDINAL_NUMBER = 1;
+
+ @BeforeEach
+ void init() {
+ doReturn(identifikationObjekt).when(creator).createIdentifikation(DOKUMENT_ORDINAL_NUMBER, OzgFileTestFactory.ID.toString());
+ doReturn(allgemeineMetadaten).when(creator).createAllgemeineMetadaten(ozgFile);
+
+ when(versionTypeCreator.createVersionType(vorgang, ozgFile)).thenReturn(version);
+ }
+
+ @Test
+ void shouldCreateIdentifikation() {
+ create();
+
+ verify(creator).createIdentifikation(DOKUMENT_ORDINAL_NUMBER, OzgFileTestFactory.ID.toString());
+ }
+
+ @Test
+ void shouldHaveIdentifikation() {
+ var dokument = create();
+
+ assertThat(dokument.getIdentifikation()).isEqualTo(identifikationObjekt);
+ }
+
+ @Test
+ void shouldCreateAllgemeineMetadaten() {
+ create();
+
+ verify(creator).createAllgemeineMetadaten(ozgFile);
+ }
+
+ @Test
+ void shouldHaveAllgemeineMetadaten() {
+ var dokument = create();
+
+ assertThat(dokument.getAllgemeineMetadaten()).isEqualTo(allgemeineMetadaten);
+ }
+
+ @Test
+ void shouldCreateVersion() {
+ create();
+
+ verify(versionTypeCreator).createVersionType(vorgang, ozgFile);
+ }
+
+ @Test
+ void shouldHaveVersion() {
+ var dokument = create();
+
+ assertThat(dokument.getVersion()).containsExactly(version);
+ }
+
+ private DokumentType create() {
+ return creator.createDokumentType(DOKUMENT_ORDINAL_NUMBER, vorgang, ozgFile);
+ }
+ }
+
+ @Nested
+ class TestCreateIdentifikation {
+
+ private final String FILE_ID = "64a820d36285172ac02826d0";
+ private final String FILE_UUID = "64a820d3-6285-172a-c028-0000000026d0";
+ private final int DOKUMENT_ORDINAL_NUMBER = 1;
+
+ @BeforeEach
+ void init() {
+ when(uuidConverter.fromObjectId(FILE_ID)).thenReturn(FILE_UUID);
+ }
+
+ @Test
+ void shouldConvertObjectId() {
+ create();
+
+ verify(uuidConverter).fromObjectId(FILE_ID);
+ }
+
+ @Test
+ void shouldHaveId() {
+ var identifikation = create();
+
+ assertThat(identifikation.getID()).matches(TestUtils.UUID_REGEX).isEqualTo(FILE_UUID);
+ }
+
+ @Test
+ void shouldHaveNummerImUebergeordnetenContainer() {
+ var identifikation = create();
+
+ assertThat(identifikation.getNummerImUebergeordnetenContainer()).isEqualTo(DOKUMENT_ORDINAL_NUMBER);
+ }
+
+ private IdentifikationObjektType create() {
+ return creator.createIdentifikation(DOKUMENT_ORDINAL_NUMBER, FILE_ID);
+ }
+ }
+
+ @Nested
+ class TestCreateAllgemeineMetadaten {
+
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+
+ @Test
+ void shouldHaveBetreff() {
+ var allgemeineMetadaten = creator.createAllgemeineMetadaten(ozgFile);
+
+ assertThat(allgemeineMetadaten.getBetreff()).isEqualTo(OzgFileTestFactory.NAME);
+ }
+
+ @Test
+ void shouldHaveKennzeichen() {
+ var allgemeineMetadaten = creator.createAllgemeineMetadaten(ozgFile);
+
+ assertThat(allgemeineMetadaten.getKennzeichen()).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldHaveBemerkung() {
+ var allgemeineMetadaten = creator.createAllgemeineMetadaten(ozgFile);
+
+ assertThat(allgemeineMetadaten.getBemerkung()).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldHaveMedium() {
+ var allgemeineMetadaten = creator.createAllgemeineMetadaten(ozgFile);
+
+ assertThat(allgemeineMetadaten.getMedium().getCode()).isEqualTo(VorgangTypeCreator.ALLGEMEINE_METADATEN_MEDIUM_CODE);
+ }
+
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DokumentTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DokumentTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..8de8ed3e01318e4883481d704d6db97012b0c708
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DokumentTypeTestFactory.java
@@ -0,0 +1,11 @@
+package de.ozgcloud.alfa.export;
+
+import de.xoev.xdomea.DokumentType;
+
+public class DokumentTypeTestFactory {
+
+ public static DokumentType create() {
+ var dokument = new DokumentType();
+ return dokument;
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportFileServiceTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportFileServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..03f402b589ebf686e607e77ebba88c8a3203a9d2
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportFileServiceTest.java
@@ -0,0 +1,65 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.stream.Stream;
+
+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.springframework.http.MediaType;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileService;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.vorgang.EingangTestFactory;
+
+class ExportFileServiceTest {
+
+ @InjectMocks
+ private ExportFileService service;
+
+ @Mock
+ private OzgFileService ozgFileService;
+
+ @Nested
+ class TestGetAllPdfs {
+
+ private final OzgFile representationPdfFile = OzgFileTestFactory.createBuilder().contentType(MediaType.APPLICATION_PDF_VALUE).build();
+ private final OzgFile representationXmlFile = OzgFileTestFactory.createBuilder().contentType(MediaType.TEXT_XML_VALUE).build();
+ private final OzgFile attachmentPdfFile = OzgFileTestFactory.createBuilder().contentType(MediaType.APPLICATION_PDF_VALUE).build();
+ private final OzgFile attachmentXmlFile = OzgFileTestFactory.createBuilder().contentType(MediaType.TEXT_XML_VALUE).build();
+
+ @BeforeEach
+ void init() {
+ when(ozgFileService.getRepresentationsByEingang(EingangTestFactory.ID)).thenReturn(
+ Stream.of(representationPdfFile, representationXmlFile));
+ when(ozgFileService.getAttachmentsByEingang(EingangTestFactory.ID)).thenReturn(Stream.of(attachmentXmlFile, attachmentPdfFile));
+ }
+
+ @Test
+ void shouldLoadRepresentations() {
+ service.getAllPdfs(EingangTestFactory.ID);
+
+ verify(ozgFileService).getRepresentationsByEingang(EingangTestFactory.ID);
+ }
+
+ @Test
+ void shouldLoadAttachments() {
+ service.getAllPdfs(EingangTestFactory.ID);
+
+ verify(ozgFileService).getAttachmentsByEingang(EingangTestFactory.ID);
+ }
+
+ @Test
+ void shouldReturnPdfs() {
+ var ozgFiles = service.getAllPdfs(EingangTestFactory.ID);
+
+ assertThat(ozgFiles).hasSize(2).containsExactlyInAnyOrder(attachmentPdfFile, representationPdfFile);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FormaTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FormaTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..b4c5902e19925829e206e4f3c6cd6d0e19098c3c
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FormaTypeTestFactory.java
@@ -0,0 +1,10 @@
+package de.ozgcloud.alfa.export;
+
+import de.xoev.xdomea.FormatType;
+
+class FormaTypeTestFactory {
+
+ public static FormatType create() {
+ return new FormatType();
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FormatTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FormatTypeCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e639d7a8bfad0a703077225d6f2a354275669df3
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/FormatTypeCreatorTest.java
@@ -0,0 +1,78 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.apache.commons.lang3.StringUtils;
+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.Spy;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.PrimaerdokumentType;
+
+class FormatTypeCreatorTest {
+
+ @Spy
+ @InjectMocks
+ private FormatTypeCreator creator;
+
+ @Mock
+ private PrimaerdokumentTypeCreator primaerdokumentTypeCreator;
+
+ @Nested
+ class TestCreateFormatType {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+
+ private final PrimaerdokumentType primaerdokument = PrimaerdokumentTypeTestFactory.create();
+
+ @BeforeEach
+ void init() {
+ when(primaerdokumentTypeCreator.createPrimaerdokumentType(vorgang, ozgFile)).thenReturn(primaerdokument);
+ }
+
+ @Test
+ void shouldCreatePrimaerdokument() {
+ creator.createFormatType(vorgang, ozgFile);
+
+ verify(primaerdokumentTypeCreator).createPrimaerdokumentType(vorgang, ozgFile);
+ }
+
+ @Test
+ void shouldHavePrimaerdokumentType() {
+ var format = creator.createFormatType(vorgang, ozgFile);
+
+ assertThat(format.getPrimaerdokument()).isEqualTo(primaerdokument);
+ }
+
+ @Test
+ void shouldHaveName() {
+ var format = creator.createFormatType(vorgang, ozgFile);
+
+ assertThat(format.getName()).usingRecursiveComparison().isEqualTo(DateiformatCode.PDF.createDateiformatCodeType());
+ }
+
+ @Test
+ void shouldHaveSonstigerName() {
+ var format = creator.createFormatType(vorgang, ozgFile);
+
+ assertThat(format.getSonstigerName()).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldHaveVersion() {
+ var format = creator.createFormatType(vorgang, ozgFile);
+
+ assertThat(format.getVersion()).isEqualTo(StringUtils.EMPTY);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d2cea2a5a3374289b5f4c2d5b3a5a1bd31d907cc
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeCreatorTest.java
@@ -0,0 +1,93 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+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.Spy;
+
+import de.ozgcloud.alfa.common.TestUtils;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.vorgang.EingangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+
+class PrimaerdokumentTypeCreatorTest {
+
+ @Spy
+ @InjectMocks
+ private PrimaerdokumentTypeCreator creator;
+
+ @Mock
+ private UUIDConverter uuidConverter;
+
+ @Nested
+ class TestCreatePrimaerdokumentType {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+
+ @BeforeEach
+ void init() {
+ doReturn(ozgFile.getName()).when(creator).createDateiname(ozgFile);
+ }
+
+ @Test
+ void shouldCreateDateiname() {
+ creator.createPrimaerdokumentType(vorgang, ozgFile);
+
+ verify(creator).createDateiname(ozgFile);
+ }
+
+ @Test
+ void shouldHaveDateiname() {
+ var primaerdokument = creator.createPrimaerdokumentType(vorgang, ozgFile);
+
+ assertThat(primaerdokument.getDateiname()).isEqualTo(ozgFile.getName());
+ }
+
+ @Test
+ void shouldHaveDateinameOriginal() {
+ var primaerdokument = creator.createPrimaerdokumentType(vorgang, ozgFile);
+
+ assertThat(primaerdokument.getDateinameOriginal()).isEqualTo(ozgFile.getName());
+ }
+
+ @Test
+ void shouldHaveErsteller() {
+ var primaerdokument = creator.createPrimaerdokumentType(vorgang, ozgFile);
+
+ assertThat(primaerdokument.getErsteller()).isEqualTo(EingangHeaderTestFactory.FORM_ENGINE_NAME);
+ }
+ }
+
+ @Nested
+ class TestCreateDateiname {
+
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+
+ @BeforeEach
+ void init() {
+ when(uuidConverter.fromObjectId(ozgFile.getId().toString())).thenReturn("64a820d3-6285-172a-c028-0000000026d0");
+ }
+
+ @Test
+ void shouldConvertObjectId() {
+ creator.createDateiname(ozgFile);
+
+ verify(uuidConverter).fromObjectId(ozgFile.getId().toString());
+ }
+
+ @Test
+ void shouldCreate() {
+ var dateiname = creator.createDateiname(ozgFile);
+
+ assertThat(dateiname).matches(String.format("^%s_%s$", TestUtils.UUID_REGEX, ozgFile.getName()));
+ }
+ }
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..f0ae78aaf77d4af8219bc90e920e504bc53f553b
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/PrimaerdokumentTypeTestFactory.java
@@ -0,0 +1,10 @@
+package de.ozgcloud.alfa.export;
+
+import de.xoev.xdomea.PrimaerdokumentType;
+
+class PrimaerdokumentTypeTestFactory {
+
+ public static PrimaerdokumentType create() {
+ return new PrimaerdokumentType();
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/SchriftgutobjektCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/SchriftgutobjektCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..214e6a3a323b1addec2aebe02381a8849e196e34
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/SchriftgutobjektCreatorTest.java
@@ -0,0 +1,50 @@
+package de.ozgcloud.alfa.export;
+
+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.mockito.InjectMocks;
+import org.mockito.Mock;
+
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
+import de.xoev.xdomea.VorgangType;
+
+class SchriftgutobjektCreatorTest {
+
+ @InjectMocks
+ private SchriftgutobjektCreator creator;
+
+ @Mock
+ private VorgangTypeCreator vorgangTypeCreator;
+
+ @Nested
+ class TestCreateSchriftgutObjekt {
+
+ private final VorgangWithEingang vorgangWithEingang = VorgangWithEingangTestFactory.create();
+
+ private final VorgangType vorgang = VorgangTypeTestFactory.create();
+ private final AnwendungsspezifischeErweiterungType anwendungsspezifischeErweiterung = AnwendungsspezifischeErweiterungTypeTestFactory.create();
+
+ @Test
+ void shouldCreateVorgangType() {
+ creator.createSchriftgutobjekt(vorgangWithEingang, anwendungsspezifischeErweiterung);
+
+ verify(vorgangTypeCreator).createVorgangType(vorgangWithEingang, anwendungsspezifischeErweiterung);
+ }
+
+ @Test
+ void shouldHaveVorgangType() {
+ doReturn(vorgang).when(vorgangTypeCreator).createVorgangType(vorgangWithEingang, anwendungsspezifischeErweiterung);
+
+ var schriftgutobjekt = creator.createSchriftgutobjekt(vorgangWithEingang, anwendungsspezifischeErweiterung);
+
+ assertThat(schriftgutobjekt.getVorgang()).isEqualTo(vorgang);
+ }
+
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/UUIDConverterTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/UUIDConverterTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d6e44fb53c75d36b71fcfd4e8e66ea90f07f188
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/UUIDConverterTest.java
@@ -0,0 +1,32 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+
+import de.ozgcloud.alfa.common.TestUtils;
+
+class UUIDConverterTest {
+
+ @InjectMocks
+ private UUIDConverter converter;
+
+ @Nested
+ class TestFromObjectId {
+
+ @Test
+ void shouldReturnUUID() {
+ var result = converter.fromObjectId("64a820d36285172ac02826d0");
+
+ assertThat(result).isEqualTo("64a820d3-6285-172a-c028-0000000026d0").matches(TestUtils.UUID_REGEX);
+ }
+
+ @Test
+ void shouldThrowIllegalArgumentException() {
+ assertThatThrownBy(() -> converter.fromObjectId("abc")).isInstanceOf(IllegalArgumentException.class);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VersionTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VersionTypeCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a038a493dcb4cd44c7dc4a7c8f131e1ab0aa3d5
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VersionTypeCreatorTest.java
@@ -0,0 +1,60 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+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 de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.FormatType;
+
+class VersionTypeCreatorTest {
+
+ @InjectMocks
+ private VersionTypeCreator creator;
+
+ @Mock
+ private FormatTypeCreator formatTypeCreator;
+
+ @Nested
+ class TestCreateVersionType {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+ private final FormatType formatType = FormaTypeTestFactory.create();
+
+ @BeforeEach
+ void init() {
+ when(formatTypeCreator.createFormatType(vorgang, ozgFile)).thenReturn(formatType);
+ }
+
+ @Test
+ void shouldHaveNummer() {
+ var version = creator.createVersionType(vorgang, ozgFile);
+
+ assertThat(version.getNummer()).isEqualTo(VersionTypeCreator.NUMMER);
+ }
+
+ @Test
+ void shouldCreateFormatType() {
+ creator.createVersionType(vorgang, ozgFile);
+
+ verify(formatTypeCreator).createFormatType(vorgang, ozgFile);
+ }
+
+ @Test
+ void shouldHaveFormatType() {
+ var version = creator.createVersionType(vorgang, ozgFile);
+
+ assertThat(version.getFormat()).containsExactly(formatType);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VersionTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VersionTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2ee1d70ad1e31e7d6f08e1ff589de41054987e2
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VersionTypeTestFactory.java
@@ -0,0 +1,10 @@
+package de.ozgcloud.alfa.export;
+
+import de.xoev.xdomea.VersionType;
+
+class VersionTypeTestFactory {
+
+ public static VersionType create() {
+ return new VersionType();
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VorgangTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VorgangTypeCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb414919b4cb6094a663ac0c8f07328dfdf3d2e4
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/VorgangTypeCreatorTest.java
@@ -0,0 +1,149 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.stream.Stream;
+
+import org.apache.commons.lang3.StringUtils;
+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.Spy;
+
+import de.ozgcloud.alfa.common.TestUtils;
+import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
+import de.xoev.xdomea.DokumentType;
+import de.xoev.xdomea.IdentifikationObjektType;
+
+class VorgangTypeCreatorTest {
+
+ @Spy
+ @InjectMocks
+ private VorgangTypeCreator creator;
+
+ @Mock
+ private DokumentTypeCreator dokumentTypeCreator;
+
+ @Nested
+ class TestCreateVorgangType {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+
+ private final IdentifikationObjektType identifikationObjekt = IdentifikationObjektTypeTestFactory.create();
+ private final AllgemeineMetadatenType allgemeineMetadaten = AllgemeineMetadatenTypeTestFactory.create();
+ private final AnwendungsspezifischeErweiterungType anwendungsspezifischeErweiterung = AnwendungsspezifischeErweiterungTypeTestFactory.create();
+ private final DokumentType dokument = DokumentTypeTestFactory.create();
+
+ @BeforeEach
+ void init() {
+ doReturn(identifikationObjekt).when(creator).createIdentifikation();
+ doReturn(allgemeineMetadaten).when(creator).createAllgemeineMetadaten(vorgang);
+
+ when(dokumentTypeCreator.createDokumentTypen(vorgang)).thenReturn(Stream.of(dokument));
+ }
+
+ @Test
+ void shouldHaveAnwendungsspezifischeErweiterungType() {
+ var vorgangType = creator.createVorgangType(vorgang, anwendungsspezifischeErweiterung);
+
+ assertThat(vorgangType.getAnwendungsspezifischeErweiterung()).isEqualTo(anwendungsspezifischeErweiterung);
+ }
+
+ @Test
+ void shouldCallCreateIdentifikation() {
+ creator.createVorgangType(vorgang, anwendungsspezifischeErweiterung);
+
+ verify(creator).createIdentifikation();
+ }
+
+ @Test
+ void shouldHaveIdentifikation() {
+ var vorgangType = creator.createVorgangType(vorgang, anwendungsspezifischeErweiterung);
+
+ assertThat(vorgangType.getIdentifikation()).isEqualTo(identifikationObjekt);
+ }
+
+ @Test
+ void shouldCallCreateAllgemeineMetadaten() {
+ creator.createVorgangType(vorgang, anwendungsspezifischeErweiterung);
+
+ verify(creator).createAllgemeineMetadaten(vorgang);
+ }
+
+ @Test
+ void shouldHaveAllgemeineMetadaten() {
+ var vorgangType = creator.createVorgangType(vorgang, anwendungsspezifischeErweiterung);
+
+ assertThat(vorgangType.getAllgemeineMetadaten()).isEqualTo(allgemeineMetadaten);
+ }
+
+ @Test
+ void shouldCreateDokumenType() {
+ var vorgangType = creator.createVorgangType(vorgang, anwendungsspezifischeErweiterung);
+
+ verify(dokumentTypeCreator).createDokumentTypen(vorgang);
+ assertThat(vorgangType.getDokument()).hasSize(1).containsExactly(dokument);
+ }
+ }
+
+ @Nested
+ class TestCreateAllgemeineMetadaten {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+
+ @Test
+ void shouldHaveBetreff() {
+ var allgemeineMetadaten = creator.createAllgemeineMetadaten(vorgang);
+
+ assertThat(allgemeineMetadaten.getBetreff()).isEqualTo(VorgangHeaderTestFactory.NAME);
+ }
+
+ @Test
+ void shouldHaveKennzeichen() {
+ var allgemeineMetadaten = creator.createAllgemeineMetadaten(vorgang);
+
+ assertThat(allgemeineMetadaten.getKennzeichen()).isEqualTo(VorgangHeaderTestFactory.NUMMER);
+ }
+
+ @Test
+ void shouldHaveBemerkung() {
+ var allgemeineMetadaten = creator.createAllgemeineMetadaten(vorgang);
+
+ assertThat(allgemeineMetadaten.getBemerkung()).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldHaveMedium() {
+ var allgemeineMetadaten = creator.createAllgemeineMetadaten(vorgang);
+
+ assertThat(allgemeineMetadaten.getMedium().getCode()).isEqualTo(VorgangTypeCreator.ALLGEMEINE_METADATEN_MEDIUM_CODE);
+ }
+
+ }
+
+ @Nested
+ class TestCreateIdentifikation {
+
+ @Test
+ void shouldHaveId() {
+ var identifikation = creator.createIdentifikation();
+
+ assertThat(identifikation.getID()).matches(TestUtils.UUID_REGEX);
+ }
+
+ @Test
+ void shouldHaveNummerImUebergeordnetenContainer() {
+ var identifikation = creator.createIdentifikation();
+
+ assertThat(identifikation.getNummerImUebergeordnetenContainer()).isEqualTo(VorgangTypeCreator.NUMMER_IM_UEBERGEORDNETEN_CONTAINER);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XDomeaServiceTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XDomeaServiceTest.java
index 27bedb1b3d5c9324030b3e997e4bbed4e359694b..b6a74793cea29cc43281abbed69c6ebdf64b82aa 100644
--- a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XDomeaServiceTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XDomeaServiceTest.java
@@ -10,7 +10,6 @@ import java.io.IOException;
import java.util.UUID;
import java.util.zip.ZipOutputStream;
-import org.apache.commons.lang3.StringUtils;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
@@ -26,11 +25,6 @@ import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
import de.xoev.xdomea.AbgabeAbgabe0401;
-import de.xoev.xdomea.AbgabeAbgabe0401.Schriftgutobjekt;
-import de.xoev.xdomea.AllgemeineMetadatenType;
-import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
-import de.xoev.xdomea.IdentifikationObjektType;
-import de.xoev.xdomea.VorgangType;
class XDomeaServiceTest {
@@ -38,15 +32,15 @@ class XDomeaServiceTest {
@InjectMocks
private XDomeaService service;
- @Mock
- private AnwendungsspezifischeErweiterungMapper anwendungsspezifischeErweiterungMapper;
-
@Mock
private XDomeaXmlMarshaller XDomeaXmlMarshaller;
@Mock
private VorgangController vorgangController;
+ @Mock
+ private AbgabeAbgabe0401Creator abgabeCreator;
+
@DisplayName("Write exportToXdomea")
@Nested
class TestWriteExport {
@@ -131,24 +125,14 @@ class XDomeaServiceTest {
private static final String XML_STRING = "<xml>";
private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
- private final AnwendungsspezifischeErweiterungType anwendungsspezifischeErweiterung = AnwendungsspezifischeErweiterungTypeTestFactory
- .create();
private final AbgabeAbgabe0401 abgabe = AbgabeAbgabe0401TestFactory.create();
@BeforeEach
void init() {
- when(anwendungsspezifischeErweiterungMapper.map(vorgang)).thenReturn(anwendungsspezifischeErweiterung);
- doReturn(abgabe).when(service).buildAbgabe(eq(vorgang), any());
+ doReturn(abgabe).when(abgabeCreator).createAbgabe(vorgang);
when(XDomeaXmlMarshaller.marshal(any())).thenReturn(XML_STRING);
}
- @Test
- void shouldCallMapper() {
- service.createXmlContent(vorgang);
-
- verify(anwendungsspezifischeErweiterungMapper).map(vorgang);
- }
-
@Test
void shouldCallXmlMarshaller() {
service.createXmlContent(vorgang);
@@ -162,141 +146,12 @@ class XDomeaServiceTest {
assertThat(result).isEqualTo(XML_STRING);
}
- }
-
- @DisplayName("Build abgabe")
- @Nested
- class TestBuildAbgabe {
-
- private final AnwendungsspezifischeErweiterungType type = AnwendungsspezifischeErweiterungTypeTestFactory.create();
- private final Schriftgutobjekt schriftgutObjekt = SchriftgutobjektTestFactory.create();
@Test
- void shouldHaveSchriftgutobjekt() {
- doReturn(schriftgutObjekt).when(service).buildSchriftgutobjekt(any(), any());
-
- var abgabe = service.buildAbgabe(VorgangWithEingangTestFactory.create(), type);
-
- assertThat(abgabe.getSchriftgutobjekt().get(0)).isEqualTo(schriftgutObjekt);
- }
-
- @DisplayName("build schriftgutobjekt")
- @Nested
- class TestBuildSchriftgutObjekt {
-
- private final VorgangType vorgang = VorgangTypeTestFactory.create();
-
- @Test
- void shouldHaveVorgangType() {
- doReturn(vorgang).when(service).buildVorgangType(any(), any());
-
- var schriftgutobjekt = service.buildSchriftgutobjekt(VorgangWithEingangTestFactory.create(), type);
-
- assertThat(schriftgutobjekt.getVorgang()).isEqualTo(vorgang);
- }
-
- @DisplayName("build vorgangType")
- @Nested
- class TestBuildVorgangType {
-
- private final IdentifikationObjektType identifikationObjekt = IdentifikationObjektTypeTestFactory.create();
- private final AllgemeineMetadatenType allgemeineMetadaten = AllgemeineMetadatenTypeTestFactory.create();
- private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
-
- @BeforeEach
- void init() {
- doReturn(identifikationObjekt).when(service).buildIdentifikation();
- doReturn(allgemeineMetadaten).when(service).buildAllgemeineMetadaten(vorgang);
- }
-
- @Test
- void shouldHaveAnwendungsspezifischeErweiterungType() {
- var vorgangType = service.buildVorgangType(vorgang, type);
-
- assertThat(vorgangType.getAnwendungsspezifischeErweiterung()).isEqualTo(type);
- }
-
- @Test
- void shouldCallBuildIdentifikation() {
- service.buildVorgangType(vorgang, type);
-
- verify(service).buildIdentifikation();
- }
-
- @Test
- void shouldHaveIdentifikation() {
- var vorgangType = service.buildVorgangType(vorgang, type);
-
- assertThat(vorgangType.getIdentifikation()).isEqualTo(identifikationObjekt);
- }
-
- @Test
- void shouldCallBuildAllgemeineMetadaten() {
- service.buildVorgangType(vorgang, type);
-
- verify(service).buildAllgemeineMetadaten(vorgang);
- }
-
- @Test
- void shouldHaveAllgemeineMetadaten() {
- var vorgangType = service.buildVorgangType(vorgang, type);
-
- assertThat(vorgangType.getAllgemeineMetadaten()).isEqualTo(allgemeineMetadaten);
- }
- }
- }
- }
-
- @Nested
- class TestBuildIdentifikation {
-
- @Test
- void shouldHaveId() {
- var identifikation = service.buildIdentifikation();
-
- assertThat(identifikation.getID()).matches(TestUtils.UUID_REGEX);
- }
-
- @Test
- void shouldHaveNummerImUebergeordnetenContainer() {
- var identifikation = service.buildIdentifikation();
-
- assertThat(identifikation.getNummerImUebergeordnetenContainer()).isEqualTo(XDomeaService.NUMMER_IM_UEBERGEORDNETEN_CONTAINER);
- }
- }
-
- @Nested
- class TestBuildAllgemeineMetadaten {
-
- private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
-
- @Test
- void shouldHaveBetreff() {
- var allgemeineMetadaten = service.buildAllgemeineMetadaten(vorgang);
-
- assertThat(allgemeineMetadaten.getBetreff()).isEqualTo(VorgangHeaderTestFactory.NAME);
- }
-
- @Test
- void shouldHaveKennzeichen() {
- var allgemeineMetadaten = service.buildAllgemeineMetadaten(vorgang);
-
- assertThat(allgemeineMetadaten.getKennzeichen()).isEqualTo(VorgangHeaderTestFactory.NUMMER);
- }
-
- @Test
- void shouldHaveBemerkung() {
- var allgemeineMetadaten = service.buildAllgemeineMetadaten(vorgang);
-
- assertThat(allgemeineMetadaten.getBemerkung()).isEqualTo(StringUtils.EMPTY);
- }
-
- @Test
- void shouldHaveMedium() {
- var allgemeineMetadaten = service.buildAllgemeineMetadaten(vorgang);
+ void shouldCallAbgabeCreator() {
+ service.createXmlContent(vorgang);
- assertThat(allgemeineMetadaten.getMedium().getCode()).isEqualTo(XDomeaMedienart.ELEKTRONISCHES_DOKUMENT.getCode());
+ verify(abgabeCreator).createAbgabe(vorgang);
}
-
}
}
\ No newline at end of file