diff --git a/alfa-service/javac.20240524_095230.args b/alfa-service/javac.20240524_095230.args
new file mode 100644
index 0000000000000000000000000000000000000000..afb64b5f04472a1efb08d555a627210a5f51a84e
--- /dev/null
+++ b/alfa-service/javac.20240524_095230.args
@@ -0,0 +1 @@
+@/tmp/org.codehaus.plexus.compiler.javac.JavacCompiler16216354973819705899arguments
diff --git a/alfa-service/src/main/java/de/ozgcloud/alfa/bescheid/Bescheid.java b/alfa-service/src/main/java/de/ozgcloud/alfa/bescheid/Bescheid.java
index 5adc0a343a849c6f72bdaab9880d691ff92631af..67cb7eb4c7f5432aa2433a65b784c788f4b9869c 100644
--- a/alfa-service/src/main/java/de/ozgcloud/alfa/bescheid/Bescheid.java
+++ b/alfa-service/src/main/java/de/ozgcloud/alfa/bescheid/Bescheid.java
@@ -57,4 +57,6 @@ public class Bescheid implements CommandBody {
private String nachrichtSubject;
private SendBy sendBy;
private BescheidStatus status;
+
+ private SentInfo sentInfo;
}
\ No newline at end of file
diff --git a/alfa-service/src/main/java/de/ozgcloud/alfa/bescheid/BescheidMapper.java b/alfa-service/src/main/java/de/ozgcloud/alfa/bescheid/BescheidMapper.java
index 633caec19adf941465e76e9aaf9e69e292b2f327..bf8932e3df1d5415b43aebb5e4be6df0c0f5cc2e 100644
--- a/alfa-service/src/main/java/de/ozgcloud/alfa/bescheid/BescheidMapper.java
+++ b/alfa-service/src/main/java/de/ozgcloud/alfa/bescheid/BescheidMapper.java
@@ -11,13 +11,18 @@ import com.google.protobuf.ProtocolStringList;
import de.ozgcloud.alfa.common.binaryfile.FileId;
import de.ozgcloud.alfa.common.binaryfile.FileIdMapper;
+import de.ozgcloud.alfa.common.user.UserIdMapper;
import de.ozgcloud.bescheid.GrpcBescheid;
+import de.ozgcloud.bescheid.GrpcSentInfo;
-@Mapper(unmappedTargetPolicy = ReportingPolicy.ERROR, nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS, uses = FileIdMapper.class)
+@Mapper(unmappedTargetPolicy = ReportingPolicy.ERROR, nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS, uses = { FileIdMapper.class,
+ UserIdMapper.class })
interface BescheidMapper {
@Mapping(target = "attachments", source = "grpcBescheid.attachmentsList")
Bescheid fromGrpc(GrpcBescheid grpcBescheid, String vorgangId);
List<FileId> fromProtocolStringList(ProtocolStringList value);
+
+ SentInfo fromGrpcSentInfo(GrpcSentInfo grpcSentInfo);
}
diff --git a/alfa-service/src/main/java/de/ozgcloud/alfa/bescheid/SentInfo.java b/alfa-service/src/main/java/de/ozgcloud/alfa/bescheid/SentInfo.java
new file mode 100644
index 0000000000000000000000000000000000000000..486b692cda613b6c18f6fed75e126b779234a077
--- /dev/null
+++ b/alfa-service/src/main/java/de/ozgcloud/alfa/bescheid/SentInfo.java
@@ -0,0 +1,15 @@
+package de.ozgcloud.alfa.bescheid;
+
+import java.time.ZonedDateTime;
+
+import de.ozgcloud.alfa.common.user.UserId;
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@Getter
+public class SentInfo {
+
+ private ZonedDateTime sentAt;
+ private UserId sentBy;
+}
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/BescheidMapperTest.java b/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/BescheidMapperTest.java
index e825c374cce0a8e55a656bdbf3656032a1f8526f..ddf307c06f9dc8460ab0d7f311b3c7f01b081bb2 100644
--- a/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/BescheidMapperTest.java
+++ b/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/BescheidMapperTest.java
@@ -4,6 +4,8 @@ import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
+import java.time.ZonedDateTime;
+
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.mapstruct.factory.Mappers;
@@ -11,12 +13,16 @@ import org.mockito.InjectMocks;
import org.mockito.Mock;
import de.ozgcloud.alfa.common.binaryfile.FileIdMapper;
+import de.ozgcloud.alfa.common.user.UserId;
+import de.ozgcloud.alfa.common.user.UserIdMapper;
import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
class BescheidMapperTest {
@Mock
private FileIdMapper fileIdMapper;
+ @Mock
+ private UserIdMapper userIdMapper;
@InjectMocks
private final BescheidMapper mapper = Mappers.getMapper(BescheidMapper.class);
@@ -88,6 +94,30 @@ class BescheidMapperTest {
assertThat(bescheid.getStatus()).isEqualTo(BescheidTestFactory.STATUS);
}
+ @Nested
+ class TestMapSentInfo {
+ private final SentInfo expectedSentInfo = SentInfoTestFactory.createBuilder()
+ .sentAt(ZonedDateTime.parse(GrpcSentInfoTestFactory.SENT_AT))
+ .sentBy(UserId.from(GrpcSentInfoTestFactory.SENT_BY))
+ .build();
+
+ @Test
+ void shouldMapSentBy() {
+ when(userIdMapper.fromString(GrpcSentInfoTestFactory.SENT_BY)).thenCallRealMethod();
+
+ var bescheid = map();
+
+ assertThat(bescheid.getSentInfo().getSentBy()).isEqualTo(expectedSentInfo.getSentBy());
+ }
+
+ @Test
+ void shouldMapSentAt() {
+ var bescheid = map();
+
+ assertThat(bescheid.getSentInfo().getSentAt()).isEqualTo(expectedSentInfo.getSentAt());
+ }
+ }
+
private Bescheid map() {
return mapper.fromGrpc(GrpcBescheidTestFactory.create(), VorgangHeaderTestFactory.ID);
}
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/BescheidTestFactory.java b/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/BescheidTestFactory.java
index 557f2a7b3eb170feae123c4afe34d7c030b47db3..55c6be1a2e8a53828688b492fd815d6c92bbcd3b 100644
--- a/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/BescheidTestFactory.java
+++ b/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/BescheidTestFactory.java
@@ -23,6 +23,7 @@ public class BescheidTestFactory {
public static final String NACHRICHT_TEXT = LoremIpsum.getInstance().getWords(10);
public static final String NACHRICHT_SUBJECT = LoremIpsum.getInstance().getWords(3);
public static final SendBy SEND_BY = SendBy.MANUAL;
+ public static final SentInfo SENT_INFO = SentInfoTestFactory.create();
public static Bescheid.BescheidBuilder createBuilder() {
return Bescheid.builder()
@@ -36,7 +37,8 @@ public class BescheidTestFactory {
.attachments(ATTACHMENTS)
.nachrichtText(NACHRICHT_TEXT)
.nachrichtSubject(NACHRICHT_SUBJECT)
- .sendBy(SEND_BY);
+ .sendBy(SEND_BY)
+ .sentInfo(SENT_INFO);
}
public static Bescheid create() {
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/GrpcBescheidTestFactory.java b/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/GrpcBescheidTestFactory.java
index 4ee81e36e98a17bea65d0f9472ae31b693ac5f73..fe0b433c030563f152f66ea4f12d94a8c0c3964c 100644
--- a/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/GrpcBescheidTestFactory.java
+++ b/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/GrpcBescheidTestFactory.java
@@ -3,6 +3,7 @@ package de.ozgcloud.alfa.bescheid;
import java.util.List;
import de.ozgcloud.bescheid.GrpcBescheid;
+import de.ozgcloud.bescheid.GrpcSentInfo;
import de.ozgcloud.common.datatype.StringBasedValue;
public class GrpcBescheidTestFactory {
@@ -14,6 +15,7 @@ public class GrpcBescheidTestFactory {
public static final List<String> ATTACHMENTS = BescheidTestFactory.ATTACHMENTS.stream().map(StringBasedValue::toString).toList();
public static final String NACHRICHT_TEXT = BescheidTestFactory.NACHRICHT_TEXT;
public static final String NACHRICHT_SUBJECT = BescheidTestFactory.NACHRICHT_SUBJECT;
+ public static final GrpcSentInfo SENT_INFO = GrpcSentInfoTestFactory.create();
public static GrpcBescheid create() {
return createBuilder().build();
@@ -29,6 +31,7 @@ public class GrpcBescheidTestFactory {
.addAllAttachments(ATTACHMENTS)
.setNachrichtText(NACHRICHT_TEXT)
.setNachrichtSubject(NACHRICHT_SUBJECT)
- .setSendBy(BescheidTestFactory.SEND_BY.toString());
+ .setSendBy(BescheidTestFactory.SEND_BY.toString())
+ .setSentInfo(SENT_INFO);
}
}
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/GrpcSentInfoTestFactory.java b/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/GrpcSentInfoTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf0dc48600671fa22a54fb1b33d9093632eb7cfb
--- /dev/null
+++ b/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/GrpcSentInfoTestFactory.java
@@ -0,0 +1,22 @@
+package de.ozgcloud.alfa.bescheid;
+
+import java.time.ZonedDateTime;
+
+import de.ozgcloud.alfa.common.user.GrpcUserTestFactory;
+import de.ozgcloud.bescheid.GrpcSentInfo;
+
+public class GrpcSentInfoTestFactory {
+
+ public static final String SENT_AT = ZonedDateTime.now().toString();
+ public static final String SENT_BY = GrpcUserTestFactory.ID;
+
+ public static GrpcSentInfo create() {
+ return createBuilder().build();
+ }
+
+ public static GrpcSentInfo.Builder createBuilder() {
+ return GrpcSentInfo.newBuilder()
+ .setSentAt(SENT_AT)
+ .setSentBy(SENT_BY);
+ }
+}
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/SentInfoTestFactory.java b/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/SentInfoTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..e7d5f826f2518ca17801dcabae6bc0d1695e5347
--- /dev/null
+++ b/alfa-service/src/test/java/de/ozgcloud/alfa/bescheid/SentInfoTestFactory.java
@@ -0,0 +1,22 @@
+package de.ozgcloud.alfa.bescheid;
+
+import java.time.ZonedDateTime;
+
+import de.ozgcloud.alfa.common.user.UserId;
+import de.ozgcloud.alfa.common.user.UserProfileTestFactory;
+
+public class SentInfoTestFactory {
+
+ public static final ZonedDateTime SENT_AT = ZonedDateTime.now();
+ public static final UserId SENT_BY = UserProfileTestFactory.ID;
+
+ public static SentInfo create() {
+ return createBuilder().build();
+ }
+
+ public static SentInfo.SentInfoBuilder createBuilder() {
+ return SentInfo.builder()
+ .sentAt(SENT_AT)
+ .sentBy(SENT_BY);
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/BescheidExportData.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/BescheidExportData.java
new file mode 100644
index 0000000000000000000000000000000000000000..ece5ee2c105749cdd5dbf2059d6ae969e8abfb35
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/BescheidExportData.java
@@ -0,0 +1,19 @@
+package de.ozgcloud.alfa.bescheid;
+
+import java.util.List;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.xoev.xdomea.DokumentType;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Singular;
+
+@Builder
+@Getter
+public class BescheidExportData {
+
+ @Singular
+ private List<DokumentType> dokumentTypes;
+ @Singular
+ private List<OzgFile> files;
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/BescheidExportInput.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/BescheidExportInput.java
new file mode 100644
index 0000000000000000000000000000000000000000..2eaa029e52aa5080b6aabcc85a611af051072b00
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/BescheidExportInput.java
@@ -0,0 +1,8 @@
+package de.ozgcloud.alfa.bescheid;
+
+import java.util.List;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+
+record BescheidExportInput(Bescheid bescheid, String organisationseinheitenId, List<OzgFile> files) {
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/DokumentTypeBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/DokumentTypeBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a049e49cd45a920d3f64a456ace9351348bc4a3
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/DokumentTypeBuilder.java
@@ -0,0 +1,83 @@
+package de.ozgcloud.alfa.bescheid;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import org.apache.commons.lang3.StringUtils;
+
+import de.ozgcloud.alfa.common.AnlageDokumentTypeBuilder;
+import de.ozgcloud.alfa.common.DateConverter;
+import de.ozgcloud.alfa.common.IdentifikationObjektTypeBuilder;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.AnlageDokumentType;
+import de.xoev.xdomea.DokumentType;
+import de.xoev.xdomea.HistorienProtokollInformationType;
+
+class DokumentTypeBuilder {
+ private static final String TYP = "Bescheid";
+ private static final Map<Boolean, String> BEMERKUNG = Map.of(true, "Bescheid wurde genehmigt.", false, "Bescheid wurde abgelehnt.");
+ private static final Map<SendBy, String> AKTION = Map.of(SendBy.MANUAL, "Bescheid gespeichert", SendBy.NACHRICHT,
+ "Bescheid an Antragsteller gesendet");
+
+ private Bescheid bescheid;
+ private String organisationsEinheitenId;
+ private String fullName;
+ private List<OzgFile> files;
+
+ public static DokumentTypeBuilder builder() {
+ return new DokumentTypeBuilder();
+ }
+
+ public DokumentTypeBuilder withBescheid(Bescheid bescheid) {
+ this.bescheid = bescheid;
+ return this;
+ }
+
+ public DokumentTypeBuilder withOrganisationseinheitenId(String organisationsEinheitenId) {
+ this.organisationsEinheitenId = organisationsEinheitenId;
+ return this;
+ }
+
+ public DokumentTypeBuilder withFullName(String fullName) {
+ this.fullName = fullName;
+ return this;
+ }
+
+ public DokumentTypeBuilder withFiles(List<OzgFile> files) {
+ this.files = files;
+ return this;
+ }
+
+ public DokumentType build() {
+ var dokumentType = new DokumentType();
+ dokumentType.setIdentifikation(IdentifikationObjektTypeBuilder.builder().withObjectID(bescheid.getId()).build());
+ dokumentType.setTyp(TYP);
+ dokumentType.setBezug(StringUtils.defaultString(bescheid.getNachrichtSubject()));
+ dokumentType.setAllgemeineMetadaten(createAllgemeineMetadaten());
+ dokumentType.getHistorienProtokollInformation().add(createHistorienProtokollInformation());
+ Optional.ofNullable(files).orElseGet(Collections::emptyList).stream().map(this::createAnlage).forEach(dokumentType.getAnlage()::add);
+ return dokumentType;
+ }
+
+ AllgemeineMetadatenType createAllgemeineMetadaten() {
+ var metadaten = new AllgemeineMetadatenType();
+ metadaten.setBemerkung(BEMERKUNG.get(bescheid.getBewilligt()));
+ return metadaten;
+ }
+
+ HistorienProtokollInformationType createHistorienProtokollInformation() {
+ var protokollInfo = new HistorienProtokollInformationType();
+ protokollInfo.setMetadatumName(StringUtils.defaultString(bescheid.getNachrichtText()));
+ protokollInfo.setAkteur(fullName + "; " + organisationsEinheitenId);
+ protokollInfo.setDatumUhrzeit(DateConverter.toXmlGregorianCalendar(bescheid.getSentInfo().getSentAt()));
+ protokollInfo.setAktion(AKTION.get(bescheid.getSendBy()));
+ return protokollInfo;
+ }
+
+ AnlageDokumentType createAnlage(OzgFile ozgFile) {
+ return AnlageDokumentTypeBuilder.builder().withOzgFile(ozgFile).build();
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/ExportBescheidService.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/ExportBescheidService.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d66ad45f4a52597ed08fa0aa41aa6a93489e45c
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/ExportBescheidService.java
@@ -0,0 +1,66 @@
+package de.ozgcloud.alfa.bescheid;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.springframework.stereotype.Service;
+
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.user.UserService;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.DokumentType;
+import lombok.RequiredArgsConstructor;
+
+@Service
+@RequiredArgsConstructor
+public class ExportBescheidService {
+ private final BescheidService bescheidService;
+ private final BinaryFileService binaryFileService;
+ private final DocumentService documentService;
+ private final UserService userService;
+
+ public BescheidExportData createExportData(VorgangWithEingang vorgang) {
+ var builder = BescheidExportData.builder();
+ getBescheids(vorgang.getId())
+ .forEach(bescheid -> addBescheidExportData(createBescheidExportInput(bescheid, vorgang), builder));
+ return builder.build();
+ }
+
+ Stream<Bescheid> getBescheids(String vorgangId) {
+ return bescheidService.findByVorgangId(vorgangId).filter(bescheid -> BescheidStatus.SENT == bescheid.getStatus());
+ }
+
+ BescheidExportInput createBescheidExportInput(Bescheid bescheid, VorgangWithEingang vorgang) {
+ return new BescheidExportInput(bescheid, vorgang.getOrganisationseinheitenID(), getAttachments(bescheid));
+ }
+
+ List<OzgFile> getAttachments(Bescheid bescheid) {
+ return binaryFileService.getFiles(bescheid.getAttachments()).toList();
+ }
+
+ void addBescheidExportData(BescheidExportInput input, BescheidExportData.BescheidExportDataBuilder builder) {
+ builder.dokumentType(buildDokumentType(input))
+ .file(getDocument(input.bescheid()))
+ .files(input.files());
+ }
+
+ OzgFile getDocument(Bescheid bescheid) {
+ var document = documentService.getDocument(bescheid.getBescheidDocument());
+ return binaryFileService.getFile(document.getFileId());
+ }
+
+ DokumentType buildDokumentType(BescheidExportInput input) {
+ var builder = DokumentTypeBuilder.builder();
+ builder.withBescheid(input.bescheid())
+ .withFiles(input.files())
+ .withFullName(getFullName(input.bescheid()))
+ .withOrganisationseinheitenId(input.organisationseinheitenId());
+ return builder.build();
+ }
+
+ String getFullName(Bescheid bescheid) {
+ return userService.getById(bescheid.getSentInfo().getSentBy()).getFullName();
+ }
+
+}
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 1901488403a73ecd3e03efdd0bfd5271dd289aee..dea71b8ecffd2e0a22f6d3f69107ffa6ce0e6b39 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
@@ -15,6 +15,7 @@ import java.util.zip.ZipOutputStream;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
+import de.ozgcloud.alfa.bescheid.ExportBescheidService;
import de.ozgcloud.alfa.common.ExportFilenameGenerator;
import de.ozgcloud.alfa.common.file.OzgFile;
import de.ozgcloud.alfa.file.ExportFileService;
@@ -44,6 +45,7 @@ class ExportService {
private final ExportHistorieService exportHistorieService;
private final ExportKommentarService exportKommentarService;
private final ExportNachrichtService exportNachrichtService;
+ private final ExportBescheidService exportBescheidService;
public void writeExport(String vorgangId, String filenameId, OutputStream out) {
var exportData = collectExportData(vorgangId, filenameId);
@@ -55,6 +57,7 @@ class ExportService {
var vorgang = exportVorgangService.getVorgang(vorgangId);
var kommentarsData = exportKommentarService.createExportData(vorgang);
var postfachMailData = exportNachrichtService.createExportData(vorgang);
+ var bescheidData = exportBescheidService.createExportData(vorgang);
var representations = exportFileService.getRepresentations(vorgang).toList();
var attachments = exportFileService.getAttachments(vorgang).toList();
var formEngineName = getFormEngineName(vorgang);
@@ -67,6 +70,7 @@ class ExportService {
.withHistorie(exportHistorieService.createHistorienProtokollInformationTypes(vorgang).toList())
.withKommentare(kommentarsData.getDokumentTypes())
.withPostfachMails(postfachMailData.getDokumentTypes())
+ .withBescheids(bescheidData.getDokumentTypes())
.build();
var exportFiles = Stream
.of(representations.stream(), attachments.stream(),
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 ae734f35808d7cff6c55d85f30070b136539630f..644265c961a0a0d943d721d12d5f1c5c9d33d067 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
@@ -23,6 +23,7 @@ class XdomeaNachrichtBuilder {
private List<DokumentType> attachments = Collections.emptyList();
private List<DokumentType> kommentare = Collections.emptyList();
private List<DokumentType> postfachMails = Collections.emptyList();
+ private List<DokumentType> bescheids = Collections.emptyList();
private List<HistorienProtokollInformationType> historie = Collections.emptyList();
public static XdomeaNachrichtBuilder builder() {
@@ -69,6 +70,11 @@ class XdomeaNachrichtBuilder {
return this;
}
+ public XdomeaNachrichtBuilder withBescheids(List<DokumentType> bescheids) {
+ this.bescheids = bescheids;
+ return this;
+ }
+
public AbgabeAbgabe0401 build() {
addVorgangDokumente();
addVorgangChangeHistory();
@@ -80,6 +86,7 @@ class XdomeaNachrichtBuilder {
attachments.forEach(vorgang.getDokument()::add);
kommentare.forEach(vorgang.getDokument()::add);
postfachMails.forEach(vorgang.getDokument()::add);
+ bescheids.forEach(vorgang.getDokument()::add);
}
void addVorgangChangeHistory() {
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/DokumentTypeBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/DokumentTypeBuilder.java
index 89520bf24ce8e36c574b7402b77696ea56384b60..1a82477373682b64b4581952fb28345ac655937c 100644
--- a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/DokumentTypeBuilder.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/DokumentTypeBuilder.java
@@ -1,6 +1,7 @@
package de.ozgcloud.alfa.postfach;
import java.time.ZonedDateTime;
+import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@@ -61,7 +62,8 @@ class DokumentTypeBuilder {
.build());
dokumentType.setTyp(TYP);
dokumentType.getHistorienProtokollInformation().add(createHistorienProtokollInformation());
- ozgFileAttachments.stream().map(this::createAnlage).forEach(dokumentType.getAnlage()::add);
+ Optional.ofNullable(ozgFileAttachments).orElseGet(Collections::emptyList).stream().map(this::createAnlage)
+ .forEach(dokumentType.getAnlage()::add);
return dokumentType;
}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/BescheidExportDataTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/BescheidExportDataTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8750928c920bc87ecdc49b5fe79aeae537cc26b
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/BescheidExportDataTestFactory.java
@@ -0,0 +1,22 @@
+package de.ozgcloud.alfa.bescheid;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.export.DokumentTypeTestFactory;
+import de.xoev.xdomea.DokumentType;
+
+public class BescheidExportDataTestFactory {
+
+ public static final DokumentType DOKUMENT_TYPE = DokumentTypeTestFactory.create();
+ public static final OzgFile OZG_FILE = OzgFileTestFactory.createWithUniqueId();
+
+ public static BescheidExportData create() {
+ return createBuilder().build();
+ }
+
+ public static BescheidExportData.BescheidExportDataBuilder createBuilder() {
+ return BescheidExportData.builder()
+ .dokumentType(DOKUMENT_TYPE)
+ .file(OZG_FILE);
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/BescheidExportInputTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/BescheidExportInputTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..0051086930bbbe289f68949dc244733f7e5ab218
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/BescheidExportInputTestFactory.java
@@ -0,0 +1,19 @@
+package de.ozgcloud.alfa.bescheid;
+
+import java.util.List;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.vorgang.ZustaendigeStelleTestFactory;
+
+public class BescheidExportInputTestFactory {
+
+ public final static Bescheid BESCHEID = BescheidTestFactory.create();
+ public final static String ORGANISATIONSEINHEITEN_ID = ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID;
+ public final static List<OzgFile> ATTACHMENTS = List.of(OzgFileTestFactory.createWithUniqueId());
+
+ public static BescheidExportInput create() {
+ return new BescheidExportInput(BESCHEID, ORGANISATIONSEINHEITEN_ID, ATTACHMENTS);
+ }
+
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/DokumentTypeBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/DokumentTypeBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9c4bfd7a1291e1a06ea16cc902d2ee60019f4a41
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/DokumentTypeBuilderTest.java
@@ -0,0 +1,293 @@
+package de.ozgcloud.alfa.bescheid;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+
+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 com.thedeanda.lorem.LoremIpsum;
+
+import de.ozgcloud.alfa.common.AnlageDokumentTypeBuilder;
+import de.ozgcloud.alfa.common.AnlageDokumentTypeTestFactory;
+import de.ozgcloud.alfa.common.DateConverter;
+import de.ozgcloud.alfa.common.HistorienProtokollInformationTypeTestFactory;
+import de.ozgcloud.alfa.common.IdentifikationObjektTypeBuilder;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.common.user.UserProfileTestFactory;
+import de.ozgcloud.alfa.export.AllgemeineMetadatenTypeTestFactory;
+import de.ozgcloud.alfa.export.IdentifikationObjektTypeTestFactory;
+import de.ozgcloud.alfa.vorgang.ZustaendigeStelleTestFactory;
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.AnlageDokumentType;
+import de.xoev.xdomea.HistorienProtokollInformationType;
+import de.xoev.xdomea.IdentifikationObjektType;
+
+class DokumentTypeBuilderTest {
+ private final String fullName = UserProfileTestFactory.FULLNAME;
+ private final Bescheid bescheid = BescheidTestFactory.create();
+ private final OzgFile document = OzgFileTestFactory.create();
+
+ @Spy
+ private final DokumentTypeBuilder builder = DokumentTypeBuilder.builder()
+ .withBescheid(bescheid)
+ .withOrganisationseinheitenId(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID)
+ .withFullName(fullName)
+ .withFiles(List.of(document));
+
+ @Nested
+ class TestBuild {
+ private static final String TYP = "Bescheid";
+
+ private MockedStatic<IdentifikationObjektTypeBuilder> identifikationObjektTypeBuilderMockedStatic;
+ @Mock
+ private IdentifikationObjektTypeBuilder identifikationObjektTypeBuilder;
+ private final IdentifikationObjektType identifikationObjektType = IdentifikationObjektTypeTestFactory.create();
+
+ private final HistorienProtokollInformationType historienProtokollInformation = HistorienProtokollInformationTypeTestFactory.create();
+ private final AllgemeineMetadatenType metadatenType = AllgemeineMetadatenTypeTestFactory.create();
+ private final AnlageDokumentType anlageDokumentDocument = AnlageDokumentTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ identifikationObjektTypeBuilderMockedStatic = mockStatic(IdentifikationObjektTypeBuilder.class);
+ identifikationObjektTypeBuilderMockedStatic.when(IdentifikationObjektTypeBuilder::builder).thenReturn(identifikationObjektTypeBuilder);
+ when(identifikationObjektTypeBuilder.withObjectID(BescheidTestFactory.ID)).thenReturn(identifikationObjektTypeBuilder);
+ when(identifikationObjektTypeBuilder.build()).thenReturn(identifikationObjektType);
+ doReturn(anlageDokumentDocument).when(builder).createAnlage(document);
+ }
+
+ @AfterEach
+ void tearDown() {
+ identifikationObjektTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldSetObjectId() {
+ builder.build();
+
+ verify(identifikationObjektTypeBuilder).withObjectID(bescheid.getId());
+ }
+
+ @Test
+ void shouldBuildIdentifikationObjectType() {
+ builder.build();
+
+ verify(identifikationObjektTypeBuilder).build();
+ }
+
+ @Test
+ void shouldHaveIdentifikation() {
+ var dokument = builder.build();
+
+ assertThat(dokument.getIdentifikation()).isEqualTo(identifikationObjektType);
+ }
+
+ @Test
+ void shouldHaveTyp() {
+ var dokument = builder.build();
+
+ assertThat(dokument.getTyp()).isEqualTo(TYP);
+ }
+
+ @Test
+ void shouldHaveBezugWithBetreff() {
+ var subject = LoremIpsum.getInstance().getWords(5);
+ builder.withBescheid(BescheidTestFactory.createBuilder().nachrichtSubject(subject).build());
+
+ var dokument = builder.build();
+
+ assertThat(dokument.getBezug()).isEqualTo(subject);
+ }
+
+ @Test
+ void shouldHaveEmptyBezug() {
+ builder.withBescheid(BescheidTestFactory.createBuilder().nachrichtSubject(null).build());
+
+ var dokument = builder.build();
+
+ assertThat(dokument.getBezug()).isEmpty();
+ }
+
+ @Test
+ void shouldHaveMetadaten() {
+ doReturn(metadatenType).when(builder).createAllgemeineMetadaten();
+
+ var dokument = builder.build();
+
+ assertThat(dokument.getAllgemeineMetadaten()).isEqualTo(metadatenType);
+ }
+
+ @Test
+ void shouldHaveHistorienProtokollInformation() {
+ doReturn(historienProtokollInformation).when(builder).createHistorienProtokollInformation();
+
+ var dokument = builder.build();
+
+ assertThat(dokument.getHistorienProtokollInformation()).containsExactly(historienProtokollInformation);
+ }
+
+ @Nested
+ class TestWithoutAnlage {
+ @Test
+ void shouldHaveNoAnlage() {
+ var dokument = builder.build();
+
+ assertThat(dokument.getAnlage()).containsExactly(anlageDokumentDocument);
+ }
+
+ }
+
+ @Nested
+ class TestWithOneAnlage {
+ private final AnlageDokumentType anlageDokumentAttachment = AnlageDokumentTypeTestFactory.create();
+ private final OzgFile attachment = OzgFileTestFactory.create();
+
+ @Test
+ void shouldHaveOneAnlage() {
+ builder.withFiles(List.of(document, attachment));
+ doReturn(anlageDokumentAttachment).when(builder).createAnlage(attachment);
+
+ var dokument = builder.build();
+
+ assertThat(dokument.getAnlage()).containsExactly(anlageDokumentDocument, anlageDokumentAttachment);
+ }
+ }
+ }
+
+ @Nested
+ class TestCreateAllgemeineMetadaten {
+ private final static String GENEHMIGT = "Bescheid wurde genehmigt.";
+ private final static String ABGELEHNT = "Bescheid wurde abgelehnt.";
+
+ @Test
+ void shouldHaveBemerkungGenehmigt() {
+ builder.withBescheid(BescheidTestFactory.createBuilder().bewilligt(true).build());
+
+ var metadaten = builder.createAllgemeineMetadaten();
+
+ assertThat(metadaten.getBemerkung()).isEqualTo(GENEHMIGT);
+ }
+
+ @Test
+ void shouldHaveBemerkungAbgelehnt() {
+ builder.withBescheid(BescheidTestFactory.createBuilder().bewilligt(false).build());
+
+ var metadaten = builder.createAllgemeineMetadaten();
+
+ assertThat(metadaten.getBemerkung()).isEqualTo(ABGELEHNT);
+ }
+ }
+
+ @Nested
+ class TestCreateHistorienProtokollInformation {
+ private final static String GESPEICHERT = "Bescheid gespeichert";
+ private final static String GESENDET = "Bescheid an Antragsteller gesendet";
+
+ @Test
+ void shouldHaveMetadatumName() {
+ var text = LoremIpsum.getInstance().getHtmlParagraphs(1, 1);
+ builder.withBescheid(BescheidTestFactory.createBuilder().nachrichtText(text).build());
+
+ var protokollInfo = builder.createHistorienProtokollInformation();
+
+ assertThat(protokollInfo.getMetadatumName()).isEqualTo(text);
+ }
+
+ @Test
+ void shouldHaveEmptyMetadatumName() {
+ builder.withBescheid(BescheidTestFactory.createBuilder().nachrichtText(null).build());
+
+ var protokollInfo = builder.createHistorienProtokollInformation();
+
+ assertThat(protokollInfo.getMetadatumName()).isEmpty();
+ }
+
+ @Test
+ void shouldHaveAkteur() {
+ var protokollInfo = builder.createHistorienProtokollInformation();
+
+ assertThat(protokollInfo.getAkteur()).isEqualTo(fullName + "; " + ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID);
+ }
+
+ @Test
+ void shouldHaveDatumUhrzeit() {
+ var protokollInfo = builder.createHistorienProtokollInformation();
+
+ assertThat(protokollInfo.getDatumUhrzeit()).isEqualTo(DateConverter.toXmlGregorianCalendar(SentInfoTestFactory.SENT_AT));
+ }
+
+ @Test
+ void shouldHaveGespeichertInAktion() {
+ builder.withBescheid(BescheidTestFactory.createBuilder().sendBy(SendBy.MANUAL).build());
+
+ var protokollInfo = builder.createHistorienProtokollInformation();
+
+ assertThat(protokollInfo.getAktion()).isEqualTo(GESPEICHERT);
+ }
+
+ @Test
+ void shouldHaveGesendetInAktion() {
+ builder.withBescheid(BescheidTestFactory.createBuilder().sendBy(SendBy.NACHRICHT).build());
+
+ var protokollInfo = builder.createHistorienProtokollInformation();
+
+ assertThat(protokollInfo.getAktion()).isEqualTo(GESENDET);
+ }
+ }
+
+ @Nested
+ class TestCreateAnlage {
+ private MockedStatic<AnlageDokumentTypeBuilder> anlageDokumentTypeBuilderMockedStatic;
+ @Mock
+ private AnlageDokumentTypeBuilder anlageDokumentTypeBuilder;
+ private final AnlageDokumentType expectedAnlage = AnlageDokumentTypeTestFactory.create();
+ private final OzgFile attachment = OzgFileTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ anlageDokumentTypeBuilderMockedStatic = mockStatic(AnlageDokumentTypeBuilder.class);
+ anlageDokumentTypeBuilderMockedStatic.when(AnlageDokumentTypeBuilder::builder).thenReturn(anlageDokumentTypeBuilder);
+ when(anlageDokumentTypeBuilder.withOzgFile(attachment)).thenReturn(anlageDokumentTypeBuilder);
+ when(anlageDokumentTypeBuilder.build()).thenReturn(expectedAnlage);
+ }
+
+ @AfterEach
+ void tearDown() {
+ anlageDokumentTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldSetOzgFile() {
+ callCreateAnlage();
+
+ verify(anlageDokumentTypeBuilder).withOzgFile(attachment);
+ }
+
+ @Test
+ void shouldBuildAnlageDokumentType() {
+ callCreateAnlage();
+
+ verify(anlageDokumentTypeBuilder).build();
+ }
+
+ @Test
+ void shouldReturnBuiltAnlage() {
+ var resultAnlage = callCreateAnlage();
+
+ assertThat(resultAnlage).isEqualTo(expectedAnlage);
+ }
+
+ private AnlageDokumentType callCreateAnlage() {
+ return builder.createAnlage(attachment);
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/ExportBescheidServiceTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/ExportBescheidServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..126aab998d2b46b39b5b8e5c2340f6200fe2adee
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/ExportBescheidServiceTest.java
@@ -0,0 +1,425 @@
+package de.ozgcloud.alfa.bescheid;
+
+import static org.assertj.core.api.Assertions.*;
+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 org.mockito.Spy;
+
+import de.ozgcloud.alfa.bescheid.BescheidExportData.BescheidExportDataBuilder;
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+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.common.user.UserProfile;
+import de.ozgcloud.alfa.common.user.UserProfileTestFactory;
+import de.ozgcloud.alfa.common.user.UserService;
+import de.ozgcloud.alfa.export.DokumentTypeTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.DokumentType;
+
+class ExportBescheidServiceTest {
+
+ @InjectMocks
+ @Spy
+ private ExportBescheidService service;
+
+ @Mock
+ private BescheidService bescheidService;
+
+ @Mock
+ private BinaryFileService binaryFileService;
+
+ @Mock
+ private DocumentService documentService;
+
+ @Mock
+ private UserService userService;
+
+ @Nested
+ class TestCreateExportData {
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final Bescheid bescheid = BescheidTestFactory.create();
+ private final BescheidExportData exportData = BescheidExportDataTestFactory.create();
+ private final BescheidExportInput input = BescheidExportInputTestFactory.create();
+
+ private MockedStatic<BescheidExportData> bescheidExportDataMockedStatic;
+ @Mock
+ private BescheidExportDataBuilder exportDataBuilder;
+
+ @BeforeEach
+ void setUpMocks() {
+ bescheidExportDataMockedStatic = mockStatic(BescheidExportData.class);
+ bescheidExportDataMockedStatic.when(BescheidExportData::builder).thenReturn(exportDataBuilder);
+
+ doReturn(Stream.of(bescheid)).when(service).getBescheids(vorgang.getId());
+ when(exportDataBuilder.build()).thenReturn(exportData);
+ doReturn(input).when(service).createBescheidExportInput(bescheid, vorgang);
+ doNothing().when(service).addBescheidExportData(input, exportDataBuilder);
+ }
+
+ @AfterEach
+ void tearDown() {
+ bescheidExportDataMockedStatic.close();
+ }
+
+ @Test
+ void shouldGetBescheids() {
+ callService();
+
+ verify(service).getBescheids(vorgang.getId());
+ }
+
+ @Test
+ void shouldCreateInputData() {
+ callService();
+
+ verify(service).createBescheidExportInput(bescheid, vorgang);
+ }
+
+ @Test
+ void shouldAddInputToBuilder() {
+ callService();
+
+ verify(service).addBescheidExportData(input, exportDataBuilder);
+ }
+
+ @Test
+ void shouldBuildExportData() {
+ callService();
+
+ verify(exportDataBuilder).build();
+ }
+
+ @Test
+ void shouldReturnBuiltExportData() {
+ var result = callService();
+
+ assertThat(result).isEqualTo(exportData);
+ }
+
+ private BescheidExportData callService() {
+ return service.createExportData(vorgang);
+ }
+ }
+
+ @Nested
+ class TestGetBescheids {
+ private final String vorgangId = VorgangHeaderTestFactory.ID;
+ private final Bescheid bescheid = BescheidTestFactory.createBuilder().status(BescheidStatus.SENT).build();
+ private final Bescheid bescheidDraft = BescheidTestFactory.createBuilder().status(BescheidStatus.DRAFT).build();
+
+ @Test
+ void shouldCallBescheidService() {
+ callService();
+
+ verify(bescheidService).findByVorgangId(vorgangId);
+ }
+
+ @Test
+ void shouldReturnBescheids() {
+ when(bescheidService.findByVorgangId(vorgangId)).thenReturn(Stream.of(bescheid));
+
+ var resultBescheids = callService();
+
+ assertThat(resultBescheids).containsExactly(bescheid);
+ }
+
+ @Test
+ void shouldNotReturnDrafts() {
+ when(bescheidService.findByVorgangId(vorgangId)).thenReturn(Stream.of(bescheid, bescheidDraft));
+
+ var resultBescheids = callService();
+
+ assertThat(resultBescheids).containsExactly(bescheid);
+ }
+
+ private Stream<Bescheid> callService() {
+ return service.getBescheids(vorgangId);
+ }
+ }
+
+ @Nested
+ class TestCreateBescheidExportInput {
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final Bescheid bescheid = BescheidTestFactory.create();
+
+ @BeforeEach
+ void setUpMocks() {
+ doReturn(BescheidExportInputTestFactory.ATTACHMENTS).when(service).getAttachments(bescheid);
+ }
+
+ @Test
+ void shouldCallGetAttachents() {
+ callService();
+
+ verify(service).getAttachments(bescheid);
+ }
+
+ @Test
+ void shouldReturnInputData() {
+ var resultInput = callService();
+
+ assertThat(resultInput).usingRecursiveComparison().isEqualTo(BescheidExportInputTestFactory.create());
+ }
+
+ private BescheidExportInput callService() {
+ return service.createBescheidExportInput(bescheid, vorgang);
+ }
+ }
+
+ @Nested
+ class TestGetDocument {
+ private final Bescheid bescheid = BescheidTestFactory.create();
+ private final Document document = DocumentTestFactory.create();
+ private final OzgFile ozgDocument = OzgFileTestFactory.create();
+
+ @BeforeEach
+ void setUpMock() {
+ when(documentService.getDocument(bescheid.getBescheidDocument())).thenReturn(document);
+ }
+
+ @Test
+ void shouldCallDocumentService() {
+ callService();
+
+ verify(documentService).getDocument(bescheid.getBescheidDocument());
+ }
+
+ @Test
+ void shouldCallBinaryFileService() {
+ callService();
+
+ verify(binaryFileService).getFile(DocumentTestFactory.FILE_ID);
+ }
+
+ @Test
+ void shouldReturnOzgFile() {
+ when(binaryFileService.getFile(DocumentTestFactory.FILE_ID)).thenReturn(ozgDocument);
+
+ var resultDocument = callService();
+
+ assertThat(resultDocument).isEqualTo(ozgDocument);
+ }
+
+ private OzgFile callService() {
+ return service.getDocument(bescheid);
+ }
+ }
+
+ @Nested
+ class TestGetAttachments {
+ private final Bescheid bescheid = BescheidTestFactory.create();
+ private final List<FileId> fileIds = BescheidTestFactory.ATTACHMENTS;
+
+ @Test
+ void shouldCallBinaryFileServiceGetFile() {
+ service.getAttachments(bescheid);
+
+ verify(binaryFileService).getFiles(fileIds);
+ }
+
+ @Test
+ void shouldReturnGottenOzgFiles() {
+ var expectedOzgFile = OzgFileTestFactory.create();
+ when(binaryFileService.getFiles(fileIds)).thenReturn(Stream.of(expectedOzgFile));
+
+ var resultOzgFiles = service.getAttachments(bescheid);
+
+ assertThat(resultOzgFiles).containsExactly(expectedOzgFile);
+ }
+ }
+
+ @Nested
+ class TestAddBescheidExportData {
+ private final List<OzgFile> attachments = BescheidExportInputTestFactory.ATTACHMENTS;
+ private final OzgFile document = OzgFileTestFactory.create();
+ private final DokumentType dokumentType = DokumentTypeTestFactory.create();
+ private final BescheidExportInput exportInput = BescheidExportInputTestFactory.create();
+
+ @Mock
+ private BescheidExportDataBuilder exportDataBuilder;
+
+ @BeforeEach
+ void setUpMocks() {
+ doReturn(dokumentType).when(service).buildDokumentType(exportInput);
+ doReturn(document).when(service).getDocument(exportInput.bescheid());
+ when(exportDataBuilder.dokumentType(dokumentType)).thenReturn(exportDataBuilder);
+ when(exportDataBuilder.file(document)).thenReturn(exportDataBuilder);
+ }
+
+ @Test
+ void shouldGetDocument() {
+ callService();
+
+ verify(service).getDocument(exportInput.bescheid());
+ }
+
+ @Test
+ void shouldAddDocumentToBuilder() {
+ callService();
+
+ verify(exportDataBuilder).file(document);
+ }
+
+ @Test
+ void shouldAddAttachmentsToBuilder() {
+ callService();
+
+ verify(exportDataBuilder).files(attachments);
+ }
+
+ @Test
+ void shouldBuildDokumentType() {
+ callService();
+
+ verify(service).buildDokumentType(exportInput);
+ }
+
+ @Test
+ void shouldAddDokumentTypeToBuilder() {
+ callService();
+
+ verify(exportDataBuilder).dokumentType(dokumentType);
+ }
+
+ private void callService() {
+ service.addBescheidExportData(exportInput, exportDataBuilder);
+ }
+ }
+
+ @Nested
+ class TestBuildDokumentType {
+ private final BescheidExportInput exportInput = BescheidExportInputTestFactory.create();
+ private final Bescheid bescheid = BescheidExportInputTestFactory.BESCHEID;
+ private final List<OzgFile> attachments = BescheidExportInputTestFactory.ATTACHMENTS;
+ private final String fullName = UserProfileTestFactory.FULLNAME;
+
+ private MockedStatic<DokumentTypeBuilder> dokumentTypeBuilderMockedStatic;
+ @Mock
+ private DokumentTypeBuilder dokumentTypeBuilder;
+
+ @BeforeEach
+ void setUp() {
+ dokumentTypeBuilderMockedStatic = mockStatic(DokumentTypeBuilder.class);
+ dokumentTypeBuilderMockedStatic.when(DokumentTypeBuilder::builder).thenReturn(dokumentTypeBuilder);
+
+ when(dokumentTypeBuilder.withBescheid(bescheid)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.withFiles(attachments)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.withFullName(fullName)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.withOrganisationseinheitenId(BescheidExportInputTestFactory.ORGANISATIONSEINHEITEN_ID))
+ .thenReturn(dokumentTypeBuilder);
+
+ doReturn(fullName).when(service).getFullName(bescheid);
+ }
+
+ @AfterEach
+ void tearDown() {
+ dokumentTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldCallBuilder() {
+ callService();
+
+ dokumentTypeBuilderMockedStatic.verify(DokumentTypeBuilder::builder);
+ }
+
+ @Test
+ void shouldBuildWithBescheid() {
+ callService();
+
+ verify(dokumentTypeBuilder).withBescheid(bescheid);
+ }
+
+ @Test
+ void shouldBuildWithOzgFiles() {
+ callService();
+
+ verify(dokumentTypeBuilder).withFiles(attachments);
+ }
+
+ @Test
+ void shouldGetFullName() {
+ callService();
+
+ verify(service).getFullName(bescheid);
+ }
+
+ @Test
+ void shouldBuildWithFullName() {
+ callService();
+
+ verify(dokumentTypeBuilder).withFullName(fullName);
+ }
+
+ @Test
+ void shouldBuildWithOrganisationseinheitenId() {
+ callService();
+
+ verify(dokumentTypeBuilder).withOrganisationseinheitenId(BescheidExportInputTestFactory.ORGANISATIONSEINHEITEN_ID);
+ }
+
+ @Test
+ void shouldBuild() {
+ callService();
+
+ verify(dokumentTypeBuilder).build();
+ }
+
+ @Test
+ void shouldReturnBuiltDokumentType() {
+ var expectedDokumentType = DokumentTypeTestFactory.create();
+ when(dokumentTypeBuilder.build()).thenReturn(expectedDokumentType);
+
+ var resultDokumentType = callService();
+
+ assertThat(resultDokumentType).isEqualTo(expectedDokumentType);
+ }
+
+ private DokumentType callService() {
+ return service.buildDokumentType(exportInput);
+ }
+ }
+
+ @Nested
+ class TestGetFullName {
+ private final Bescheid bescheid = BescheidTestFactory.create();
+ private final UserProfile userProfile = UserProfileTestFactory.create();
+ private final String expectedFullName = UserProfileTestFactory.FULLNAME;
+
+ @BeforeEach
+ void mockUserService() {
+ when(userService.getById(SentInfoTestFactory.SENT_BY)).thenReturn(userProfile);
+ }
+
+ @Test
+ void shouldCallUserServiceGetbyId() {
+ callService();
+
+ verify(userService).getById(SentInfoTestFactory.SENT_BY);
+ }
+
+ @Test
+ void shouldReturnOptionalOfUserProfile() {
+ var fullName = callService();
+
+ assertThat(fullName).isEqualTo(expectedFullName);
+ }
+
+ private String callService() {
+ return service.getFullName(bescheid);
+ }
+ }
+}
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 1ce3deed159608cf3f609716ee204f03b701520c..4cf6d583e155be78b4d3d0020b700cf9723c6232 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
@@ -16,6 +16,8 @@ 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.bescheid.BescheidExportDataTestFactory;
+import de.ozgcloud.alfa.bescheid.ExportBescheidService;
import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
import de.ozgcloud.alfa.common.user.UserProfileTestFactory;
@@ -50,6 +52,8 @@ class ExportServiceITCase {
@MockBean
private ExportNachrichtService exportNachrichtService;
@MockBean
+ private ExportBescheidService exportBescheidService;
+ @MockBean
private UserService userService;
@Autowired
private ExportService exportService;
@@ -71,6 +75,7 @@ class ExportServiceITCase {
when(exportHistorieService.createHistorienProtokollInformationTypes(vorgang)).thenReturn(Stream.empty());
when(exportKommentarService.createExportData(vorgang)).thenReturn(KommentarsExportDataTestFactory.create());
when(exportNachrichtService.createExportData(vorgang)).thenReturn(PostfachMailExportDataTestFactory.create());
+ when(exportBescheidService.createExportData(vorgang)).thenReturn(BescheidExportDataTestFactory.create());
}
@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 60f57250052a7d1f28655002f3fff6324fbe9f93..4cb6ebb420df44f1ea730e236351db5b1e781a13 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
@@ -26,6 +26,9 @@ import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Spy;
+import de.ozgcloud.alfa.bescheid.BescheidExportData;
+import de.ozgcloud.alfa.bescheid.BescheidExportDataTestFactory;
+import de.ozgcloud.alfa.bescheid.ExportBescheidService;
import de.ozgcloud.alfa.common.ExportFilenameGenerator;
import de.ozgcloud.alfa.common.HistorienProtokollInformationTypeTestFactory;
import de.ozgcloud.alfa.common.TestUtils;
@@ -74,6 +77,8 @@ class ExportServiceTest {
private ExportKommentarService exportKommentarService;
@Mock
private ExportNachrichtService exportNachrichtService;
+ @Mock
+ private ExportBescheidService exportBescheidService;
@DisplayName("Write exportToXdomea")
@Nested
@@ -139,6 +144,7 @@ class ExportServiceTest {
HistorienProtokollInformationTypeTestFactory.create());
private final KommentarsExportData kommentarsExportData = KommentarsExportDataTestFactory.create();
private final PostfachMailExportData postfachMailExportData = PostfachMailExportDataTestFactory.create();
+ private final BescheidExportData bescheidExportData = BescheidExportDataTestFactory.create();
@Mock
private XdomeaNachrichtBuilder xdomeaNachrichtBuilder;
@@ -151,6 +157,7 @@ class ExportServiceTest {
setUpExportHistorieService();
setUpExportKommentarService();
setUpExportNachrichtService();
+ setUpExportBescheidService();
doReturn(FILE_NAME).when(service).buildXmlFilename(FILENAME_ID);
doReturn(EingangHeaderTestFactory.FORM_ENGINE_NAME).when(service).getFormEngineName(vorgang);
@@ -174,6 +181,7 @@ class ExportServiceTest {
when(xdomeaNachrichtBuilder.withHistorie(historienProtokollInformationTypes)).thenReturn(xdomeaNachrichtBuilder);
when(xdomeaNachrichtBuilder.withKommentare(kommentarsExportData.getDokumentTypes())).thenReturn(xdomeaNachrichtBuilder);
when(xdomeaNachrichtBuilder.withPostfachMails(postfachMailExportData.getDokumentTypes())).thenReturn(xdomeaNachrichtBuilder);
+ when(xdomeaNachrichtBuilder.withBescheids(bescheidExportData.getDokumentTypes())).thenReturn(xdomeaNachrichtBuilder);
xdomeaNachrichtBuilderMockedStatic.when(XdomeaNachrichtBuilder::builder).thenReturn(xdomeaNachrichtBuilder);
when(xdomeaNachrichtBuilder.build()).thenReturn(abgabe);
}
@@ -201,6 +209,10 @@ class ExportServiceTest {
when(exportNachrichtService.createExportData(vorgang)).thenReturn(postfachMailExportData);
}
+ private void setUpExportBescheidService() {
+ when(exportBescheidService.createExportData(vorgang)).thenReturn(bescheidExportData);
+ }
+
@AfterEach
void tearDown() {
xdomeaNachrichtBuilderMockedStatic.close();
@@ -311,6 +323,13 @@ class ExportServiceTest {
verify(xdomeaNachrichtBuilder).withPostfachMails(postfachMailExportData.getDokumentTypes());
}
+ @Test
+ void shouldSetBescheids() {
+ callService();
+
+ verify(xdomeaNachrichtBuilder).withBescheids(bescheidExportData.getDokumentTypes());
+ }
+
@Test
void shouldSetAktenzeichen() {
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 5e7b4ea241d987d8713cab382e833fde766882cb..c524f4f7c82761a842f02be8f42dde2b2159af53 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
@@ -104,6 +104,7 @@ class XdomeaNachrichtBuilderTest {
private final List<DokumentType> attachments = List.of(DokumentTypeTestFactory.create(), DokumentTypeTestFactory.create());
private final List<DokumentType> kommentare = List.of(DokumentTypeTestFactory.create(), DokumentTypeTestFactory.create());
private final List<DokumentType> postfachMails = List.of(DokumentTypeTestFactory.create(), DokumentTypeTestFactory.create());
+ private final List<DokumentType> bescheids = List.of(DokumentTypeTestFactory.create(), DokumentTypeTestFactory.create());
@Test
void shouldAddRepresentations() {
@@ -133,6 +134,13 @@ class XdomeaNachrichtBuilderTest {
assertThat(vorgangType.getDokument()).isEqualTo(postfachMails);
}
+ @Test
+ void shouldAddBescheids() {
+ builder.withBescheids(bescheids).addVorgangDokumente();
+
+ assertThat(vorgangType.getDokument()).isEqualTo(bescheids);
+ }
+
}
@Nested
diff --git a/pom.xml b/pom.xml
index aa707651cdc6c5f822f0dcb2ba123c0ce4e2aa2e..4be17f3b766715348c9d8a217b700df8b37e4b59 100644
--- a/pom.xml
+++ b/pom.xml
@@ -50,7 +50,7 @@
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
- <vorgang-manager.version>2.7.0</vorgang-manager.version>
+ <vorgang-manager.version>2.8.0-SNAPSHOT</vorgang-manager.version>
<nachrichten-manager.version>2.7.0</nachrichten-manager.version>
<ozgcloud-common-pdf.version>3.0.1</ozgcloud-common-pdf.version>
<user-manager.version>2.2.0</user-manager.version>