diff --git a/nachrichten-manager-interface/src/main/protobuf/antragraum.model.proto b/nachrichten-manager-interface/src/main/protobuf/antragraum.model.proto
index 282543d0303eaf7f5eae47245f936f1d1d75fb46..80234a7f435bc161ae2df951c7f0226d2503d9c9 100644
--- a/nachrichten-manager-interface/src/main/protobuf/antragraum.model.proto
+++ b/nachrichten-manager-interface/src/main/protobuf/antragraum.model.proto
@@ -61,6 +61,7 @@ message GrpcRueckfrageAnswer {
string rueckfrageId = 1;
string answerText = 2;
repeated string attachmentFileId = 3;
+ string sentAt = 4;
}
message GrpcSendRueckfrageAnswerResponse {
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumGrpcService.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumGrpcService.java
index fc8b30283be549db5c634fdc032b169cd3017348..3684ce3c2f2c29b5dda1966a5e48bcc4d1ed0cbd 100644
--- a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumGrpcService.java
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumGrpcService.java
@@ -24,11 +24,13 @@
package de.ozgcloud.nachrichten.antragraum;
import java.time.ZonedDateTime;
+import java.util.List;
import java.util.stream.Stream;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import de.ozgcloud.common.errorhandling.TechnicalException;
import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
import io.grpc.stub.StreamObserver;
import lombok.RequiredArgsConstructor;
@@ -43,27 +45,25 @@ class AntragraumGrpcService extends AntragraumServiceGrpc.AntragraumServiceImplB
@Override
public void findRueckfragen(GrpcFindRueckfragenRequest request, StreamObserver<GrpcFindRueckfragenResponse> streamObserver) {
- var rueckfragen = buildGrpcRueckfrage(request.getSamlToken());
- var response = GrpcFindRueckfragenResponse.newBuilder().addAllRueckfrage(rueckfragen.toList()).build();
+ var rueckfragen = antragraumService.findRueckfragen(request.getSamlToken())
+ .map(mapper::toGrpc)
+ .map(rueckfrage -> addAnswers(request.getSamlToken(), rueckfrage));
- streamObserver.onNext(response);
+ streamObserver.onNext(buildFindRueckfragenResponse(rueckfragen));
streamObserver.onCompleted();
}
- Stream<GrpcRueckfrage> buildGrpcRueckfrage(String samlToken) {
- return antragraumService.findRueckfragen(samlToken).map(mapper::toGrpc)
- .map(rueckfrage -> addAnswers(samlToken, rueckfrage));
-
+ private GrpcRueckfrage addAnswers(String samlToken, GrpcRueckfrage rueckfrage) {
+ return rueckfrage.toBuilder().addAllAnswers(findRueckfrageAnswers(samlToken, rueckfrage.getId())).build();
}
- private GrpcRueckfrage addAnswers(String samlToken, GrpcRueckfrage rueckfrage) {
- return rueckfrage.toBuilder()
- .addAllAnswers(buildGrpcRueckfrageAnswer(samlToken, rueckfrage.getId()).toList())
- .build();
+ List<GrpcRueckfrageAnswer> findRueckfrageAnswers(String samlToken, String rueckfrageId) {
+ return antragraumService.findAnswers(samlToken, rueckfrageId).map(mapper::toRueckfrageAnswer).toList();
}
- Stream<GrpcRueckfrageAnswer> buildGrpcRueckfrageAnswer(String samlToken, String rueckfrageId) {
- return antragraumService.findAnswers(samlToken, rueckfrageId).map(mapper::toRueckfrageAnswer);
+ private GrpcFindRueckfragenResponse buildFindRueckfragenResponse(Stream<GrpcRueckfrage> rueckfragen) {
+ return GrpcFindRueckfragenResponse.newBuilder().addAllRueckfrage(rueckfragen.toList()).build();
+
}
@Override
@@ -77,13 +77,14 @@ class AntragraumGrpcService extends AntragraumServiceGrpc.AntragraumServiceImplB
streamObserver.onCompleted();
}
- PostfachNachricht getRueckfrage(String samlToken, String postfachNachrichtId) {
+ Rueckfrage getRueckfrage(String samlToken, String postfachNachrichtId) {
return antragraumService.findRueckfragen(samlToken)
- .filter(postfachNachricht -> StringUtils.equals(postfachNachricht.getId(), postfachNachrichtId))
- .toList().getFirst();
+ .filter(rueckfrage -> StringUtils.equals(rueckfrage.getId(), postfachNachrichtId))
+ .findFirst()
+ .orElseThrow(() -> new TechnicalException(String.format("No rueckfrage found for answer with id %s", postfachNachrichtId)));
}
- PostfachNachricht enrichRueckfrageAnswer(PostfachNachricht answer, PostfachNachricht rueckfrage) {
+ PostfachNachricht enrichRueckfrageAnswer(PostfachNachricht answer, Rueckfrage rueckfrage) {
return answer.toBuilder()
.vorgangId(rueckfrage.getVorgangId())
.postfachAddress(rueckfrage.getPostfachAddress())
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumNachrichtMapper.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumNachrichtMapper.java
index 25500e8ea808c7e719814d097e7b25587873e8ff..a85826691734ae04456d98860d7f77c6a620fdd6 100644
--- a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumNachrichtMapper.java
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumNachrichtMapper.java
@@ -33,7 +33,6 @@ import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
@Mapper(collectionMappingStrategy = CollectionMappingStrategy.ADDER_PREFERRED, nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS)
interface AntragraumNachrichtMapper {
- String DEFAULT_STATUS = "NEU";
@Mapping(target = "mergeFrom", ignore = true)
@Mapping(target = "clearField", ignore = true)
@@ -53,12 +52,9 @@ interface AntragraumNachrichtMapper {
@Mapping(target = "answersBuilderList", ignore = true)
@Mapping(target = "answersList", ignore = true)
@Mapping(target = "answersOrBuilderList", ignore = true)
- @Mapping(source = "sentAt", target = "sentAt", dateFormat = "yyyy-MM-dd'T'HH:mm:ss")
- @Mapping(source = "mailBody", target = "text")
- @Mapping(source = "subject", target = "vorgangName")
- @Mapping(source = "attachments", target = "attachmentFileIdList")
- @Mapping(target = "status", constant = DEFAULT_STATUS)
- GrpcRueckfrage toGrpc(PostfachNachricht postfachNachricht);
+ @Mapping(target = "sentAt", source = "sentAt", dateFormat = "yyyy-MM-dd'T'HH:mm:ss")
+ @Mapping(target = "attachmentFileIdList", source = "attachments")
+ GrpcRueckfrage toGrpc(Rueckfrage rueckfrage);
@Mapping(target = "referencedNachricht", ignore = true)
@Mapping(target = "mailBody", source = "answerText")
@@ -72,7 +68,6 @@ interface AntragraumNachrichtMapper {
@Mapping(target = "postfachAddress", ignore = true)
@Mapping(target = "postfachId", ignore = true)
@Mapping(target = "replyOption", constant = "FORBIDDEN")
- @Mapping(target = "sentAt", ignore = true)
@Mapping(target = "sentSuccessful", constant = "true")
@Mapping(target = "subject", constant = "Antwort") // TODO klären
@Mapping(target = "vorgangId", ignore = true)
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumService.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumService.java
index a8e360bb49179070e1878c31810a10d5f9eac6f0..28365c34793bf7e58cd938809bb65afc9d7184d9 100644
--- a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumService.java
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/AntragraumService.java
@@ -25,6 +25,10 @@ package de.ozgcloud.nachrichten.antragraum;
import static java.util.Objects.*;
+import java.time.ZonedDateTime;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Optional;
import java.util.stream.Stream;
import jakarta.annotation.PostConstruct;
@@ -34,6 +38,7 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Service;
import de.ozgcloud.nachrichten.NachrichtenManagerProperties;
+import de.ozgcloud.nachrichten.common.vorgang.VorgangService;
import de.ozgcloud.nachrichten.postfach.PersistPostfachNachrichtService;
import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
import lombok.RequiredArgsConstructor;
@@ -45,12 +50,7 @@ import lombok.extern.log4j.Log4j2;
@ConditionalOnProperty(AntragraumProperties.PROPERTY_ANTRAGSRAUM_URL)
public class AntragraumService {
- static final String BAYERN_ID = "BayernID";
-
- private final PersistPostfachNachrichtService postfachNachrichtService;
- private final Saml2Verifier verifier;
- private final Saml2Parser parser;
- private final Saml2Decrypter decrypter;
+ static final String BAYERN_ID_SERVICE_KONTO_TYPE = "BayernID";
static final String USER_NOTIFICATION_TEMPLATE = """
Guten Tag,
@@ -63,8 +63,15 @@ public class AntragraumService {
Ihre digitale Verwaltung
""";
+ private final PersistPostfachNachrichtService postfachNachrichtService;
+ private final Saml2Verifier verifier;
+ private final Saml2Parser parser;
+ private final Saml2Decrypter decrypter;
+
private final AntragraumProperties properties;
private final NachrichtenManagerProperties nachrichtenManagerProperties;
+ private final RueckfrageMapper rueckfrageMapper;
+ private final VorgangService vorgangService;
@PostConstruct
void init() {
@@ -86,11 +93,38 @@ public class AntragraumService {
return USER_NOTIFICATION_TEMPLATE.formatted(getAntragsraumUrl());
}
- public Stream<PostfachNachricht> findRueckfragen(String samlToken) {
+ public Stream<Rueckfrage> findRueckfragen(String samlToken) {
verifyToken(samlToken);
- var postfachId = decrypter.decryptPostfachId(parser.parse(samlToken));
- return postfachNachrichtService.findRueckfragen(BAYERN_ID, postfachId);
+ var rueckfragen = postfachNachrichtService.findRueckfragen(BAYERN_ID_SERVICE_KONTO_TYPE, getPostfachId(samlToken))
+ .map(rueckfrageMapper::fromPostfachNachricht)
+ .map(rueckfrage -> enrichByAnswers(rueckfrage, samlToken)).toList();
+ return enrichRueckfragen(rueckfragen);
+ }
+
+ Rueckfrage enrichByAnswers(Rueckfrage rueckfrage, String samlToken) {
+ var rueckfrageBuilder = rueckfrage.toBuilder();
+
+ getFirstSentAt(findAnswers(samlToken, rueckfrage.getId()))
+ .ifPresent(firstSentAt -> rueckfrageBuilder.answeredAt(firstSentAt).status(RueckfrageStatus.ANSWERED));
+
+ return rueckfrageBuilder.build();
+ }
+
+ Optional<ZonedDateTime> getFirstSentAt(Stream<PostfachNachricht> answers) {
+ return answers.sorted(Comparator.comparing(PostfachNachricht::getSentAt)).map(PostfachNachricht::getSentAt).findFirst();
+ }
+
+ Stream<Rueckfrage> enrichRueckfragen(List<Rueckfrage> rueckfragen) {
+ if (rueckfragen.isEmpty()) {
+ return Stream.empty();
+ }
+ return addVorgangName(rueckfragen, rueckfragen.getFirst().getVorgangId());
+ }
+
+ Stream<Rueckfrage> addVorgangName(List<Rueckfrage> rueckfragen, String vorgangId) {
+ var vorgang = vorgangService.getVorgang(vorgangId);
+ return rueckfragen.stream().map(rueckfrage -> rueckfrage.toBuilder().vorgangName(vorgang.getName()).build());
}
public String sendRueckfrageAnswer(String samlToken, String rueckfrageId, PostfachNachricht nachricht) {
@@ -101,9 +135,8 @@ public class AntragraumService {
public Stream<PostfachNachricht> findAnswers(String samlToken, String rueckfrageId) {
verifyToken(samlToken);
- var postfachId = decrypter.decryptPostfachId(parser.parse(samlToken));
- return postfachNachrichtService.findAnswers(BAYERN_ID, postfachId, rueckfrageId);
+ return postfachNachrichtService.findAnswers(BAYERN_ID_SERVICE_KONTO_TYPE, getPostfachId(samlToken), rueckfrageId);
}
void verifyToken(String token) {
@@ -113,4 +146,7 @@ public class AntragraumService {
}
}
+ String getPostfachId(String samlToken) {
+ return decrypter.decryptPostfachId(parser.parse(samlToken));
+ }
}
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/Rueckfrage.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/Rueckfrage.java
new file mode 100644
index 0000000000000000000000000000000000000000..d9526d0badf420305fb2c8b34af3bfedc64c498a
--- /dev/null
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/Rueckfrage.java
@@ -0,0 +1,30 @@
+package de.ozgcloud.nachrichten.antragraum;
+
+import java.time.ZonedDateTime;
+import java.util.Collections;
+import java.util.List;
+
+import de.ozgcloud.nachrichten.postfach.PostfachAddress;
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder(toBuilder = true)
+class Rueckfrage {
+
+ private String id;
+ private String vorgangId;
+ private String vorgangName;
+
+ private PostfachAddress postfachAddress;
+ private ZonedDateTime sentAt;
+ private ZonedDateTime answeredAt;
+
+ @Builder.Default
+ private RueckfrageStatus status = RueckfrageStatus.NEW;
+ private String text;
+
+ @Builder.Default
+ private List<String> attachments = Collections.emptyList();
+
+}
\ No newline at end of file
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/RueckfrageMapper.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/RueckfrageMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..439961c766b90a6952961e916a0117210115dc63
--- /dev/null
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/RueckfrageMapper.java
@@ -0,0 +1,22 @@
+package de.ozgcloud.nachrichten.antragraum;
+
+import org.mapstruct.CollectionMappingStrategy;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.NullValueCheckStrategy;
+import org.mapstruct.ReportingPolicy;
+
+import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
+
+@Mapper(collectionMappingStrategy = CollectionMappingStrategy.ADDER_PREFERRED, //
+ unmappedTargetPolicy = ReportingPolicy.WARN, //
+ nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS)
+interface RueckfrageMapper {
+
+ @Mapping(target = "answeredAt", ignore = true)
+ @Mapping(target = "status", ignore = true)
+ @Mapping(target = "text", source = "mailBody")
+ @Mapping(target = "vorgangName", ignore = true)
+ Rueckfrage fromPostfachNachricht(PostfachNachricht postfachNachricht);
+
+}
\ No newline at end of file
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/RueckfrageStatus.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/RueckfrageStatus.java
new file mode 100644
index 0000000000000000000000000000000000000000..57d19462a4c20591ed619f4583318d79fe7571d2
--- /dev/null
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/antragraum/RueckfrageStatus.java
@@ -0,0 +1,5 @@
+package de.ozgcloud.nachrichten.antragraum;
+
+enum RueckfrageStatus {
+ NEW, ANSWERED
+}
\ No newline at end of file
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/common/vorgang/Vorgang.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/common/vorgang/Vorgang.java
new file mode 100644
index 0000000000000000000000000000000000000000..881bcaa9be2912afa4b5c4824489875bc60b42ca
--- /dev/null
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/common/vorgang/Vorgang.java
@@ -0,0 +1,12 @@
+package de.ozgcloud.nachrichten.common.vorgang;
+
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class Vorgang {
+
+ private String id;
+ private String name;
+}
\ No newline at end of file
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/common/vorgang/VorgangMapper.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/common/vorgang/VorgangMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce9a492ae09e8f2207a848f1aa018ae4825b983c
--- /dev/null
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/common/vorgang/VorgangMapper.java
@@ -0,0 +1,12 @@
+package de.ozgcloud.nachrichten.common.vorgang;
+
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+
+import de.ozgcloud.vorgang.vorgang.GrpcVorgangWithEingang;
+
+@Mapper(unmappedTargetPolicy = ReportingPolicy.WARN)
+interface VorgangMapper {
+
+ Vorgang fromVorgangWithEingang(GrpcVorgangWithEingang vorgangWithEingang);
+}
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/VorgangRemoteService.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/common/vorgang/VorgangRemoteService.java
similarity index 77%
rename from nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/VorgangRemoteService.java
rename to nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/common/vorgang/VorgangRemoteService.java
index 73342e11305eeb33c6813434e3b5d8203a82ce8b..890beb2cda4f9cbc38d9f965f46beaa68040f185 100644
--- a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/VorgangRemoteService.java
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/common/vorgang/VorgangRemoteService.java
@@ -21,16 +21,19 @@
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
-package de.ozgcloud.nachrichten.postfach;
+package de.ozgcloud.nachrichten.common.vorgang;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
+import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import de.ozgcloud.nachrichten.common.grpc.NachrichtenCallContextAttachingInterceptor;
+import de.ozgcloud.nachrichten.postfach.FindVorgangIterator;
+import de.ozgcloud.vorgang.vorgang.GrpcFindVorgangWithEingangRequest;
import de.ozgcloud.vorgang.vorgang.GrpcVorgangHeader;
import de.ozgcloud.vorgang.vorgang.VorgangServiceGrpc.VorgangServiceBlockingStub;
import net.devh.boot.grpc.client.inject.GrpcClient;
@@ -40,6 +43,8 @@ class VorgangRemoteService {
@GrpcClient("vorgang-manager")
private VorgangServiceBlockingStub vorgangServiceStub;
+ @Autowired
+ private VorgangMapper mapper;
public Stream<String> findVorgangIds(String servicekontoType, String postfachId) {
return buildStream(servicekontoType, postfachId).map(GrpcVorgangHeader::getId);
@@ -54,7 +59,16 @@ class VorgangRemoteService {
return new FindVorgangIterator(getVorgangServiceStub(), servicekontoType, postfachId);
}
+ public Vorgang getVorgang(String vorgangId) {
+ var response = getVorgangServiceStub().findVorgangWithEingang(buildFindVorgangWithEingangRequest(vorgangId));
+ return mapper.fromVorgangWithEingang(response.getVorgangWithEingang());
+ }
+
VorgangServiceBlockingStub getVorgangServiceStub() {
return vorgangServiceStub.withInterceptors(new NachrichtenCallContextAttachingInterceptor());
}
-}
+
+ GrpcFindVorgangWithEingangRequest buildFindVorgangWithEingangRequest(String vorgangId) {
+ return GrpcFindVorgangWithEingangRequest.newBuilder().setId(vorgangId).build();
+ }
+}
\ No newline at end of file
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/common/vorgang/VorgangService.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/common/vorgang/VorgangService.java
new file mode 100644
index 0000000000000000000000000000000000000000..f89f448d7d5358675cb2e1187107417701012357
--- /dev/null
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/common/vorgang/VorgangService.java
@@ -0,0 +1,24 @@
+package de.ozgcloud.nachrichten.common.vorgang;
+
+import java.util.stream.Stream;
+
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Service;
+
+import lombok.RequiredArgsConstructor;
+
+@Service
+@RequiredArgsConstructor
+public class VorgangService {
+
+ @Qualifier("findVorgangRemoteService")
+ private final VorgangRemoteService remoteService;
+
+ public Stream<String> findVorgangIds(String servicekontoType, String postfachId) {
+ return remoteService.findVorgangIds(servicekontoType, postfachId);
+ }
+
+ public Vorgang getVorgang(String vorgangId) {
+ return remoteService.getVorgang(vorgangId);
+ }
+}
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImpl.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImpl.java
index a4d9682eb1ed6ea4437fabfeb3534b35e9ef2515..aedd1434632b2a94e75bf3ee9d9b4a94a4ea7607 100644
--- a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImpl.java
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImpl.java
@@ -39,6 +39,7 @@ import de.ozgcloud.apilib.common.command.OzgCloudCommand;
import de.ozgcloud.apilib.common.command.OzgCloudCommandService;
import de.ozgcloud.apilib.vorgang.OzgCloudVorgangId;
import de.ozgcloud.nachrichten.NachrichtenManagerConfiguration;
+import de.ozgcloud.nachrichten.common.vorgang.VorgangService;
@Service
@Primary
@@ -56,8 +57,7 @@ public class PersistPostfachNachrichtServiceImpl implements PersistPostfachNachr
static final String ITEM_FIELD = "item";
@Autowired
- @Qualifier("findVorgangRemoteService")
- private VorgangRemoteService vorgangRemoteService;
+ private VorgangService vorgangService;
@Autowired
@Qualifier(NachrichtenManagerConfiguration.OZG_CLOUD_COMMAND_SERVICE_NAME)
@@ -124,7 +124,7 @@ public class PersistPostfachNachrichtServiceImpl implements PersistPostfachNachr
@Override
public Stream<PostfachNachricht> findRueckfragen(String servicekontoType, String postfachId) {
- return vorgangRemoteService.findVorgangIds(servicekontoType, postfachId)
+ return vorgangService.findVorgangIds(servicekontoType, postfachId)
.flatMap(attachedItemRemoteService::findReplyAllowedPostfachNachrichts);
}
@@ -157,12 +157,12 @@ public class PersistPostfachNachrichtServiceImpl implements PersistPostfachNachr
@Override
public Stream<PostfachNachricht> findAnswers(String serviceKontoType, String postfachId, String rueckfrageId) {
- return findPostfachNachricht(serviceKontoType, postfachId, rueckfrageId)
+ return findPostfachNachricht(serviceKontoType, postfachId)
.filter(postfachNachricht -> hasMatchingReferenceNachrichtId(postfachNachricht, rueckfrageId));
}
- private Stream<PostfachNachricht> findPostfachNachricht(String serviceKontoType, String postfachId, String rueckfrageId) {
- return vorgangRemoteService.findVorgangIds(serviceKontoType, postfachId).flatMap(attachedItemRemoteService::findByVorgangId);
+ private Stream<PostfachNachricht> findPostfachNachricht(String serviceKontoType, String postfachId) {
+ return vorgangService.findVorgangIds(serviceKontoType, postfachId).flatMap(attachedItemRemoteService::findByVorgangId);
}
private boolean hasMatchingReferenceNachrichtId(PostfachNachricht postfachNachricht, String postfachNachrichtId) {
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachNachrichtMapper.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachNachrichtMapper.java
index 2d30f00558cde6cf423a3760c2e05c17bd95331d..c2783a9fbe16fea8bf94b4740b5f304e937d3547 100644
--- a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachNachrichtMapper.java
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachNachrichtMapper.java
@@ -71,7 +71,6 @@ public abstract class PostfachNachrichtMapper {
return StringBasedIdentifier.builder().postfachId(postfachId).build();
}
- @SuppressWarnings("unchecked")
public GrpcPostfachMail fromMap(Map<String, Object> mailMap) {
var postfachMailBuilder = GrpcPostfachMail.newBuilder()
.setId(MapUtils.getString(mailMap, PostfachNachricht.FIELD_ID))
@@ -86,8 +85,12 @@ public abstract class PostfachNachrichtMapper {
.setDirection(GrpcDirection.valueOf(MapUtils.getString(mailMap, PostfachNachricht.FIELD_DIRECTION)))
.setSubject(MapUtils.getString(mailMap, PostfachNachricht.FIELD_SUBJECT))
.setMailBody(MapUtils.getString(mailMap, PostfachNachricht.FIELD_MAIL_BODY))
- .setReplyOption(MapUtils.getString(mailMap, PostfachNachricht.FIELD_REPLY_OPTION))
- .addAllAttachment(getAttachments(mailMap));
+ .setReplyOption(MapUtils.getString(mailMap, PostfachNachricht.FIELD_REPLY_OPTION));
+
+ Optional.ofNullable(mailMap.get(PostfachNachricht.FIELD_ATTACHMENTS))
+ .filter(this::doesAttachmentsExists)
+ .map(this::getAttachments)
+ .ifPresent(postfachMailBuilder::addAllAttachment);
Optional.ofNullable(getAsMap(mailMap, PostfachNachricht.POSTFACH_ADDRESS_FIELD))
.filter(MapUtils::isNotEmpty)
@@ -97,13 +100,15 @@ public abstract class PostfachNachrichtMapper {
return postfachMailBuilder.build();
}
- private Iterable<String> getAttachments(Map<String, Object> map) {
- var attachments = map.getOrDefault(PostfachNachricht.FIELD_ATTACHMENTS, Collections.emptyList());
+ private boolean doesAttachmentsExists(Object attachments) {
+ return (attachments instanceof String attachment && StringUtils.isNotBlank(attachment)) || attachments instanceof Collection;
+ }
+
+ private Iterable<String> getAttachments(Object attachments) {
if (attachments instanceof String attachment) {
return Collections.singletonList(attachment);
}
return (Iterable<String>) attachments;
-
}
GrpcPostfachAddress buildGrpcPostfachAddress(Map<String, Object> postfachAddressMap) {
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/AntragraumGrpcServiceTest.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/AntragraumGrpcServiceTest.java
index e14177a773180e00b35acb87b676af648a5eb2e2..6b96cc3be43f4a2797608efb1350768c1c50f502 100644
--- a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/AntragraumGrpcServiceTest.java
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/AntragraumGrpcServiceTest.java
@@ -37,6 +37,7 @@ import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
+import de.ozgcloud.common.errorhandling.TechnicalException;
import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
import de.ozgcloud.nachrichten.postfach.PostfachNachrichtTestFactory;
import io.grpc.stub.StreamObserver;
@@ -44,53 +45,50 @@ import io.grpc.stub.StreamObserver;
class AntragraumGrpcServiceTest {
@Spy
@InjectMocks
- private AntragraumGrpcService antragsraumGrpcService;
+ private AntragraumGrpcService grpcService;
@Mock
- private AntragraumService antragraumService;
+ private AntragraumService service;
@Mock
- private AntragraumNachrichtMapper mapper;
+ private AntragraumNachrichtMapper nachrichtMapper;
@Nested
class TestFindRueckfragen {
- @Nested
- class TestFindRueckfrageGrpc {
- @Mock
- private StreamObserver<GrpcFindRueckfragenResponse> streamObserver;
+ @Mock
+ private StreamObserver<GrpcFindRueckfragenResponse> streamObserver;
- @BeforeEach
- void setup() {
- when(antragraumService.findRueckfragen(any())).thenReturn(Stream.of(PostfachNachrichtTestFactory.create()));
- when(mapper.toGrpc(any(PostfachNachricht.class))).thenReturn(GrpcRueckfrageTestFactory.create());
- }
+ @BeforeEach
+ void setup() {
+ when(service.findRueckfragen(any())).thenReturn(Stream.of(RueckfrageTestFactory.create()));
+ when(nachrichtMapper.toGrpc(any(Rueckfrage.class))).thenReturn(GrpcRueckfrageTestFactory.create());
+ }
- @Test
- void shouldCallMapper() {
- antragsraumGrpcService.findRueckfragen(GrpcFindRueckfrageRequestTestFactory.create(), streamObserver);
+ @Test
+ void shouldCallMapper() {
+ grpcService.findRueckfragen(GrpcFindRueckfrageRequestTestFactory.create(), streamObserver);
- verify(mapper).toGrpc(any(PostfachNachricht.class));
- }
+ verify(nachrichtMapper).toGrpc(any(Rueckfrage.class));
+ }
- @Test
- void shouldCallOnNext() {
- antragsraumGrpcService.findRueckfragen(GrpcFindRueckfrageRequestTestFactory.create(), streamObserver);
+ @Test
+ void shouldCallOnNext() {
+ grpcService.findRueckfragen(GrpcFindRueckfrageRequestTestFactory.create(), streamObserver);
- verify(streamObserver).onNext(any(GrpcFindRueckfragenResponse.class));
- }
+ verify(streamObserver).onNext(any(GrpcFindRueckfragenResponse.class));
+ }
- @Test
- void shouldCallOnCompleted() {
- antragsraumGrpcService.findRueckfragen(GrpcFindRueckfrageRequestTestFactory.create(), streamObserver);
+ @Test
+ void shouldCallOnCompleted() {
+ grpcService.findRueckfragen(GrpcFindRueckfrageRequestTestFactory.create(), streamObserver);
- verify(streamObserver).onCompleted();
- }
+ verify(streamObserver).onCompleted();
+ }
- @Test
- void shouldLoadAnswers() {
- antragsraumGrpcService.findRueckfragen(GrpcFindRueckfrageRequestTestFactory.create(), streamObserver);
+ @Test
+ void shouldLoadAnswers() {
+ grpcService.findRueckfragen(GrpcFindRueckfrageRequestTestFactory.create(), streamObserver);
- verify(antragraumService).findAnswers(GrpcFindRueckfrageRequestTestFactory.SAML_TOKEN, GrpcRueckfrageTestFactory.ID);
- }
+ verify(service).findAnswers(GrpcFindRueckfrageRequestTestFactory.SAML_TOKEN, GrpcRueckfrageTestFactory.ID);
}
}
@@ -100,28 +98,29 @@ class AntragraumGrpcServiceTest {
@Mock
private StreamObserver<GrpcSendRueckfrageAnswerResponse> streamObserver;
private PostfachNachricht postfachNachricht = PostfachNachrichtTestFactory.create();
+ private Rueckfrage rueckfrage = RueckfrageTestFactory.create();
@BeforeEach
void setup() {
- when(mapper.fromRueckfrageAnswer(any(GrpcRueckfrageAnswer.class))).thenReturn(postfachNachricht);
- when(antragraumService.sendRueckfrageAnswer(anyString(), anyString(), any(PostfachNachricht.class)))
+ when(nachrichtMapper.fromRueckfrageAnswer(any(GrpcRueckfrageAnswer.class))).thenReturn(postfachNachricht);
+ when(service.sendRueckfrageAnswer(anyString(), anyString(), any(PostfachNachricht.class)))
.thenReturn(UUID.randomUUID().toString());
- doReturn(postfachNachricht).when(antragsraumGrpcService).enrichRueckfrageAnswer(any(), any());
- doReturn(postfachNachricht).when(antragsraumGrpcService).getRueckfrage(any(), any());
+ doReturn(postfachNachricht).when(grpcService).enrichRueckfrageAnswer(any(), any());
+ doReturn(rueckfrage).when(grpcService).getRueckfrage(any(), any());
}
@Test
void shouldCallMapper() {
- antragsraumGrpcService.sendRueckfrageAnswer(GrpcSendRueckfrageAnswerRequestTestFactory.create(), streamObserver);
+ grpcService.sendRueckfrageAnswer(GrpcSendRueckfrageAnswerRequestTestFactory.create(), streamObserver);
- verify(mapper).fromRueckfrageAnswer(any(GrpcRueckfrageAnswer.class));
+ verify(nachrichtMapper).fromRueckfrageAnswer(any(GrpcRueckfrageAnswer.class));
}
@Test
void shouldGetRueckfrage() {
sendRueckfrageAnswer();
- verify(antragsraumGrpcService).getRueckfrage(GrpcSendRueckfrageAnswerRequestTestFactory.SAML_TOKEN,
+ verify(grpcService).getRueckfrage(GrpcSendRueckfrageAnswerRequestTestFactory.SAML_TOKEN,
GrpcRueckfrageAnswerTestFactory.RUECKFRAGE_ID);
}
@@ -129,32 +128,32 @@ class AntragraumGrpcServiceTest {
void shouldEnrichPostfachNachricht() {
sendRueckfrageAnswer();
- verify(antragsraumGrpcService).enrichRueckfrageAnswer(postfachNachricht, postfachNachricht);
+ verify(grpcService).enrichRueckfrageAnswer(postfachNachricht, rueckfrage);
}
@Test
void shouldCallAntragraumService() {
- antragsraumGrpcService.sendRueckfrageAnswer(GrpcSendRueckfrageAnswerRequestTestFactory.create(), streamObserver);
+ grpcService.sendRueckfrageAnswer(GrpcSendRueckfrageAnswerRequestTestFactory.create(), streamObserver);
- verify(antragraumService).sendRueckfrageAnswer(anyString(), anyString(), any(PostfachNachricht.class));
+ verify(service).sendRueckfrageAnswer(anyString(), anyString(), any(PostfachNachricht.class));
}
@Test
void shouldCallOnNext() {
- antragsraumGrpcService.sendRueckfrageAnswer(GrpcSendRueckfrageAnswerRequestTestFactory.create(), streamObserver);
+ grpcService.sendRueckfrageAnswer(GrpcSendRueckfrageAnswerRequestTestFactory.create(), streamObserver);
verify(streamObserver).onNext(any(GrpcSendRueckfrageAnswerResponse.class));
}
@Test
void shouldCallOnCompleted() {
- antragsraumGrpcService.sendRueckfrageAnswer(GrpcSendRueckfrageAnswerRequestTestFactory.create(), streamObserver);
+ grpcService.sendRueckfrageAnswer(GrpcSendRueckfrageAnswerRequestTestFactory.create(), streamObserver);
verify(streamObserver).onCompleted();
}
private void sendRueckfrageAnswer() {
- antragsraumGrpcService.sendRueckfrageAnswer(GrpcSendRueckfrageAnswerRequestTestFactory.create(), streamObserver);
+ grpcService.sendRueckfrageAnswer(GrpcSendRueckfrageAnswerRequestTestFactory.create(), streamObserver);
}
}
@@ -162,32 +161,38 @@ class AntragraumGrpcServiceTest {
@Nested
class TestGetRueckfrage {
- private final PostfachNachricht matchingPostfachNachricht = PostfachNachrichtTestFactory.createBuilder()
- .id(GrpcRueckfrageAnswerTestFactory.RUECKFRAGE_ID)
+ private final Rueckfrage matchingRueckfrage = RueckfrageTestFactory.createBuilder().id(GrpcRueckfrageAnswerTestFactory.RUECKFRAGE_ID)
.build();
- private final PostfachNachricht postfachNachricht = PostfachNachrichtTestFactory.create();
+ private final Rueckfrage rueckfrage = RueckfrageTestFactory.create();
@BeforeEach
void mock() {
- when(antragraumService.findRueckfragen(any())).thenReturn(Stream.of(postfachNachricht, matchingPostfachNachricht));
+ when(service.findRueckfragen(any())).thenReturn(Stream.of(rueckfrage, matchingRueckfrage));
}
@Test
void shouldCallService() {
getRueckfrage();
- verify(antragraumService).findRueckfragen(GrpcSendRueckfrageAnswerRequestTestFactory.SAML_TOKEN);
+ verify(service).findRueckfragen(GrpcSendRueckfrageAnswerRequestTestFactory.SAML_TOKEN);
}
@Test
void shouldReturnMatchingPostfachNachricht() {
var rueckfrage = getRueckfrage();
- assertThat(rueckfrage).isEqualTo(matchingPostfachNachricht);
+ assertThat(rueckfrage).isEqualTo(matchingRueckfrage);
+ }
+
+ @Test
+ void shouldThrowExceptionIfNoRueckfrageExists() {
+ when(service.findRueckfragen(any())).thenReturn(Stream.empty());
+
+ assertThatThrownBy(() -> getRueckfrage()).isInstanceOf(TechnicalException.class);
}
- private PostfachNachricht getRueckfrage() {
- return antragsraumGrpcService.getRueckfrage(GrpcSendRueckfrageAnswerRequestTestFactory.SAML_TOKEN,
+ private Rueckfrage getRueckfrage() {
+ return grpcService.getRueckfrage(GrpcSendRueckfrageAnswerRequestTestFactory.SAML_TOKEN,
GrpcRueckfrageAnswerTestFactory.RUECKFRAGE_ID);
}
}
@@ -202,25 +207,25 @@ class AntragraumGrpcServiceTest {
.sentAt(null)
.build();
- private final PostfachNachricht postfachNachrichtRueckfrage = PostfachNachrichtTestFactory.create();
+ private final Rueckfrage postfachNachrichtRueckfrage = RueckfrageTestFactory.create();
@Test
void shouldSetVorgangId() {
- var enrichedPostfachNachricht = antragsraumGrpcService.enrichRueckfrageAnswer(postfachNachrichtToEnrich, postfachNachrichtRueckfrage);
+ var enrichedPostfachNachricht = grpcService.enrichRueckfrageAnswer(postfachNachrichtToEnrich, postfachNachrichtRueckfrage);
assertThat(enrichedPostfachNachricht.getVorgangId()).isEqualTo(postfachNachrichtRueckfrage.getVorgangId());
}
@Test
void shouldSetPostfachAddresses() {
- var enrichedPostfachNachricht = antragsraumGrpcService.enrichRueckfrageAnswer(postfachNachrichtToEnrich, postfachNachrichtRueckfrage);
+ var enrichedPostfachNachricht = grpcService.enrichRueckfrageAnswer(postfachNachrichtToEnrich, postfachNachrichtRueckfrage);
assertThat(enrichedPostfachNachricht.getPostfachAddress()).isEqualTo(postfachNachrichtRueckfrage.getPostfachAddress());
}
@Test
void shouldSetSentAt() {
- var enrichedPostfachNachricht = antragsraumGrpcService.enrichRueckfrageAnswer(postfachNachrichtToEnrich, postfachNachrichtRueckfrage);
+ var enrichedPostfachNachricht = grpcService.enrichRueckfrageAnswer(postfachNachrichtToEnrich, postfachNachrichtRueckfrage);
assertThat(enrichedPostfachNachricht.getSentAt()).isCloseTo(ZonedDateTime.now(), within(2, ChronoUnit.SECONDS));
}
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/AntragraumNachrichtMapperTest.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/AntragraumNachrichtMapperTest.java
index 0fe3c3d3fc8b70e2dfacf2edb39a53970712b9e7..ddd404c7700604182b4c3be686bcd2ea44cdec8d 100644
--- a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/AntragraumNachrichtMapperTest.java
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/AntragraumNachrichtMapperTest.java
@@ -32,13 +32,12 @@ import org.mapstruct.factory.Mappers;
import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
import de.ozgcloud.nachrichten.postfach.PostfachNachricht.Direction;
+import de.ozgcloud.nachrichten.postfach.PostfachNachricht.ReplyOption;
import de.ozgcloud.nachrichten.postfach.PostfachNachrichtTestFactory;
-import de.ozgcloud.nachrichten.postfach.osi.MessageTestFactory;
-import de.ozgcloud.nachrichten.postfach.osi.ReplyOption;
class AntragraumNachrichtMapperTest {
- AntragraumNachrichtMapper mapper = Mappers.getMapper(AntragraumNachrichtMapper.class);
+ private final AntragraumNachrichtMapper mapper = Mappers.getMapper(AntragraumNachrichtMapper.class);
@Nested
class TestMapRueckfrage {
@@ -47,28 +46,28 @@ class AntragraumNachrichtMapperTest {
void shouldMapVorgangId() {
var result = map();
- assertThat(result.getVorgangId()).isEqualTo(MessageTestFactory.VORGANG_ID);
+ assertThat(result.getVorgangId()).isEqualTo(RueckfrageTestFactory.VORGANG_ID);
}
@Test
void shouldMapId() {
var result = map();
- assertThat(result.getId()).isEqualTo(PostfachNachrichtTestFactory.ID);
+ assertThat(result.getId()).isEqualTo(RueckfrageTestFactory.ID);
}
@Test
void shouldMapVorgangName() {
var result = map();
- assertThat(result.getVorgangName()).isEqualTo(MessageTestFactory.SUBJECT);
+ assertThat(result.getVorgangName()).isEqualTo(RueckfrageTestFactory.VORGANG_NAME);
}
@Test
void shouldMapStatus() {
var result = map();
- assertThat(result.getStatus()).isEqualTo(AntragraumNachrichtMapper.DEFAULT_STATUS);
+ assertThat(result.getStatus()).isEqualTo(RueckfrageStatus.NEW.name());
}
@Test
@@ -89,12 +88,11 @@ class AntragraumNachrichtMapperTest {
void shouldMapAttachments() {
var result = map();
- assertThat(result.getAttachmentFileIdCount()).isEqualTo(1);
- assertThat(result.getAttachmentFileId(0)).isEqualTo(PostfachNachrichtTestFactory.ATTACHMENTS.get(0));
+ assertThat(result.getAttachmentFileIdList()).hasSize(1).first().isEqualTo(PostfachNachrichtTestFactory.ATTACHMENTS.get(0));
}
private GrpcRueckfrage map() {
- return mapper.toGrpc(PostfachNachrichtTestFactory.create());
+ return mapper.toGrpc(RueckfrageTestFactory.create());
}
}
@@ -123,17 +121,17 @@ class AntragraumNachrichtMapperTest {
}
@Test
- void shouldMapDirection() {
+ void shouldSetDirection() {
var result = map();
assertThat(result.getDirection()).isEqualTo(Direction.IN);
}
@Test
- void shouldMapReplyOption() {
+ void shouldSetReplyOption() {
var result = map();
- assertThat(result.getReplyOption()).hasToString(ReplyOption.FORBIDDEN.name());
+ assertThat(result.getReplyOption()).isEqualTo(ReplyOption.FORBIDDEN);
}
@Test
@@ -143,6 +141,13 @@ class AntragraumNachrichtMapperTest {
assertThat(result.getCreatedAt()).isCloseTo(ZonedDateTime.now(), within(2, ChronoUnit.SECONDS));
}
+ @Test
+ void shouldSetSentAt() {
+ var result = map();
+
+ assertThat(result.getSentAt()).isCloseTo(PostfachNachrichtTestFactory.SENT_AT, within(2, ChronoUnit.SECONDS));
+ }
+
private PostfachNachricht map() {
return mapper.fromRueckfrageAnswer(GrpcRueckfrageAnswerTestFactory.create());
}
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/AntragraumServiceTest.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/AntragraumServiceTest.java
index 8ff8ca4b3c7cbf98fca3ac6f6dc9f545fb85afba..8433d492e6c79d56cc689854aca408f5099ce80c 100644
--- a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/AntragraumServiceTest.java
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/AntragraumServiceTest.java
@@ -4,9 +4,15 @@ import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
+import java.time.ZonedDateTime;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
import java.util.UUID;
+import java.util.stream.Stream;
import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
@@ -15,6 +21,8 @@ import org.mockito.Spy;
import org.opensaml.saml.saml2.core.Response;
import de.ozgcloud.nachrichten.NachrichtenManagerProperties;
+import de.ozgcloud.nachrichten.common.vorgang.VorgangService;
+import de.ozgcloud.nachrichten.common.vorgang.VorgangTestFactory;
import de.ozgcloud.nachrichten.postfach.PersistPostfachNachrichtService;
import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
import de.ozgcloud.nachrichten.postfach.PostfachNachrichtTestFactory;
@@ -36,6 +44,10 @@ class AntragraumServiceTest {
private Saml2Parser parser;
@Mock
private Saml2Decrypter decrypter;
+ @Mock
+ private RueckfrageMapper rueckfrageMapper;
+ @Mock
+ private VorgangService vorgangService;
@Nested
class TestGetAntragsraumUrl {
@@ -50,43 +62,211 @@ class AntragraumServiceTest {
assertThat(url).isEqualTo(URL);
}
-
}
+ @DisplayName("Find rueckfragen")
@Nested
class TestFindRueckfragen {
- static final String SAML_TOKEN = "TOKEN";
+
+ @Mock
+ private Response response;
+
+ private static final String SAML_TOKEN = "TOKEN";
+ private static final String POSTFACH_ID = "dummyPostfachId";
+
+ private final Rueckfrage rueckfrage = RueckfrageTestFactory.create();
+ private final PostfachNachricht postfachNachricht = PostfachNachrichtTestFactory.create();
+
+ @BeforeEach
+ void mock() {
+ when(postfachNachrichtService.findRueckfragen(any(), any())).thenReturn(Stream.of(postfachNachricht));
+
+ when(rueckfrageMapper.fromPostfachNachricht(any())).thenReturn(rueckfrage);
+ doReturn(rueckfrage).when(service).enrichByAnswers(any(), any());
+ doReturn(Stream.of(rueckfrage)).when(service).enrichRueckfragen(any());
+ doReturn(POSTFACH_ID).when(service).getPostfachId(any());
+ }
@Test
void shouldCallVerify() {
- service.findRueckfragen(SAML_TOKEN);
+ service.findRueckfragen(SAML_TOKEN).toList();
- verify(service).verifyToken(anyString());
+ verify(service).verifyToken(SAML_TOKEN);
}
@Test
void shouldCallVerifier() {
- service.findRueckfragen(SAML_TOKEN);
+ service.findRueckfragen(SAML_TOKEN).toList();
verify(verifier).verify(anyString());
}
@Test
- void shouldCallDecrypt() {
- when(parser.parse(anyString())).thenReturn(mock(Response.class));
-
- service.findRueckfragen(SAML_TOKEN);
+ void shouldGetPostfachId() {
+ service.findRueckfragen(SAML_TOKEN).toList();
- verify(decrypter).decryptPostfachId(any(Response.class));
+ verify(service).getPostfachId(SAML_TOKEN);
}
@Test
void shouldCallPostfachService() {
- when(decrypter.decryptPostfachId(any())).thenReturn(GrpcFindRueckfrageRequestTestFactory.POSTFACH_ID);
+ service.findRueckfragen(SAML_TOKEN).toList();
- service.findRueckfragen(SAML_TOKEN);
+ verify(postfachNachrichtService).findRueckfragen(AntragraumService.BAYERN_ID_SERVICE_KONTO_TYPE, POSTFACH_ID);
+ }
+
+ @Test
+ void shouldCallMapper() {
+ service.findRueckfragen(SAML_TOKEN).toList();
+
+ verify(rueckfrageMapper).fromPostfachNachricht(postfachNachricht);
+ }
+
+ @Test
+ void shouldCallEnrichByAnswers() {
+ service.findRueckfragen(SAML_TOKEN).toList();
+
+ verify(service).enrichByAnswers(rueckfrage, SAML_TOKEN);
+ }
+
+ @Test
+ void shouldCallEnrichRueckfragen() {
+ service.findRueckfragen(SAML_TOKEN).toList();
+
+ verify(service).enrichRueckfragen(any());
+ }
+
+ @Test
+ void shouldReturnFullFilledValue() {
+ var rueckfragen = service.findRueckfragen(SAML_TOKEN).toList();
+
+ assertThat(rueckfragen).containsExactly(rueckfrage);
+ }
+ }
+
+ @DisplayName("Enrich by answers")
+ @Nested
+ class TestEnrichByAnswers {
+
+ private static final String SAML_TOKEN = "TOKEN";
+ private final Rueckfrage rueckfrage = RueckfrageTestFactory.create();
+ private final PostfachNachricht postfachNachricht = PostfachNachrichtTestFactory.create();
+ private final Stream<PostfachNachricht> answers = Stream.of(postfachNachricht);
+
+ @BeforeEach
+ void mock() {
+ doReturn(Optional.of(PostfachNachrichtTestFactory.SENT_AT)).when(service).getFirstSentAt(any());
+ doReturn(answers).when(service).findAnswers(any(), any());
+ }
+
+ @Test
+ void shouldCallFindAnswers() {
+ enrichByAnswer();
- verify(postfachNachrichtService).findRueckfragen(anyString(), anyString());
+ verify(service).findAnswers(SAML_TOKEN, RueckfrageTestFactory.ID);
+ }
+
+ @Test
+ void shouldSetAnsweredAt() {
+ var enrichedRueckfrage = enrichByAnswer();
+
+ assertThat(enrichedRueckfrage.getAnsweredAt()).isEqualTo(PostfachNachrichtTestFactory.SENT_AT);
+ }
+
+ @Test
+ void shouldSetStatus() {
+ var enrichedRueckfrage = enrichByAnswer();
+
+ assertThat(enrichedRueckfrage.getStatus()).isEqualTo(RueckfrageStatus.ANSWERED);
+ }
+
+ @Test
+ void shouldReturnFullFilledValue() {
+ var enrichedRueckfrage = enrichByAnswer();
+
+ assertThat(enrichedRueckfrage).usingRecursiveComparison().ignoringFields("answeredAt", "vorgangId", "vorgangName", "status")
+ .isEqualTo(rueckfrage);
+ }
+
+ private Rueckfrage enrichByAnswer() {
+ return service.enrichByAnswers(rueckfrage, SAML_TOKEN);
+ }
+ }
+
+ @DisplayName("Enrich rueckfrage")
+ @Nested
+ class TestEnrichRueckgabe {
+
+ private final Rueckfrage rueckfrageWithoutVorgangName = RueckfrageTestFactory.createBuilder().vorgangName(null).build();
+ private final List<Rueckfrage> rueckfragen = Collections.singletonList(rueckfrageWithoutVorgangName);
+
+ @BeforeEach
+ void mock() {
+ doReturn(Stream.of(RueckfrageTestFactory.create())).when(service).addVorgangName(any(), any());
+ }
+
+ @Test
+ void shouldCallAddVorgangNameIfRueckfragenExists() {
+ service.enrichRueckfragen(rueckfragen);
+
+ verify(service).addVorgangName(Collections.singletonList(rueckfrageWithoutVorgangName), RueckfrageTestFactory.VORGANG_ID);
+ }
+
+ @Test
+ void shouldReturnValue() {
+ var enrichedRueckfragen = service.enrichRueckfragen(rueckfragen);
+
+ assertThat(enrichedRueckfragen.findFirst()).get().extracting(Rueckfrage::getVorgangName).isEqualTo(RueckfrageTestFactory.VORGANG_NAME);
+ }
+ }
+
+ @DisplayName("Add vorgang name")
+ @Nested
+ class TestAddVorgangName {
+
+ private final Rueckfrage rueckfrage = RueckfrageTestFactory.createBuilder()
+ .vorgangName(null)
+ .build();
+
+ @BeforeEach
+ void mock() {
+ when(vorgangService.getVorgang(any())).thenReturn(VorgangTestFactory.create());
+ }
+
+ @Test
+ void shouldCallGetVorgang() {
+ addVorgangName().toList();
+
+ verify(vorgangService).getVorgang(RueckfrageTestFactory.VORGANG_ID);
+ }
+
+ @Test
+ void shouldSetVorgangName() {
+ var rueckfragenWithVorgangName = addVorgangName().toList();
+
+ assertThat(rueckfragenWithVorgangName.getFirst().getVorgangName()).isEqualTo(VorgangTestFactory.NAME);
+ }
+
+ private Stream<Rueckfrage> addVorgangName() {
+ return service.addVorgangName(Collections.singletonList(rueckfrage), RueckfrageTestFactory.VORGANG_ID);
+ }
+ }
+
+ @DisplayName("Get first sentAt")
+ @Nested
+ class TestGetFirstSentAt {
+ private static final ZonedDateTime earlyZonedDateTime = ZonedDateTime.parse("2020-01-01T10:00:10Z");
+ private static final PostfachNachricht earlyPostfachNachricht = PostfachNachrichtTestFactory.createBuilder().sentAt(earlyZonedDateTime)
+ .build();
+
+ private static final ZonedDateTime lateZonedDateTime = ZonedDateTime.parse("2021-01-01T10:00:10Z");
+ private static final PostfachNachricht latePostfachNachricht = PostfachNachrichtTestFactory.createBuilder().sentAt(lateZonedDateTime).build();
+
+ @Test
+ void shouldReturnSentAt() {
+ var firstSentAt = service.getFirstSentAt(Stream.of(PostfachNachrichtTestFactory.create(), earlyPostfachNachricht, latePostfachNachricht));
+
+ assertThat(firstSentAt).contains(earlyZonedDateTime);
}
}
@@ -121,6 +301,8 @@ class AntragraumServiceTest {
@Nested
class TestFindAnswer {
+ private static final String SAML_TOKEN = "TOKEN";
+
@BeforeEach
void init() {
when(decrypter.decryptPostfachId(any())).thenReturn(GrpcFindRueckfrageRequestTestFactory.POSTFACH_ID);
@@ -128,17 +310,48 @@ class AntragraumServiceTest {
@Test
void shouldCallVerify() {
- service.findAnswers("TOKEN", PostfachNachrichtTestFactory.ID);
+ service.findAnswers(SAML_TOKEN, PostfachNachrichtTestFactory.ID);
- verify(service).verifyToken("TOKEN");
+ verify(service).verifyToken(SAML_TOKEN);
}
@Test
void shouldCallFindAnswers() {
- service.findAnswers("TOKEN", PostfachNachrichtTestFactory.ID);
+ service.findAnswers(SAML_TOKEN, PostfachNachrichtTestFactory.ID);
- verify(postfachNachrichtService).findAnswers("BayernID", GrpcFindRueckfrageRequestTestFactory.POSTFACH_ID,
+ verify(postfachNachrichtService).findAnswers(AntragraumService.BAYERN_ID_SERVICE_KONTO_TYPE,
+ GrpcFindRueckfrageRequestTestFactory.POSTFACH_ID,
PostfachNachrichtTestFactory.ID);
}
}
+
+ @DisplayName("Get postfachId")
+ @Nested
+ class TestGetPostfachId {
+
+ @Mock
+ private Response response;
+
+ private static final String SAML_TOKEN = "TOKEN";
+
+ @BeforeEach
+ void init() {
+ when(parser.parse(anyString())).thenReturn(response);
+ when(decrypter.decryptPostfachId(any())).thenReturn(GrpcFindRueckfrageRequestTestFactory.POSTFACH_ID);
+ }
+
+ @Test
+ void shouldCallParser() {
+ service.getPostfachId(SAML_TOKEN);
+
+ verify(parser).parse(SAML_TOKEN);
+ }
+
+ @Test
+ void shouldCallDecrypter() {
+ service.getPostfachId(SAML_TOKEN);
+
+ verify(decrypter).decryptPostfachId(response);
+ }
+ }
}
\ No newline at end of file
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcRueckfrageAnswerTestFactory.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcRueckfrageAnswerTestFactory.java
index 6c0fb28f113bc5e179aff00d19a9e5cd5a7a6cc9..a5a1c3d84905536ae3be2ed01e8e596095f8ff7c 100644
--- a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcRueckfrageAnswerTestFactory.java
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcRueckfrageAnswerTestFactory.java
@@ -5,6 +5,8 @@ import java.util.UUID;
import com.thedeanda.lorem.LoremIpsum;
+import de.ozgcloud.nachrichten.postfach.PostfachNachrichtTestFactory;
+
public class GrpcRueckfrageAnswerTestFactory {
static final String RUECKFRAGE_ID = UUID.randomUUID().toString();
static final String TEXT = LoremIpsum.getInstance().getParagraphs(2, 4);
@@ -18,6 +20,7 @@ public class GrpcRueckfrageAnswerTestFactory {
return GrpcRueckfrageAnswer.newBuilder()
.setRueckfrageId(RUECKFRAGE_ID)
.setAnswerText(TEXT)
- .addAllAttachmentFileId(ATTACHMENT_ID_LIST);
+ .addAllAttachmentFileId(ATTACHMENT_ID_LIST)
+ .setSentAt(PostfachNachrichtTestFactory.SENT_AT_STR);
}
}
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/RueckfrageMapperTest.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/RueckfrageMapperTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c7e80e7db967c35727133fdac1d42cbc51cd3d3
--- /dev/null
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/RueckfrageMapperTest.java
@@ -0,0 +1,75 @@
+package de.ozgcloud.nachrichten.antragraum;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mapstruct.factory.Mappers;
+
+import de.ozgcloud.nachrichten.postfach.PostfachAddressTestFactory;
+import de.ozgcloud.nachrichten.postfach.PostfachNachrichtTestFactory;
+import de.ozgcloud.nachrichten.postfach.osi.MessageTestFactory;
+
+class RueckfrageMapperTest {
+
+ private final RueckfrageMapper mapper = Mappers.getMapper(RueckfrageMapper.class);
+
+ @DisplayName("From postfachNachricht")
+ @Nested
+ class TestFromPostfachNachricht {
+
+ @Test
+ void shouldMapId() {
+ var mapped = mapFromPostfachNachricht();
+
+ assertThat(mapped.getId()).isEqualTo(PostfachNachrichtTestFactory.ID);
+ }
+
+ @Test
+ void shouldMapVorgangId() {
+ var mapped = mapFromPostfachNachricht();
+
+ assertThat(mapped.getVorgangId()).isEqualTo(MessageTestFactory.VORGANG_ID);
+ }
+
+ @Test
+ void shouldMapPostfachAddress() {
+ var mapped = mapFromPostfachNachricht();
+
+ assertThat(mapped.getPostfachAddress()).usingRecursiveComparison().isEqualTo(PostfachAddressTestFactory.create());
+ }
+
+ @Test
+ void shouldMapSentAt() {
+ var mapped = mapFromPostfachNachricht();
+
+ assertThat(mapped.getSentAt()).isEqualTo(PostfachNachrichtTestFactory.SENT_AT);
+ }
+
+ @Test
+ void shouldMapText() {
+ var mapped = mapFromPostfachNachricht();
+
+ assertThat(mapped.getText()).isEqualTo(PostfachNachrichtTestFactory.MAIL_BODY);
+ }
+
+ @Test
+ void shouldMapAttachments() {
+ var mapped = mapFromPostfachNachricht();
+
+ assertThat(mapped.getAttachments()).isEqualTo(PostfachNachrichtTestFactory.ATTACHMENTS);
+ }
+
+ @Test
+ void shouldHaveDefaultStatus() {
+ var mapped = mapFromPostfachNachricht();
+
+ assertThat(mapped.getStatus()).isEqualTo(RueckfrageStatus.NEW);
+ }
+
+ private Rueckfrage mapFromPostfachNachricht() {
+ return mapper.fromPostfachNachricht(PostfachNachrichtTestFactory.create());
+ }
+ }
+}
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/RueckfrageTestFactory.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/RueckfrageTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a60a8a4d1f15b5ebe814c10197a92afc8afe8f0
--- /dev/null
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/RueckfrageTestFactory.java
@@ -0,0 +1,30 @@
+package de.ozgcloud.nachrichten.antragraum;
+
+import java.util.UUID;
+
+import com.thedeanda.lorem.LoremIpsum;
+
+import de.ozgcloud.nachrichten.postfach.PostfachAddressTestFactory;
+import de.ozgcloud.nachrichten.postfach.PostfachNachrichtTestFactory;
+
+public class RueckfrageTestFactory {
+
+ public static final String ID = UUID.randomUUID().toString();
+ public static final String VORGANG_ID = UUID.randomUUID().toString();
+ public static final String VORGANG_NAME = LoremIpsum.getInstance().getName();
+
+ public static Rueckfrage create() {
+ return createBuilder().build();
+ }
+
+ public static Rueckfrage.RueckfrageBuilder createBuilder() {
+ return Rueckfrage.builder()
+ .id(ID)
+ .vorgangId(VORGANG_ID)
+ .vorgangName(VORGANG_NAME)
+ .postfachAddress(PostfachAddressTestFactory.create())
+ .sentAt(PostfachNachrichtTestFactory.SENT_AT)
+ .text(PostfachNachrichtTestFactory.MAIL_BODY)
+ .attachments(PostfachNachrichtTestFactory.ATTACHMENTS);
+ }
+}
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/GrpcVorgangHeaderTestFactory.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/GrpcVorgangHeaderTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..e794f652d2747fdc7a460c2f90ca55cb37a40ea0
--- /dev/null
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/GrpcVorgangHeaderTestFactory.java
@@ -0,0 +1,16 @@
+package de.ozgcloud.nachrichten.common.vorgang;
+
+import de.ozgcloud.vorgang.vorgang.GrpcVorgangHeader;
+
+public class GrpcVorgangHeaderTestFactory {
+
+ public static GrpcVorgangHeader create() {
+ return createBuilder().build();
+ }
+
+ public static GrpcVorgangHeader.Builder createBuilder() {
+ return GrpcVorgangHeader.newBuilder()
+ .setId(VorgangTestFactory.ID)
+ .setName(VorgangTestFactory.NAME);
+ }
+}
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/GrpcVorgangWithEingangTestFactory.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/GrpcVorgangWithEingangTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..80e47d727ced49a1e22d2e6441d36d9bf063dae4
--- /dev/null
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/GrpcVorgangWithEingangTestFactory.java
@@ -0,0 +1,16 @@
+package de.ozgcloud.nachrichten.common.vorgang;
+
+import de.ozgcloud.vorgang.vorgang.GrpcVorgangWithEingang;
+
+public class GrpcVorgangWithEingangTestFactory {
+
+ public static GrpcVorgangWithEingang create() {
+ return createBuilder().build();
+ }
+
+ public static GrpcVorgangWithEingang.Builder createBuilder() {
+ return GrpcVorgangWithEingang.newBuilder()
+ .setId(VorgangTestFactory.ID)
+ .setName(VorgangTestFactory.NAME);
+ }
+}
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/VorgangMapperTest.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/VorgangMapperTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d8c84e02d1ec21d65e134924d5370559c16f9d9e
--- /dev/null
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/VorgangMapperTest.java
@@ -0,0 +1,25 @@
+package de.ozgcloud.nachrichten.common.vorgang;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mapstruct.factory.Mappers;
+
+class VorgangMapperTest {
+
+ private final VorgangMapper mapper = Mappers.getMapper(VorgangMapper.class);
+
+ @DisplayName("From vorgang with eingang")
+ @Nested
+ class TestFromVorgangWithEingang {
+
+ @Test
+ void shouldMap() {
+ var vorgang = mapper.fromVorgangWithEingang(GrpcVorgangWithEingangTestFactory.create());
+
+ assertThat(vorgang).usingRecursiveComparison().isEqualTo(VorgangTestFactory.create());
+ }
+ }
+}
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/VorgangRemoteServiceTest.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/VorgangRemoteServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..79daec0dc35d431c2d674249588c814ab8c2f9e5
--- /dev/null
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/VorgangRemoteServiceTest.java
@@ -0,0 +1,89 @@
+package de.ozgcloud.nachrichten.common.vorgang;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+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.vorgang.vorgang.GrpcFindVorgangWithEingangRequest;
+import de.ozgcloud.vorgang.vorgang.GrpcFindVorgangWithEingangResponse;
+import de.ozgcloud.vorgang.vorgang.GrpcVorgangWithEingang;
+import de.ozgcloud.vorgang.vorgang.VorgangServiceGrpc.VorgangServiceBlockingStub;
+
+class VorgangRemoteServiceTest {
+
+ @Spy
+ @InjectMocks
+ private VorgangRemoteService remoteService;
+ @Mock
+ private VorgangServiceBlockingStub stub;
+ @Mock
+ private VorgangMapper mapper;
+
+ @DisplayName("Find vorgangIds")
+ @Nested
+ class TestFindVorgangids {
+ // TODO
+ }
+
+ @DisplayName("Get vorgang")
+ @Nested
+ class TestGetVorgang {
+
+ private final GrpcFindVorgangWithEingangRequest request = GrpcFindVorgangWithEingangRequest.newBuilder().build();
+
+ private final GrpcVorgangWithEingang vorgangWithEingang = GrpcVorgangWithEingang.newBuilder().build();
+ private final GrpcFindVorgangWithEingangResponse response = GrpcFindVorgangWithEingangResponse.newBuilder()
+ .setVorgangWithEingang(vorgangWithEingang).build();
+
+ @BeforeEach
+ void mock() {
+ doReturn(stub).when(remoteService).getVorgangServiceStub();
+ doReturn(request).when(remoteService).buildFindVorgangWithEingangRequest(any());
+ when(stub.findVorgangWithEingang(any())).thenReturn(response);
+ when(mapper.fromVorgangWithEingang(any())).thenReturn(VorgangTestFactory.create());
+ }
+
+ @Test
+ void shouldGetStub() {
+ remoteService.getVorgang(VorgangTestFactory.ID);
+
+ verify(remoteService).getVorgangServiceStub();
+ }
+
+ @Test
+ void shouldCallBuildRequest() {
+ remoteService.getVorgang(VorgangTestFactory.ID);
+
+ verify(remoteService).buildFindVorgangWithEingangRequest(VorgangTestFactory.ID);
+ }
+
+ @Test
+ void shouldCallStub() {
+ remoteService.getVorgang(VorgangTestFactory.ID);
+
+ verify(stub).findVorgangWithEingang(request);
+ }
+
+ @Test
+ void shouldCallMapper() {
+ remoteService.getVorgang(VorgangTestFactory.ID);
+
+ verify(mapper).fromVorgangWithEingang(vorgangWithEingang);
+ }
+
+ @Test
+ void shouldReturnMappedValue() {
+ var vorgang = remoteService.getVorgang(VorgangTestFactory.ID);
+
+ assertThat(vorgang).usingRecursiveComparison().isEqualTo(VorgangTestFactory.create());
+ }
+ }
+}
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/VorgangServiceTest.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/VorgangServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a841932662527c5998a97e3746b2f295b633b53
--- /dev/null
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/VorgangServiceTest.java
@@ -0,0 +1,79 @@
+package de.ozgcloud.nachrichten.common.vorgang;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.UUID;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+import de.ozgcloud.nachrichten.postfach.PostfachTestFactory;
+import de.ozgcloud.nachrichten.postfach.osi.MessageTestFactory;
+
+class VorgangServiceTest {
+
+ @InjectMocks
+ private VorgangService service;
+ @Mock
+ private VorgangRemoteService remoteService;
+
+ @DisplayName("Find vorgangIds")
+ @Nested
+ class TestFindVorgangIds {
+
+ private final Stream<String> returnedVorgangIds = Stream.of("1");
+ private final String postfachId = UUID.randomUUID().toString();
+
+ @BeforeEach
+ void mock() {
+ when(remoteService.findVorgangIds(any(), any())).thenReturn(returnedVorgangIds);
+ }
+
+ @Test
+ void shouldCallRemoteService() {
+ service.findVorgangIds(PostfachTestFactory.POSTFACH_TYPE, postfachId);
+
+ verify(remoteService).findVorgangIds(PostfachTestFactory.POSTFACH_TYPE, postfachId);
+ }
+
+ @Test
+ void shouldReturnValue() {
+ var vorgangIds = service.findVorgangIds(PostfachTestFactory.POSTFACH_TYPE, postfachId);
+
+ assertThat(vorgangIds).isEqualTo(returnedVorgangIds);
+ }
+ }
+
+ @DisplayName("Get vorgang")
+ @Nested
+ class TestGetVorgang {
+
+ private final Vorgang returnedVorgang = VorgangTestFactory.create();
+
+ @BeforeEach
+ void mock() {
+ when(remoteService.getVorgang(any())).thenReturn(returnedVorgang);
+ }
+
+ @Test
+ void shouldCallRemoteService() {
+ service.getVorgang(MessageTestFactory.VORGANG_ID);
+
+ verify(remoteService).getVorgang(MessageTestFactory.VORGANG_ID);
+ }
+
+ @Test
+ void shouldReturnValue() {
+ var vorgang = service.getVorgang(MessageTestFactory.VORGANG_ID);
+
+ assertThat(vorgang).isEqualTo(returnedVorgang);
+ }
+ }
+}
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/VorgangTestFactory.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/VorgangTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf1a3392ca1a68594fe6471921153747a157ea8d
--- /dev/null
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/common/vorgang/VorgangTestFactory.java
@@ -0,0 +1,21 @@
+package de.ozgcloud.nachrichten.common.vorgang;
+
+import java.util.UUID;
+
+import com.thedeanda.lorem.LoremIpsum;
+
+public class VorgangTestFactory {
+
+ public static final String ID = UUID.randomUUID().toString();
+ public static final String NAME = LoremIpsum.getInstance().getWords(5);
+
+ public static Vorgang create() {
+ return createBuilder().build();
+ }
+
+ public static Vorgang.VorgangBuilder createBuilder() {
+ return Vorgang.builder()
+ .id(ID)
+ .name(NAME);
+ }
+}
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImplTest.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImplTest.java
index 4b990f5ff92c8d3c17655ec97045664181c094b5..02d2d73f90b8d8147e58adcb2c19a5117aa37c0f 100644
--- a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImplTest.java
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PersistPostfachNachrichtServiceImplTest.java
@@ -21,6 +21,7 @@ import org.mockito.Spy;
import de.ozgcloud.apilib.common.command.OzgCloudCommand;
import de.ozgcloud.apilib.common.command.OzgCloudCommandId;
import de.ozgcloud.apilib.common.command.OzgCloudCommandService;
+import de.ozgcloud.nachrichten.common.vorgang.VorgangService;
import de.ozgcloud.nachrichten.postfach.osi.MessageTestFactory;
class PersistPostfachNachrichtServiceImplTest {
@@ -29,7 +30,7 @@ class PersistPostfachNachrichtServiceImplTest {
@InjectMocks
private PersistPostfachNachrichtServiceImpl service;
@Mock
- private VorgangRemoteService vorgangRemoteService;
+ private VorgangService vorgangService;
@Mock
private OzgCloudCommandService commandService;
@Mock
@@ -178,7 +179,7 @@ class PersistPostfachNachrichtServiceImplTest {
@BeforeEach
void mock() {
- when(vorgangRemoteService.findVorgangIds(any(), any())).thenReturn(Stream.of(MessageTestFactory.VORGANG_ID));
+ when(vorgangService.findVorgangIds(any(), any())).thenReturn(Stream.of(MessageTestFactory.VORGANG_ID));
when(attachedItemRemoteService.findByVorgangId(any())).thenReturn(Stream.of(postfachNachrichtWithNoReferencedNachricht,
matchingPostfachNachricht, postfachNachrichtWithNonMatchingReferencedNachricht));
}
@@ -187,7 +188,7 @@ class PersistPostfachNachrichtServiceImplTest {
void shouldCallVorgangRemoteService() {
doFindAnswers().toList();
- verify(vorgangRemoteService).findVorgangIds(serviceKontoType, PostfachAddressTestFactory.STRING_BASED_IDENTIFIER_POSTFACH_ID_VALUE);
+ verify(vorgangService).findVorgangIds(serviceKontoType, PostfachAddressTestFactory.STRING_BASED_IDENTIFIER_POSTFACH_ID_VALUE);
}
@Test
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PostfachNachrichtMapperTest.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PostfachNachrichtMapperTest.java
index 646aacaab83277bdbb9102da5afec10383a0dc35..40f9862129b74ab2813d04e82cdcac2d398411b1 100644
--- a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PostfachNachrichtMapperTest.java
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PostfachNachrichtMapperTest.java
@@ -31,6 +31,7 @@ import static org.mockito.Mockito.*;
import java.util.Map;
import java.util.UUID;
+import org.apache.commons.lang3.StringUtils;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
@@ -125,6 +126,39 @@ class PostfachNachrichtMapperTest {
assertDoesNotThrow(() -> fromMap(postfachNachrichtMap));
}
+
+ @Test
+ void shouldProceedWithNullAsAttachments() {
+ var postfachNachrichtMap = PostfachNachrichtTestFactory.asMap();
+
+ postfachNachrichtMap.put(PostfachNachricht.FIELD_ATTACHMENTS, null);
+
+ assertDoesNotThrow(() -> fromMap(postfachNachrichtMap));
+ }
+
+ @DisplayName("on empty attachments")
+ @Nested
+ class TestOnEmptyAttachmets {
+
+ @Test
+ void shouldProceedWithEmptyAttachments() {
+ var postfachNachrichtMap = PostfachNachrichtTestFactory.asMap();
+
+ postfachNachrichtMap.put(PostfachNachricht.FIELD_ATTACHMENTS, StringUtils.EMPTY);
+
+ assertDoesNotThrow(() -> fromMap(postfachNachrichtMap));
+ }
+
+ @Test
+ void shouldKeepEmptyAttachments() {
+ var postfachNachrichtMap = PostfachNachrichtTestFactory.asMap();
+ postfachNachrichtMap.put(PostfachNachricht.FIELD_ATTACHMENTS, StringUtils.EMPTY);
+
+ var postfachNachricht = fromMap(postfachNachrichtMap);
+
+ assertThat(postfachNachricht.getAttachmentList()).isEmpty();
+ }
+ }
}
@DisplayName("with missing postfachAddress")
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/osi/MessageTestFactory.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/osi/MessageTestFactory.java
index a60eb1180946699746247df1c19a3b2fd6039e5e..c281353f0f1d0a667c17e2e9117c195b43978256 100644
--- a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/osi/MessageTestFactory.java
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/osi/MessageTestFactory.java
@@ -49,16 +49,16 @@ public class MessageTestFactory {
}
public static Message.MessageBuilder createBuilder() {
- return Message.builder() //
- .messageId(MESSAGE_ID) //
- .postfachId(POSTFACH_ID) //
- .mailBody(MAIL_BODY) //
- .isHtml(IS_HTML) //
- .replyOption(REPLY_OPTION) //
- .subject(SUBJECT) //
- .vorgangId(VORGANG_ID) //
- .eidasLevel(EIDAS_LEVEL) //
- .rechtsverbindlich(RECHTSVERBINDLICH) //
+ return Message.builder()
+ .messageId(MESSAGE_ID)
+ .postfachId(POSTFACH_ID)
+ .mailBody(MAIL_BODY)
+ .isHtml(IS_HTML)
+ .replyOption(REPLY_OPTION)
+ .subject(SUBJECT)
+ .vorgangId(VORGANG_ID)
+ .eidasLevel(EIDAS_LEVEL)
+ .rechtsverbindlich(RECHTSVERBINDLICH)
.attachments(ATTACHMENTS);
}
}