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 3684ce3c2f2c29b5dda1966a5e48bcc4d1ed0cbd..671fb18c5d5a7a5b1da73250644081a911848c85 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
@@ -31,6 +31,7 @@ import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import de.ozgcloud.common.errorhandling.TechnicalException;
+import de.ozgcloud.nachrichten.common.vorgang.VorgangService;
import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
import io.grpc.stub.StreamObserver;
import lombok.RequiredArgsConstructor;
@@ -40,12 +41,15 @@ import net.devh.boot.grpc.server.service.GrpcService;
@RequiredArgsConstructor
@ConditionalOnProperty(AntragraumProperties.PROPERTY_ANTRAGSRAUM_URL)
class AntragraumGrpcService extends AntragraumServiceGrpc.AntragraumServiceImplBase {
- private final AntragraumService antragraumService;
+ private final AntragraumService service;
private final AntragraumNachrichtMapper mapper;
+ private final RueckfrageMapper rueckfrageMapper;
+
+ private final VorgangService vorgangService;
@Override
public void findRueckfragen(GrpcFindRueckfragenRequest request, StreamObserver<GrpcFindRueckfragenResponse> streamObserver) {
- var rueckfragen = antragraumService.findRueckfragen(request.getSamlToken())
+ var rueckfragen = service.findRueckfragen(request.getSamlToken())
.map(mapper::toGrpc)
.map(rueckfrage -> addAnswers(request.getSamlToken(), rueckfrage));
@@ -58,27 +62,26 @@ class AntragraumGrpcService extends AntragraumServiceGrpc.AntragraumServiceImplB
}
List<GrpcRueckfrageAnswer> findRueckfrageAnswers(String samlToken, String rueckfrageId) {
- return antragraumService.findAnswers(samlToken, rueckfrageId).map(mapper::toRueckfrageAnswer).toList();
+ return service.findAnswers(samlToken, rueckfrageId).map(mapper::toRueckfrageAnswer).toList();
}
private GrpcFindRueckfragenResponse buildFindRueckfragenResponse(Stream<GrpcRueckfrage> rueckfragen) {
return GrpcFindRueckfragenResponse.newBuilder().addAllRueckfrage(rueckfragen.toList()).build();
-
}
@Override
public void sendRueckfrageAnswer(GrpcSendRueckfrageAnswerRequest request, StreamObserver<GrpcSendRueckfrageAnswerResponse> streamObserver) {
var answer = mapper.fromRueckfrageAnswer(request.getAnswer());
- answer = enrichRueckfrageAnswer(answer, getRueckfrage(request.getSamlToken(), request.getAnswer().getRueckfrageId()));
- var commandId = antragraumService.sendRueckfrageAnswer(request.getSamlToken(), request.getAnswer().getRueckfrageId(), answer);
+ answer = enrichRueckfrageAnswer(answer, getRueckfrageByNachricht(request.getSamlToken(), request.getAnswer().getRueckfrageId()));
+ var commandId = service.sendRueckfrageAnswer(request.getSamlToken(), request.getAnswer().getRueckfrageId(), answer);
streamObserver.onNext(GrpcSendRueckfrageAnswerResponse.newBuilder().setCommandId(commandId).build());
streamObserver.onCompleted();
}
- Rueckfrage getRueckfrage(String samlToken, String postfachNachrichtId) {
- return antragraumService.findRueckfragen(samlToken)
+ Rueckfrage getRueckfrageByNachricht(String samlToken, String postfachNachrichtId) {
+ return service.findRueckfragen(samlToken)
.filter(rueckfrage -> StringUtils.equals(rueckfrage.getId(), postfachNachrichtId))
.findFirst()
.orElseThrow(() -> new TechnicalException(String.format("No rueckfrage found for answer with id %s", postfachNachrichtId)));
@@ -91,4 +94,30 @@ class AntragraumGrpcService extends AntragraumServiceGrpc.AntragraumServiceImplB
.sentAt(ZonedDateTime.now())
.build();
}
+
+ @Override
+ public void getRueckfrage(GrpcGetRueckfrageRequest request, StreamObserver<GrpcGetRueckfrageResponse> responseObserver) {
+ var reuckfrage = buildRueckfrage(request);
+
+ responseObserver.onNext(buildGetRueckfrageResponse(reuckfrage));
+ responseObserver.onCompleted();
+ }
+
+ GrpcRueckfrage buildRueckfrage(GrpcGetRueckfrageRequest request) {
+ var rueckfrage = service.getRueckfrage(request.getSamlToken(), request.getId());
+ var vorgang = vorgangService.getVorgang(rueckfrage.getVorgangId());
+
+ var answers = service.findAnswers(request.getSamlToken(), request.getId()).toList();
+ var firstAnswerSentAt = service.getFirstSentAt(answers.stream());
+
+ return addAnswers(rueckfrageMapper.toRueckfrage(firstAnswerSentAt, vorgang, rueckfrage), answers);
+ }
+
+ GrpcRueckfrage addAnswers(GrpcRueckfrage rueckfrage, List<PostfachNachricht> answers) {
+ return rueckfrage.toBuilder().addAllAnswers(answers.stream().map(mapper::toRueckfrageAnswer).toList()).build();
+ }
+
+ GrpcGetRueckfrageResponse buildGetRueckfrageResponse(GrpcRueckfrage rueckfrage) {
+ return GrpcGetRueckfrageResponse.newBuilder().setRueckfrage(rueckfrage).build();
+ }
}
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 3e10f0004cdf6859e59c8dd37927c04a2ede9b08..d6a76afc390f7c76fb8c2abe4f45d1a5f3f06882 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
@@ -44,6 +44,7 @@ import de.ozgcloud.nachrichten.common.vorgang.Vorgang;
import de.ozgcloud.nachrichten.common.vorgang.VorgangService;
import de.ozgcloud.nachrichten.postfach.PersistPostfachNachrichtService;
import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
+import de.ozgcloud.nachrichten.postfach.PostfachNachrichtMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.log4j.Log4j2;
@@ -76,6 +77,7 @@ public class AntragraumService {
private final RueckfrageMapper rueckfrageMapper;
@Qualifier(NachrichtenManagerConfiguration.NACHRICHTEN_VORGANG_SERVICE)
private final VorgangService vorgangService;
+ private final PostfachNachrichtMapper nachrichtMapper;
@PostConstruct
void init() {
@@ -147,14 +149,20 @@ public class AntragraumService {
return postfachNachrichtService.findAnswers(BAYERN_ID_SERVICE_KONTO_TYPE, getPostfachId(samlToken), rueckfrageId);
}
+ String getPostfachId(String samlToken) {
+ return decrypter.decryptPostfachId(parser.parse(samlToken));
+ }
+
+ public PostfachNachricht getRueckfrage(String samlToken, String id) {
+ verifyToken(samlToken);
+
+ return nachrichtMapper.fromMapToPostfachMail(postfachNachrichtService.getById(id));
+ }
+
void verifyToken(String token) {
var errors = verifier.verify(token);
if (CollectionUtils.isNotEmpty(errors)) {
throw new SecurityException("SAML Token verification failed. Errors: %s".formatted(errors));
}
}
-
- String getPostfachId(String samlToken) {
- return decrypter.decryptPostfachId(parser.parse(samlToken));
- }
-}
+}
\ 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
index 439961c766b90a6952961e916a0117210115dc63..a9dfefdf3b38485bc28ffd12bbd7a4d40854e998 100644
--- 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
@@ -1,11 +1,17 @@
package de.ozgcloud.nachrichten.antragraum;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Optional;
+
+import org.apache.commons.lang3.StringUtils;
import org.mapstruct.CollectionMappingStrategy;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.NullValueCheckStrategy;
import org.mapstruct.ReportingPolicy;
+import de.ozgcloud.nachrichten.common.vorgang.Vorgang;
import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
@Mapper(collectionMappingStrategy = CollectionMappingStrategy.ADDER_PREFERRED, //
@@ -13,10 +19,55 @@ import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS)
interface RueckfrageMapper {
+ final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssX");
+
@Mapping(target = "answeredAt", ignore = true)
@Mapping(target = "status", ignore = true)
@Mapping(target = "text", source = "mailBody")
@Mapping(target = "vorgangName", ignore = true)
Rueckfrage fromPostfachNachricht(PostfachNachricht postfachNachricht);
+ @Mapping(target = "mergeFrom", ignore = true)
+ @Mapping(target = "clearField", ignore = true)
+ @Mapping(target = "clearOneof", ignore = true)
+ @Mapping(target = "mergeUnknownFields", ignore = true)
+ @Mapping(target = "removeAnswers", ignore = true)
+ @Mapping(target = "accessible", ignore = true) // TODO
+ @Mapping(target = "accessibleBytes", ignore = true)
+ @Mapping(target = "answeredAt", expression = "java(setAnsweredAt(firstAnswerSentAt))")
+ @Mapping(target = "answeredAtBytes", ignore = true)
+ @Mapping(target = "idBytes", ignore = true)
+ @Mapping(target = "sentAtBytes", ignore = true)
+ @Mapping(target = "status", expression = "java(setStatus(firstAnswerSentAt))")
+ @Mapping(target = "statusBytes", ignore = true)
+ @Mapping(target = "textBytes", ignore = true)
+ @Mapping(target = "trustLevel", ignore = true) // TODO
+ @Mapping(target = "trustLevelBytes", ignore = true)
+ @Mapping(target = "unknownFields", ignore = true)
+ @Mapping(target = "vorgangIdBytes", ignore = true)
+ @Mapping(target = "vorgangName", source = "vorgang.name")
+ @Mapping(target = "vorgangNameBytes", ignore = true)
+ @Mapping(target = "vorgangNummer", source = "vorgang.nummer")
+ @Mapping(target = "vorgangNummerBytes", ignore = true)
+ @Mapping(target = "allFields", ignore = true)
+ @Mapping(target = "answersBuilderList", ignore = true)
+ @Mapping(target = "answersList", ignore = true)
+ @Mapping(target = "answersOrBuilderList", ignore = true)
+ @Mapping(target = "attachmentFileIdList", source = "rueckfrage.attachments")
+ @Mapping(target = "sentAt", source = "rueckfrage.sentAt", dateFormat = "yyyy-MM-dd'T'HH:mm:ss")
+ @Mapping(target = "id", source = "rueckfrage.id")
+ @Mapping(target = "text", source = "rueckfrage.mailBody")
+ GrpcRueckfrage toRueckfrage(Optional<ZonedDateTime> firstAnswerSentAt, Vorgang vorgang, PostfachNachricht rueckfrage);
+
+ default String setVorgangName(Vorgang vorgang) {
+ return vorgang.getName();
+ }
+
+ default String setAnsweredAt(Optional<ZonedDateTime> firstAnswerSentAt) {
+ return firstAnswerSentAt.map(formatter::format).orElseGet(() -> StringUtils.EMPTY);
+ }
+
+ default String setStatus(Optional<ZonedDateTime> firstAnswerSentAt) {
+ return firstAnswerSentAt.map(answeredAt -> RueckfrageStatus.ANSWERED.name()).orElseGet(RueckfrageStatus.NEW::name);
+ }
}
\ No newline at end of file
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 c2783a9fbe16fea8bf94b4740b5f304e937d3547..fa6905abc07b0fe4d3a89939d4b895d374e39dec 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
@@ -125,7 +125,7 @@ public abstract class PostfachNachrichtMapper {
return fromMapToPostfachMail(grpcObjectMapper.mapFromGrpc(grpcVorgangAttachedItem.getItem()));
}
- PostfachNachricht fromMapToPostfachMail(Map<String, Object> mailMap) {
+ public PostfachNachricht fromMapToPostfachMail(Map<String, Object> mailMap) {
var postfachMailBuilder = PostfachNachricht.builder()
.id(MapUtils.getString(mailMap, PostfachNachricht.FIELD_ID))
.vorgangId(MapUtils.getString(mailMap, (PostfachNachricht.FIELD_VORGANG_ID)))
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 6b96cc3be43f4a2797608efb1350768c1c50f502..f90512f50f318d5c579a913700637c2598f86877 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
@@ -26,6 +26,8 @@ import static org.mockito.Mockito.*;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoUnit;
+import java.util.List;
+import java.util.Optional;
import java.util.UUID;
import java.util.stream.Stream;
@@ -33,13 +35,19 @@ 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.ArgumentCaptor;
+import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import de.ozgcloud.common.errorhandling.TechnicalException;
+import de.ozgcloud.nachrichten.common.vorgang.Vorgang;
+import de.ozgcloud.nachrichten.common.vorgang.VorgangService;
+import de.ozgcloud.nachrichten.common.vorgang.VorgangTestFactory;
import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
import de.ozgcloud.nachrichten.postfach.PostfachNachrichtTestFactory;
+import de.ozgcloud.nachrichten.postfach.osi.MessageTestFactory;
import io.grpc.stub.StreamObserver;
class AntragraumGrpcServiceTest {
@@ -50,6 +58,11 @@ class AntragraumGrpcServiceTest {
private AntragraumService service;
@Mock
private AntragraumNachrichtMapper nachrichtMapper;
+ @Mock
+ private RueckfrageMapper rueckfrageMapper;
+
+ @Mock
+ private VorgangService vorgangService;
@Nested
class TestFindRueckfragen {
@@ -88,7 +101,7 @@ class AntragraumGrpcServiceTest {
void shouldLoadAnswers() {
grpcService.findRueckfragen(GrpcFindRueckfrageRequestTestFactory.create(), streamObserver);
- verify(service).findAnswers(GrpcFindRueckfrageRequestTestFactory.SAML_TOKEN, GrpcRueckfrageTestFactory.ID);
+ verify(service).findAnswers(GrpcFindRueckfrageRequestTestFactory.SAML_TOKEN, PostfachNachrichtTestFactory.ID);
}
}
@@ -106,7 +119,7 @@ class AntragraumGrpcServiceTest {
when(service.sendRueckfrageAnswer(anyString(), anyString(), any(PostfachNachricht.class)))
.thenReturn(UUID.randomUUID().toString());
doReturn(postfachNachricht).when(grpcService).enrichRueckfrageAnswer(any(), any());
- doReturn(rueckfrage).when(grpcService).getRueckfrage(any(), any());
+ doReturn(rueckfrage).when(grpcService).getRueckfrageByNachricht(anyString(), anyString());
}
@Test
@@ -120,7 +133,7 @@ class AntragraumGrpcServiceTest {
void shouldGetRueckfrage() {
sendRueckfrageAnswer();
- verify(grpcService).getRueckfrage(GrpcSendRueckfrageAnswerRequestTestFactory.SAML_TOKEN,
+ verify(grpcService).getRueckfrageByNachricht(GrpcSendRueckfrageAnswerRequestTestFactory.SAML_TOKEN,
GrpcRueckfrageAnswerTestFactory.RUECKFRAGE_ID);
}
@@ -157,9 +170,9 @@ class AntragraumGrpcServiceTest {
}
}
- @DisplayName("Get rueckfrage")
+ @DisplayName("Get rueckfrage by nachricht")
@Nested
- class TestGetRueckfrage {
+ class TestGetRueckfrageByNachricht {
private final Rueckfrage matchingRueckfrage = RueckfrageTestFactory.createBuilder().id(GrpcRueckfrageAnswerTestFactory.RUECKFRAGE_ID)
.build();
@@ -192,7 +205,7 @@ class AntragraumGrpcServiceTest {
}
private Rueckfrage getRueckfrage() {
- return grpcService.getRueckfrage(GrpcSendRueckfrageAnswerRequestTestFactory.SAML_TOKEN,
+ return grpcService.getRueckfrageByNachricht(GrpcSendRueckfrageAnswerRequestTestFactory.SAML_TOKEN,
GrpcRueckfrageAnswerTestFactory.RUECKFRAGE_ID);
}
}
@@ -230,4 +243,189 @@ class AntragraumGrpcServiceTest {
assertThat(enrichedPostfachNachricht.getSentAt()).isCloseTo(ZonedDateTime.now(), within(2, ChronoUnit.SECONDS));
}
}
+
+ @DisplayName("Get rueckfrage")
+ @Nested
+ class TestGetRueckfrage {
+
+ @Mock
+ private StreamObserver<GrpcGetRueckfrageResponse> streamObserver;
+
+ private final GrpcGetRueckfrageRequest request = GrpcGetRueckfrageRequestTestFactory.create();
+
+ private final GrpcGetRueckfrageResponse getRueckfrageResponse = GrpcGetRueckfrageResponseTestFactory.create();
+
+ private final GrpcRueckfrage grpcRueckfrage = GrpcRueckfrageTestFactory.create();
+
+ @BeforeEach
+ void mock() {
+ doReturn(getRueckfrageResponse).when(grpcService).buildGetRueckfrageResponse(any());
+ doReturn(grpcRueckfrage).when(grpcService).buildRueckfrage(any());
+ }
+
+ @Test
+ void shouldBuildRueckfrage() {
+ getRueckfrage();
+
+ verify(grpcService).buildRueckfrage(request);
+ }
+
+ @Test
+ void shouldCallBuildRueckfrageResponse() {
+ getRueckfrage();
+
+ verify(grpcService).buildGetRueckfrageResponse(grpcRueckfrage);
+ }
+
+ @Test
+ void shouldCallOnNext() {
+ getRueckfrage();
+
+ verify(streamObserver).onNext(getRueckfrageResponse);
+ }
+
+ @Test
+ void shouldCallOnCompleted() {
+ getRueckfrage();
+
+ verify(streamObserver).onCompleted();
+ }
+
+ private void getRueckfrage() {
+ grpcService.getRueckfrage(GrpcGetRueckfrageRequestTestFactory.create(), streamObserver);
+ }
+ }
+
+ @DisplayName("Build rueckfrage")
+ @Nested
+ class TestBuildRueckfrage {
+
+ @Captor
+ private ArgumentCaptor<Stream<PostfachNachricht>> answersStreamCaptor;
+
+ @Captor
+ private ArgumentCaptor<List<PostfachNachricht>> answersListCaptor;
+
+ private final GrpcGetRueckfrageRequest request = GrpcGetRueckfrageRequestTestFactory.create();
+
+ private final PostfachNachricht rueckfrage = PostfachNachrichtTestFactory.create();
+
+ private final PostfachNachricht answer = PostfachNachrichtTestFactory.create();
+
+ private final ZonedDateTime now = ZonedDateTime.now();
+ private final Optional<ZonedDateTime> sentAt = Optional.of(now);
+
+ private final Vorgang vorgang = VorgangTestFactory.create();
+
+ private final GrpcRueckfrage grpcRueckfrage = GrpcRueckfrageTestFactory.create();
+
+ @BeforeEach
+ void mock() {
+ when(service.getRueckfrage(any(), any())).thenReturn(rueckfrage);
+ when(service.findAnswers(any(), any())).thenReturn(Stream.of(answer));
+ when(service.getFirstSentAt(any())).thenReturn(sentAt);
+ when(vorgangService.getVorgang(any())).thenReturn(vorgang);
+ when(rueckfrageMapper.toRueckfrage(any(), any(), any())).thenReturn(grpcRueckfrage);
+ doReturn(grpcRueckfrage).when(grpcService).addAnswers(any(), any());
+ }
+
+ @Test
+ void shouldCallServiceToGetRueckfrage() {
+ buildRueckfrage();
+
+ verify(service).getRueckfrage(GrpcGetRueckfrageRequestTestFactory.SAML_TOKEN, RueckfrageTestFactory.ID);
+ }
+
+ @Test
+ void shouldCallVorgangService() {
+ buildRueckfrage();
+
+ verify(vorgangService).getVorgang(MessageTestFactory.VORGANG_ID);
+ }
+
+ @Test
+ void shouldCallServiceToGetAnswers() {
+ buildRueckfrage();
+
+ verify(service).findAnswers(GrpcGetRueckfrageRequestTestFactory.SAML_TOKEN, RueckfrageTestFactory.ID);
+ }
+
+ @Test
+ void shouldCallServiceToGetFirstSentAt() {
+ buildRueckfrage();
+
+ verify(service).getFirstSentAt(answersStreamCaptor.capture());
+ assertThat(answersStreamCaptor.getValue().toList().get(0)).isEqualTo(answer);
+ }
+
+ @Test
+ void shouldCallMapper() {
+ buildRueckfrage();
+
+ verify(rueckfrageMapper).toRueckfrage(sentAt, vorgang, rueckfrage);
+ }
+
+ @Test
+ void shouldCallAddAnswers() {
+ buildRueckfrage();
+
+ verify(grpcService).addAnswers(eq(grpcRueckfrage), answersListCaptor.capture());
+ assertThat(answersListCaptor.getValue().get(0)).isEqualTo(answer);
+ }
+
+ @Test
+ void shouldReturnRueckfrage() {
+ var buildedRueckfrage = buildRueckfrage();
+
+ assertThat(buildedRueckfrage).isEqualTo(grpcRueckfrage);
+ }
+
+ private GrpcRueckfrage buildRueckfrage() {
+ return grpcService.buildRueckfrage(request);
+ }
+ }
+
+ @DisplayName("Add answers")
+ @Nested
+ class TestAddAnswers {
+
+ private final PostfachNachricht answer = PostfachNachrichtTestFactory.create();
+
+ private final GrpcRueckfrage grpcRueckfrage = GrpcRueckfrageTestFactory.create();
+
+ private final GrpcRueckfrageAnswer grpcRueckfrageAnwswer = GrpcRueckfrageAnswerTestFactory.create();
+
+ @BeforeEach
+ void mock() {
+ when(nachrichtMapper.toRueckfrageAnswer(any())).thenReturn(grpcRueckfrageAnwswer);
+ }
+
+ @Test
+ void shouldCallMapper() {
+ grpcService.addAnswers(grpcRueckfrage, List.of(answer));
+
+ verify(nachrichtMapper).toRueckfrageAnswer(answer);
+ }
+
+ @Test
+ void shouldReturnRueckfrageWithAnswers() {
+ var enhancedRueckfrage = grpcService.addAnswers(grpcRueckfrage, List.of(answer));
+
+ assertThat(enhancedRueckfrage.getAnswersList().get(0)).isEqualTo(grpcRueckfrageAnwswer);
+ }
+ }
+
+ @DisplayName("Build get rueckfrage response")
+ @Nested
+ class TestBuildGetRueckfrageResponse {
+
+ private final GrpcRueckfrage grpcRueckfrage = GrpcRueckfrageTestFactory.create();
+
+ @Test
+ void shouldReturnResponseIncludingRueckfrage() {
+ var rueckfrageResponse = grpcService.buildGetRueckfrageResponse(grpcRueckfrage);
+
+ assertThat(rueckfrageResponse.getRueckfrage()).isEqualTo(grpcRueckfrage);
+ }
+ }
}
\ No newline at end of file
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 36523ddfe28228a5b7276c294dffcd500b2cea46..2188ed9d19949f4aa20ead0e34315e033d46b108 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
@@ -7,6 +7,7 @@ import static org.mockito.Mockito.*;
import java.time.ZonedDateTime;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import java.util.stream.Stream;
@@ -25,6 +26,7 @@ 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.PostfachNachrichtMapper;
import de.ozgcloud.nachrichten.postfach.PostfachNachrichtTestFactory;
class AntragraumServiceTest {
@@ -49,6 +51,8 @@ class AntragraumServiceTest {
private RueckfrageMapper rueckfrageMapper;
@Mock
private VorgangService vorgangService;
+ @Mock
+ private PostfachNachrichtMapper nachrichtMapper;
@Nested
class TestGetAntragsraumUrl {
@@ -362,4 +366,54 @@ class AntragraumServiceTest {
verify(decrypter).decryptPostfachId(response);
}
}
+
+ @DisplayName("Get rueckfrage")
+ @Nested
+ class TestGetRueckfrage {
+
+ private final String samlToken = "DummySamlToken";
+
+ private final Map<String, Object> nachrichtAsMap = PostfachNachrichtTestFactory.asMap();
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.create();
+
+ @BeforeEach
+ void mock() {
+ when(postfachNachrichtService.getById(any())).thenReturn(nachrichtAsMap);
+ when(nachrichtMapper.fromMapToPostfachMail(any())).thenReturn(nachricht);
+
+ doNothing().when(service).verifyToken(any());
+ }
+
+ @Test
+ void shouldVerifySamlToken() {
+ getRueckfrage();
+
+ verify(service).verifyToken(samlToken);
+ }
+
+ @Test
+ void shouldCallPersistPostfachNachrichtService() {
+ getRueckfrage();
+
+ verify(postfachNachrichtService).getById(RueckfrageTestFactory.ID);
+ }
+
+ @Test
+ void shouldCallNachrichtMapper() {
+ getRueckfrage();
+
+ verify(nachrichtMapper).fromMapToPostfachMail(nachrichtAsMap);
+ }
+
+ @Test
+ void shouldReturnValue() {
+ var rueckfrage = getRueckfrage();
+
+ assertThat(rueckfrage).isEqualTo(nachricht);
+ }
+
+ private PostfachNachricht getRueckfrage() {
+ return service.getRueckfrage(samlToken, RueckfrageTestFactory.ID);
+ }
+ }
}
\ No newline at end of file
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcGetRueckfrageRequestTestFactory.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcGetRueckfrageRequestTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..164cc0e42e902c18f0c3681972d30d5aec1acfcd
--- /dev/null
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcGetRueckfrageRequestTestFactory.java
@@ -0,0 +1,19 @@
+package de.ozgcloud.nachrichten.antragraum;
+
+import java.util.UUID;
+
+public class GrpcGetRueckfrageRequestTestFactory {
+
+ public final static String SAML_TOKEN = "DUMMY_SAML_TOKEN";
+ public final static String ID = UUID.randomUUID().toString();
+
+ public static GrpcGetRueckfrageRequest create() {
+ return createBuilder().build();
+ }
+
+ public static GrpcGetRueckfrageRequest.Builder createBuilder() {
+ return GrpcGetRueckfrageRequest.newBuilder()
+ .setSamlToken(SAML_TOKEN)
+ .setId(RueckfrageTestFactory.ID);
+ }
+}
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcGetRueckfrageResponseTestFactory.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcGetRueckfrageResponseTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..53e38d91e5d9b82cdd31c99c4a0d601b32b5de5b
--- /dev/null
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcGetRueckfrageResponseTestFactory.java
@@ -0,0 +1,13 @@
+package de.ozgcloud.nachrichten.antragraum;
+
+public class GrpcGetRueckfrageResponseTestFactory {
+
+ public static GrpcGetRueckfrageResponse create() {
+ return createBuilder().build();
+ }
+
+ public static GrpcGetRueckfrageResponse.Builder createBuilder() {
+ return GrpcGetRueckfrageResponse.newBuilder()
+ .setRueckfrage(GrpcRueckfrageTestFactory.create());
+ }
+}
\ No newline at end of file
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcRueckfrageTestFactory.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcRueckfrageTestFactory.java
index 248e5abc56da8018fd832afef80ea32039aa2c07..829463f7cb8e07981ab2294ba120839f9c8e1d32 100644
--- a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcRueckfrageTestFactory.java
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/antragraum/GrpcRueckfrageTestFactory.java
@@ -1,18 +1,19 @@
package de.ozgcloud.nachrichten.antragraum;
-import java.util.UUID;
+import de.ozgcloud.nachrichten.postfach.PostfachNachrichtTestFactory;
public class GrpcRueckfrageTestFactory {
- public static final String ID = UUID.randomUUID().toString();
-
public static GrpcRueckfrage create() {
return createBuilder().build();
}
public static GrpcRueckfrage.Builder createBuilder() {
return GrpcRueckfrage.newBuilder()
- .setId(ID);
+ .setId(PostfachNachrichtTestFactory.ID)
+ .setText(PostfachNachrichtTestFactory.MAIL_BODY)
+ .setSentAt(PostfachNachrichtTestFactory.SENT_AT_STR)
+ .addAllAttachmentFileId(PostfachNachrichtTestFactory.ATTACHMENTS);
}
}
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
index 5c7e80e7db967c35727133fdac1d42cbc51cd3d3..4b247cbe8fa0c4797e77b560b0d35703fcd68ae7 100644
--- 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
@@ -2,12 +2,18 @@ package de.ozgcloud.nachrichten.antragraum;
import static org.assertj.core.api.Assertions.*;
+import java.time.ZonedDateTime;
+import java.util.Optional;
+
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.common.vorgang.Vorgang;
+import de.ozgcloud.nachrichten.common.vorgang.VorgangTestFactory;
import de.ozgcloud.nachrichten.postfach.PostfachAddressTestFactory;
+import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
import de.ozgcloud.nachrichten.postfach.PostfachNachrichtTestFactory;
import de.ozgcloud.nachrichten.postfach.osi.MessageTestFactory;
@@ -72,4 +78,69 @@ class RueckfrageMapperTest {
return mapper.fromPostfachNachricht(PostfachNachrichtTestFactory.create());
}
}
+
+ @DisplayName("To rueckfrage")
+ @Nested
+ class TestToRueckfrage {
+
+ private final Vorgang vorgang = VorgangTestFactory.create();
+ private final PostfachNachricht rueckfrageNachricht = PostfachNachrichtTestFactory.create();
+
+ public static final String ANSWERED_AT_STR = "2020-04-01T11:30:10Z";
+ public static final ZonedDateTime ANSWERED_AT_AT = ZonedDateTime.parse(ANSWERED_AT_STR);
+ private final Optional<ZonedDateTime> firstSentAt = Optional.of(ANSWERED_AT_AT);
+
+ @Test
+ void shouldMapId() {
+ var rueckfrage = toRueckfrage();
+
+ assertThat(rueckfrage.getId()).isEqualTo(PostfachNachrichtTestFactory.ID);
+ }
+
+ @Test
+ void shouldMapText() {
+ var rueckfrage = toRueckfrage();
+
+ assertThat(rueckfrage.getText()).isEqualTo(PostfachNachrichtTestFactory.MAIL_BODY);
+ }
+
+ @Test
+ void shouldMapAttachments() {
+ var rueckfrage = toRueckfrage();
+
+ assertThat(rueckfrage.getAttachmentFileIdList()).containsExactly(PostfachNachrichtTestFactory.ATTACHMENT_FILE_ID);
+ }
+
+ @Test
+ void shouldMapVorgangName() {
+ var rueckfrage = toRueckfrage();
+
+ assertThat(rueckfrage.getVorgangName()).isEqualTo(VorgangTestFactory.NAME);
+ }
+
+ @Test
+ void shouldMapVorgangNummer() {
+ var rueckfrage = toRueckfrage();
+
+ assertThat(rueckfrage.getVorgangNummer()).isEqualTo(VorgangTestFactory.NUMMER);
+ }
+
+ @Test
+ void shouldMapAnsweredAt() {
+ var rueckfrage = toRueckfrage();
+
+ assertThat(rueckfrage.getAnsweredAt()).isEqualTo(ANSWERED_AT_STR);
+ }
+
+ @Test
+ void shouldMapStatus() {
+ var rueckfrage = toRueckfrage();
+
+ assertThat(rueckfrage.getStatus()).isEqualTo(RueckfrageStatus.ANSWERED.name());
+ }
+
+ private GrpcRueckfrage toRueckfrage() {
+ return mapper.toRueckfrage(firstSentAt, vorgang, rueckfrageNachricht);
+ }
+ }
}