diff --git a/Jenkinsfile b/Jenkinsfile
index c998ddea10cfb5c6f8b13ae7ed5a6166845119b9..8885032c114dd1e335960bf51579b3e7a5d5a338 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -43,6 +43,26 @@ pipeline {
}
}
}
+ stage('Set Version') {
+ when {
+ not {
+ anyOf {
+ branch 'master'
+ branch 'release'
+ }
+ }
+ }
+ steps {
+ script {
+ FAILED_STAGE=env.STAGE_NAME
+ JAR_TAG = getPomVersion('pom.xml').replace("SNAPSHOT", "${env.BRANCH_NAME}-SNAPSHOT")
+ }
+ configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
+ sh "mvn -s $MAVEN_SETTINGS versions:set -DnewVersion=${JAR_TAG} -DprocessAllModules=true"
+
+ }
+ }
+ }
stage('Build NachrichtenManager') {
steps {
@@ -57,18 +77,13 @@ pipeline {
}
stage('Deploy to Nexus'){
- when {
- anyOf {
- branch 'master'
- branch 'release'
- }
- }
steps {
script {
FAILED_STAGE = env.STAGE_NAME
}
configFileProvider([configFile(fileId: 'maven-settings', variable: 'MAVEN_SETTINGS')]) {
sh 'mvn --no-transfer-progress -s $MAVEN_SETTINGS -DskipTests deploy -Dmaven.wagon.http.retryHandler.count=3'
+ sh "mvn -s $MAVEN_SETTINGS versions:revert"
}
}
}
@@ -160,7 +175,7 @@ Void sendFailureMessage() {
href='${BLUE_OCEAN_URL}'>${env.BUILD_NUMBER}</a>"}"""
if (env.BRANCH_NAME == 'master') {
- room = "!iQPAvQIiRwRpNOszjw:matrix.ozg-sh.de"
+ room = "!GjqhmouBtnDbwUkAjx:matrix.ozg-sh.de"
}
else if (env.BRANCH_NAME == 'release') {
room = "!oWZpUGTFsxkJIYNfYg:matrix.ozg-sh.de"
diff --git a/nachrichten-manager-interface/src/main/protobuf/antragraum.model.proto b/nachrichten-manager-interface/src/main/protobuf/antragraum.model.proto
index 80234a7f435bc161ae2df951c7f0226d2503d9c9..fa1ef06aea7c96255623000b25acb0a1421d138a 100644
--- a/nachrichten-manager-interface/src/main/protobuf/antragraum.model.proto
+++ b/nachrichten-manager-interface/src/main/protobuf/antragraum.model.proto
@@ -50,6 +50,7 @@ message GrpcRueckfrage {
string text = 7;
repeated string attachmentFileId = 8;
repeated GrpcRueckfrageAnswer answers = 9;
+ string vorgangNummer = 10;
}
message GrpcSendRueckfrageAnswerRequest {
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 0d576aabd573e0bce86a53334a0914068b0a842a..f0c954007b2aabfa4ed9c3af1e3a3499bb323a04 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
@@ -84,6 +84,7 @@ interface AntragraumNachrichtMapper {
return ZonedDateTime.parse(sentAt);
}
+ @Mapping(target = "sentAtBytes", ignore = true)
@Mapping(target = "mergeFrom", ignore = true)
@Mapping(target = "clearField", ignore = true)
@Mapping(target = "clearOneof", 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 d0d7d8066877dcc53d98d4b97fd2de7588429791..3e10f0004cdf6859e59c8dd37927c04a2ede9b08 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
@@ -40,6 +40,7 @@ import org.springframework.stereotype.Service;
import de.ozgcloud.nachrichten.NachrichtenManagerConfiguration;
import de.ozgcloud.nachrichten.NachrichtenManagerProperties;
+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;
@@ -122,12 +123,16 @@ public class AntragraumService {
if (rueckfragen.isEmpty()) {
return Stream.empty();
}
- return addVorgangName(rueckfragen, rueckfragen.getFirst().getVorgangId());
+ return addVorgangData(rueckfragen, rueckfragen.getFirst().getVorgangId());
}
- Stream<Rueckfrage> addVorgangName(List<Rueckfrage> rueckfragen, String vorgangId) {
+ Stream<Rueckfrage> addVorgangData(List<Rueckfrage> rueckfragen, String vorgangId) {
var vorgang = vorgangService.getVorgang(vorgangId);
- return rueckfragen.stream().map(rueckfrage -> rueckfrage.toBuilder().vorgangName(vorgang.getName()).build());
+ return rueckfragen.stream().map(rueckfrage -> addVorgangData(rueckfrage, vorgang));
+ }
+
+ private Rueckfrage addVorgangData(Rueckfrage rueckfrage, Vorgang vorgang) {
+ return rueckfrage.toBuilder().vorgangName(vorgang.getName()).vorgangNummer(vorgang.getNummer()).build();
}
public String sendRueckfrageAnswer(String samlToken, String rueckfrageId, PostfachNachricht nachricht) {
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
index d9526d0badf420305fb2c8b34af3bfedc64c498a..acc18d8093e83d95447a6f8d63fa95e8b24ab1e9 100644
--- 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
@@ -15,6 +15,7 @@ class Rueckfrage {
private String id;
private String vorgangId;
private String vorgangName;
+ private String vorgangNummer;
private PostfachAddress postfachAddress;
private ZonedDateTime sentAt;
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
index 881bcaa9be2912afa4b5c4824489875bc60b42ca..6e3df04528c6d10ceddb2832d712dea41a3f2bf1 100644
--- 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
@@ -9,4 +9,5 @@ public class Vorgang {
private String id;
private String name;
+ private String nummer;
}
\ No newline at end of file
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/NachrichtId.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/NachrichtId.java
new file mode 100644
index 0000000000000000000000000000000000000000..dbba4ee93f6c56f350c6968a78f122b5231e8477
--- /dev/null
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/NachrichtId.java
@@ -0,0 +1,17 @@
+package de.ozgcloud.nachrichten.postfach;
+
+import org.mapstruct.ObjectFactory;
+
+import de.ozgcloud.common.datatype.StringBasedValue;
+
+class NachrichtId extends StringBasedValue {
+
+ NachrichtId(String vorgangId) {
+ super(vorgangId);
+ }
+
+ @ObjectFactory
+ public static NachrichtId from(String vorgangId) {
+ return new NachrichtId(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 260983f3386173286bddb7641b19d7ab1e7b8df6..154404a4d8c7fb71f22e51016e004f8f63a0f5d6 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
@@ -29,7 +29,7 @@ import java.util.Map;
import java.util.Optional;
import java.util.stream.Stream;
-import org.apache.commons.codec.binary.StringUtils;
+import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Primary;
@@ -37,19 +37,24 @@ import org.springframework.stereotype.Service;
import de.ozgcloud.apilib.common.command.OzgCloudCommand;
import de.ozgcloud.apilib.common.command.OzgCloudCommandService;
+import de.ozgcloud.apilib.user.OzgCloudUserId;
import de.ozgcloud.apilib.vorgang.OzgCloudVorgangId;
import de.ozgcloud.nachrichten.NachrichtenManagerConfiguration;
+import de.ozgcloud.nachrichten.attributes.ClientAttributeService;
import de.ozgcloud.nachrichten.common.vorgang.VorgangService;
+import de.ozgcloud.nachrichten.postfach.PostfachNachricht.Direction;
@Service
@Primary
public class PersistPostfachNachrichtServiceImpl implements PersistPostfachNachrichtService {
private static final String NOT_IMPLEMENTED_MESSAGE = "Not implemented. Use gRPC API instead.";
+
static final String CLIENT = "OzgCloud_NachrichtenManager";
static final String ITEM_NAME = "PostfachMail";
static final String CREATE_ATTACHED_ITEM_ORDER = "CREATE_ATTACHED_ITEM";
+ static final String UPDATE_ATTACHED_ITEM_ORDER = "UPDATE_ATTACHED_ITEM";
static final String CLIENT_FIELD = "client";
static final String VORGANG_ID_FIELD = "vorgangId";
@@ -68,6 +73,8 @@ public class PersistPostfachNachrichtServiceImpl implements PersistPostfachNachr
private AttachedItemRemoteService attachedItemRemoteService;
@Autowired
private PostfachNachrichtMapper postfachNachrichtMapper;
+ @Autowired
+ private ClientAttributeService clientAttributeService;
@Autowired(required = false)
@Qualifier("persistPostfachNachrichtByCommandService")
@@ -75,11 +82,75 @@ public class PersistPostfachNachrichtServiceImpl implements PersistPostfachNachr
@Override
public void persistNachricht(Optional<String> userId, PostfachNachricht nachricht) {
- if (vorgangManagerNachrichtService != null) {
- vorgangManagerNachrichtService.persistNachricht(userId, nachricht);
- return;
+ commandService.create(buildNachrichtCommand(userId, nachricht));
+
+ setHasNewPostfachNachricht(nachricht);
+ }
+
+ OzgCloudCommand buildNachrichtCommand(Optional<String> userId, PostfachNachricht nachricht) {
+ return StringUtils.isBlank(nachricht.getId()) ? buildCreateCommand(userId, nachricht) : buildUpdateCommand(userId, nachricht);
+ }
+
+ OzgCloudCommand buildUpdateCommand(Optional<String> userId, PostfachNachricht nachricht) {
+ return createBaseCommandBuilder(userId, nachricht)
+ .order(UPDATE_ATTACHED_ITEM_ORDER)
+ .relationId(NachrichtId.from(nachricht.getId()))
+ .bodyObject(buildUpdateItem(nachricht))
+ .build();
+ }
+
+ private Map<String, Object> buildUpdateItem(PostfachNachricht nachricht) {
+ return Map.of(
+ CLIENT_FIELD, CLIENT,
+ ITEM_FIELD, postfachNachrichtMapper.mapToMap(nachricht));
+ }
+
+ // TODO pruefen ob referencedNachricht existiert
+ // TODO pruefen ob referencedNachricht in dem postfach des anfragenden liegt
+ @Override
+ public String persistAnswer(String referencedNachrichtId, PostfachNachricht answer) {
+ var enhancedAnswer = answer.toBuilder().referencedNachricht(referencedNachrichtId).build();
+ var command = buildCreateCommand(Optional.ofNullable(answer.getCreatedBy()), enhancedAnswer);
+
+ var commandId = commandService.create(command).getId().toString();
+
+ setHasNewPostfachNachricht(answer);
+
+ return commandId;
+ }
+
+ OzgCloudCommand buildCreateCommand(Optional<String> userId, PostfachNachricht nachricht) {
+ return createBaseCommandBuilder(userId, nachricht)
+ .order(CREATE_ATTACHED_ITEM_ORDER)
+ .relationId(OzgCloudVorgangId.from(nachricht.getVorgangId()))
+ .bodyObject(buildCreateItem(nachricht))
+ .build();
+ }
+
+ OzgCloudCommand.OzgCloudCommandBuilder createBaseCommandBuilder(Optional<String> userId, PostfachNachricht nachricht) {
+ var commandBuilder = OzgCloudCommand.builder().vorgangId(OzgCloudVorgangId.from(nachricht.getVorgangId()));
+
+ userId.map(OzgCloudUserId::from).ifPresent(commandBuilder::createdBy);
+
+ return commandBuilder;
+ }
+
+ Map<String, Object> buildCreateItem(PostfachNachricht nachricht) {
+ return Map.of(
+ CLIENT_FIELD, CLIENT,
+ VORGANG_ID_FIELD, nachricht.getVorgangId(),
+ ITEM_NAME_FIELD, ITEM_NAME,
+ ITEM_FIELD, postfachNachrichtMapper.mapToMap(nachricht));
+ }
+
+ void setHasNewPostfachNachricht(PostfachNachricht nachricht) {
+ if (isIncomingNachricht(nachricht)) {
+ clientAttributeService.setHasNewPostfachNachricht(nachricht.getVorgangId());
}
- throw new UnsupportedOperationException(NOT_IMPLEMENTED_MESSAGE);
+ }
+
+ private boolean isIncomingNachricht(PostfachNachricht nachricht) {
+ return nachricht.getDirection() == Direction.IN;
}
@Override
@@ -129,33 +200,6 @@ public class PersistPostfachNachrichtServiceImpl implements PersistPostfachNachr
.flatMap(attachedItemRemoteService::findReplyAllowedPostfachNachrichts);
}
- // TODO pruefen ob referencedNachricht existiert
- // TODO pruefen ob referencedNachricht in dem postfach des anfragenden liegt
- @Override
- public String persistAnswer(String referencedNachrichtId, PostfachNachricht answer) {
- return commandService.create(buildCommand(setReferencedNachricht(referencedNachrichtId, answer))).getId().toString();
- }
-
- private PostfachNachricht setReferencedNachricht(String referencedNachrichtId, PostfachNachricht answer) {
- return answer.toBuilder().referencedNachricht(referencedNachrichtId).build();
- }
-
- OzgCloudCommand buildCommand(PostfachNachricht nachricht) {
- return OzgCloudCommand.builder().order(CREATE_ATTACHED_ITEM_ORDER)
- .vorgangId(OzgCloudVorgangId.from(nachricht.getVorgangId()))
- .relationId(OzgCloudVorgangId.from(nachricht.getVorgangId()))
- .bodyObject(buildCommandBody(nachricht))
- .build();
- }
-
- Map<String, Object> buildCommandBody(PostfachNachricht nachricht) {
- return Map.of(
- CLIENT_FIELD, CLIENT,
- VORGANG_ID_FIELD, nachricht.getVorgangId(),
- ITEM_NAME_FIELD, ITEM_NAME,
- ITEM_FIELD, postfachNachrichtMapper.mapToMap(nachricht));
- }
-
@Override
public Stream<PostfachNachricht> findAnswers(String serviceKontoType, String postfachId, String rueckfrageId) {
return findPostfachNachricht(serviceKontoType, postfachId)
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..7c9ce56fee998de321c44bb1b0ee9348a33466cc 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
@@ -104,6 +104,7 @@ public abstract class PostfachNachrichtMapper {
return (attachments instanceof String attachment && StringUtils.isNotBlank(attachment)) || attachments instanceof Collection;
}
+ @SuppressWarnings("unchecked")
private Iterable<String> getAttachments(Object attachments) {
if (attachments instanceof String attachment) {
return Collections.singletonList(attachment);
diff --git a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachService.java b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachService.java
index bf5ef519eff7a69d61e9b443a1a6dbb67f049992..90d28db00fc2502aa4397ce64077e7769edbcd33 100644
--- a/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachService.java
+++ b/nachrichten-manager-server/src/main/java/de/ozgcloud/nachrichten/postfach/PostfachService.java
@@ -128,7 +128,6 @@ class PostfachService {
private void persistReceivedMail(PostfachNachricht nachricht) {
persistMail(Optional.empty(), nachricht);
- clientAttributeService.setHasNewPostfachNachricht(nachricht.getVorgangId());
postfachRemoteService.deleteMessage(nachricht.getMessageId());
}
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 8433d492e6c79d56cc689854aca408f5099ce80c..36523ddfe28228a5b7276c294dffcd500b2cea46 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
@@ -28,6 +28,7 @@ import de.ozgcloud.nachrichten.postfach.PostfachNachricht;
import de.ozgcloud.nachrichten.postfach.PostfachNachrichtTestFactory;
class AntragraumServiceTest {
+
@Spy
@InjectMocks
private AntragraumService service;
@@ -202,14 +203,14 @@ class AntragraumServiceTest {
@BeforeEach
void mock() {
- doReturn(Stream.of(RueckfrageTestFactory.create())).when(service).addVorgangName(any(), any());
+ doReturn(Stream.of(RueckfrageTestFactory.create())).when(service).addVorgangData(any(), any());
}
@Test
- void shouldCallAddVorgangNameIfRueckfragenExists() {
+ void shouldCallAddVorgangDataIfRueckfragenExists() {
service.enrichRueckfragen(rueckfragen);
- verify(service).addVorgangName(Collections.singletonList(rueckfrageWithoutVorgangName), RueckfrageTestFactory.VORGANG_ID);
+ verify(service).addVorgangData(Collections.singletonList(rueckfrageWithoutVorgangName), RueckfrageTestFactory.VORGANG_ID);
}
@Test
@@ -220,9 +221,9 @@ class AntragraumServiceTest {
}
}
- @DisplayName("Add vorgang name")
+ @DisplayName("Add vorgang data")
@Nested
- class TestAddVorgangName {
+ class TestAddVorgangData {
private final Rueckfrage rueckfrage = RueckfrageTestFactory.createBuilder()
.vorgangName(null)
@@ -235,20 +236,27 @@ class AntragraumServiceTest {
@Test
void shouldCallGetVorgang() {
- addVorgangName().toList();
+ addVorgangData().toList();
verify(vorgangService).getVorgang(RueckfrageTestFactory.VORGANG_ID);
}
@Test
void shouldSetVorgangName() {
- var rueckfragenWithVorgangName = addVorgangName().toList();
+ var rueckfragenWithVorgangData = addVorgangData().toList();
+
+ assertThat(rueckfragenWithVorgangData.getFirst().getVorgangName()).isEqualTo(VorgangTestFactory.NAME);
+ }
+
+ @Test
+ void shouldSetVorgangNummer() {
+ var rueckfragenWithVorgangData = addVorgangData().toList();
- assertThat(rueckfragenWithVorgangName.getFirst().getVorgangName()).isEqualTo(VorgangTestFactory.NAME);
+ assertThat(rueckfragenWithVorgangData.getFirst().getVorgangNummer()).isEqualTo(VorgangTestFactory.NUMMER);
}
- private Stream<Rueckfrage> addVorgangName() {
- return service.addVorgangName(Collections.singletonList(rueckfrage), RueckfrageTestFactory.VORGANG_ID);
+ private Stream<Rueckfrage> addVorgangData() {
+ return service.addVorgangData(Collections.singletonList(rueckfrage), RueckfrageTestFactory.VORGANG_ID);
}
}
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
index 80e47d727ced49a1e22d2e6441d36d9bf063dae4..cd089671dd93144c8833bbb133e7f41e6453ea39 100644
--- 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
@@ -11,6 +11,7 @@ public class GrpcVorgangWithEingangTestFactory {
public static GrpcVorgangWithEingang.Builder createBuilder() {
return GrpcVorgangWithEingang.newBuilder()
.setId(VorgangTestFactory.ID)
- .setName(VorgangTestFactory.NAME);
+ .setName(VorgangTestFactory.NAME)
+ .setNummer(VorgangTestFactory.NUMMER);
}
}
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
index cf1a3392ca1a68594fe6471921153747a157ea8d..48ef6e441a5be6163176a1d3c34496268053b0d1 100644
--- 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
@@ -8,6 +8,7 @@ public class VorgangTestFactory {
public static final String ID = UUID.randomUUID().toString();
public static final String NAME = LoremIpsum.getInstance().getWords(5);
+ public static final String NUMMER = LoremIpsum.getInstance().getWords(3);
public static Vorgang create() {
return createBuilder().build();
@@ -16,6 +17,7 @@ public class VorgangTestFactory {
public static Vorgang.VorgangBuilder createBuilder() {
return Vorgang.builder()
.id(ID)
- .name(NAME);
+ .name(NAME)
+ .nummer(NUMMER);
}
}
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 02d2d73f90b8d8147e58adcb2c19a5117aa37c0f..844c0e77fa1221167695b1c49e89ca594e2b8fa6 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
@@ -5,6 +5,7 @@ import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import java.util.Map;
+import java.util.Optional;
import java.util.UUID;
import java.util.stream.Stream;
@@ -21,7 +22,9 @@ 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.attributes.ClientAttributeService;
import de.ozgcloud.nachrichten.common.vorgang.VorgangService;
+import de.ozgcloud.nachrichten.postfach.PostfachNachricht.Direction;
import de.ozgcloud.nachrichten.postfach.osi.MessageTestFactory;
class PersistPostfachNachrichtServiceImplTest {
@@ -37,6 +40,221 @@ class PersistPostfachNachrichtServiceImplTest {
private AttachedItemRemoteService attachedItemRemoteService;
@Mock
private PostfachNachrichtMapper postfachNachrichtMapper;
+ @Mock
+ private ClientAttributeService clientAttributeService;
+
+ @DisplayName("Persist nachricht")
+ @Nested
+ class TestPersistNachricht {
+
+ private final String userId = UUID.randomUUID().toString();
+ private final Optional<String> userIdOpt = Optional.of(userId);
+
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.createBuilder().id(null).build();
+
+ private final OzgCloudCommand command = OzgCloudCommand.builder().build();
+
+ @BeforeEach
+ void mock() {
+ doReturn(command).when(service).buildNachrichtCommand(any(), any());
+ }
+
+ @Test
+ void shouldBuildNachrichtCommand() {
+ persistNachricht();
+
+ verify(service).buildNachrichtCommand(userIdOpt, nachricht);
+ }
+
+ @Test
+ void shouldCallCommandService() {
+ persistNachricht();
+
+ verify(commandService).create(command);
+ }
+
+ @Test
+ void shouldSetHasNewPostfachNachricht() {
+ persistNachricht();
+
+ verify(service).setHasNewPostfachNachricht(nachricht);
+ }
+
+ private void persistNachricht() {
+ service.persistNachricht(userIdOpt, nachricht);
+ }
+ }
+
+ @DisplayName("Create base command builder")
+ @Nested
+ class TestCreateBaseComandBuilder {
+
+ private final String userId = UUID.randomUUID().toString();
+ private final Optional<String> userIdOpt = Optional.of(userId);
+
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.createBuilder().id(null).build();
+
+ @Test
+ void shouldContainVorgangId() {
+ var command = service.createBaseCommandBuilder(userIdOpt, nachricht).build();
+
+ assertThat(command.getVorgangId()).hasToString(MessageTestFactory.VORGANG_ID);
+ }
+
+ @DisplayName("created by")
+ @Nested
+ class TestCreatedBy {
+
+ @Test
+ void shouldBeAddIfIsPresent() {
+ var command = service.createBaseCommandBuilder(userIdOpt, nachricht).build();
+
+ assertThat(command.getCreatedBy()).hasToString(userId);
+ }
+
+ @Test
+ void shouldNotBeAddIfMissing() {
+ var command = service.createBaseCommandBuilder(Optional.empty(), nachricht).build();
+
+ assertThat(command.getCreatedBy()).isNull();
+ }
+ }
+ }
+
+ @DisplayName("Build nachricht command")
+ @Nested
+ class TestBuildNachrichtCommand {
+
+ private final String userId = UUID.randomUUID().toString();
+ private final Optional<String> userIdOpt = Optional.of(userId);
+
+ private final OzgCloudCommand command = OzgCloudCommand.builder().build();
+
+ @DisplayName("on present id")
+ @Nested
+ class TestOnPresentId {
+
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.create();
+
+ @BeforeEach
+ void mock() {
+ doReturn(command).when(service).buildUpdateCommand(any(), any());
+ }
+
+ @Test
+ void shouldBuildUpdateCommand() {
+ service.buildNachrichtCommand(userIdOpt, nachricht);
+
+ verify(service).buildUpdateCommand(userIdOpt, nachricht);
+ }
+
+ @Test
+ void shouldReturnValue() {
+ var nachrichtCommand = service.buildNachrichtCommand(userIdOpt, nachricht);
+
+ assertThat(nachrichtCommand).isEqualTo(command);
+ }
+ }
+
+ @DisplayName("on missing id")
+ @Nested
+ class TestOnMissingId {
+
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.createBuilder().id(null).build();
+
+ @BeforeEach
+ void mock() {
+ doReturn(command).when(service).buildCreateCommand(any(), any());
+ }
+
+ @Test
+ void shouldBuildCreateCommand() {
+ service.buildNachrichtCommand(userIdOpt, nachricht);
+
+ verify(service).buildCreateCommand(userIdOpt, nachricht);
+ }
+
+ @Test
+ void shouldReturnValue() {
+ var nachrichtCommand = service.buildNachrichtCommand(userIdOpt, nachricht);
+
+ assertThat(nachrichtCommand).isEqualTo(command);
+ }
+ }
+
+ @DisplayName("for update")
+ @Nested
+ class TestBuildUpdateCommand {
+
+ private final OzgCloudCommand.OzgCloudCommandBuilder commandBuilder = OzgCloudCommand.builder();
+
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.create();
+
+ @BeforeEach
+ void mock() {
+ doReturn(commandBuilder).when(service).createBaseCommandBuilder(any(), any());
+ }
+
+ @Test
+ void shouldCallCreateBaseCommandBuilder() {
+ buildUpdateCommand();
+
+ verify(service).createBaseCommandBuilder(userIdOpt, nachricht);
+ }
+
+ @Test
+ void shouldContainOrder() {
+ var command = buildUpdateCommand();
+
+ assertThat(command.getOrder()).isEqualTo(PersistPostfachNachrichtServiceImpl.UPDATE_ATTACHED_ITEM_ORDER);
+ }
+
+ @Test
+ void shouldContainRelationId() {
+ var command = buildUpdateCommand();
+
+ assertThat(command.getRelationId()).hasToString(PostfachNachrichtTestFactory.ID);
+ }
+
+ @DisplayName("bodyObject")
+ @Nested
+ class TestBodyObject {
+
+ private final Map<String, Object> itemMap = Map.of("dummyKey", "dummyValue");
+
+ @BeforeEach
+ void mock() {
+ when(postfachNachrichtMapper.mapToMap(any())).thenReturn(itemMap);
+ }
+
+ @Test
+ void shouldContainClient() {
+ var command = buildUpdateCommand();
+
+ assertThat(command.getBodyObject()).containsEntry(PersistPostfachNachrichtServiceImpl.CLIENT_FIELD,
+ PersistPostfachNachrichtServiceImpl.CLIENT);
+ }
+
+ @Test
+ void shouldCallMapper() {
+ buildUpdateCommand();
+
+ verify(postfachNachrichtMapper).mapToMap(nachricht);
+ }
+
+ @Test
+ void shouldContainItem() {
+ var command = buildUpdateCommand();
+
+ assertThat(command.getBodyObject()).containsEntry(PersistPostfachNachrichtServiceImpl.ITEM_FIELD, itemMap);
+ }
+ }
+
+ private OzgCloudCommand buildUpdateCommand() {
+ return service.buildUpdateCommand(userIdOpt, nachricht);
+ }
+ }
+ }
@DisplayName("Persist answer")
@Nested
@@ -46,83 +264,98 @@ class PersistPostfachNachrichtServiceImplTest {
private ArgumentCaptor<PostfachNachricht> postfachNachrichtCaptor;
private final OzgCloudCommand command = OzgCloudCommand.builder().id(OzgCloudCommandId.from(UUID.randomUUID().toString())).build();
- private final PostfachNachricht postfachNachricht = PostfachNachrichtTestFactory.createBuilder().referencedNachricht(null).build();
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.createBuilder().referencedNachricht(null).build();
@BeforeEach
void mock() {
- doReturn(command).when(service).buildCommand(any());
+ doReturn(command).when(service).buildCreateCommand(any(), any());
when(commandService.create(any())).thenReturn(command);
}
@Test
void shouldCallBuildCommand() {
- service.persistAnswer(GrpcPostfachMailTestFactory.REFERENCED_NACHRICHT_ID, postfachNachricht);
+ persistAnswer();
- verify(service).buildCommand(postfachNachrichtCaptor.capture());
+ verify(service).buildCreateCommand(eq(Optional.of(PostfachNachrichtTestFactory.CREATED_BY)), postfachNachrichtCaptor.capture());
assertThat(postfachNachrichtCaptor.getValue().getReferencedNachricht()).isEqualTo(GrpcPostfachMailTestFactory.REFERENCED_NACHRICHT_ID);
}
@Test
void shouldCallCommandService() {
- service.persistAnswer(GrpcPostfachMailTestFactory.REFERENCED_NACHRICHT_ID, postfachNachricht);
+ persistAnswer();
verify(commandService).create(command);
}
+
+ @Test
+ void shouldSetHasNewPostfachNachricht() {
+ persistAnswer();
+
+ verify(service).setHasNewPostfachNachricht(nachricht);
+ }
+
+ void persistAnswer() {
+ service.persistAnswer(GrpcPostfachMailTestFactory.REFERENCED_NACHRICHT_ID, nachricht);
+ }
}
- @DisplayName("Build command")
+ @DisplayName("Build create command")
@Nested
- class TestBuildCommand {
+ class TestBuildCreateCommand {
- private final PostfachNachricht postfachNachricht = PostfachNachrichtTestFactory.create();
+ private final OzgCloudCommand.OzgCloudCommandBuilder commandBuilder = OzgCloudCommand.builder();
+
+ private final String userId = UUID.randomUUID().toString();
+ private final Optional<String> userIdOpt = Optional.of(userId);
+
+ private final PostfachNachricht nachricht = PostfachNachrichtTestFactory.createBuilder().id(null).build();
+ private final Map<String, Object> itemMap = Map.of("dummyKey", "dummyValue");
@BeforeEach
void mock() {
- doReturn(Map.of("dummyKey", "dummyValue")).when(service).buildCommandBody(any());
+ doReturn(itemMap).when(service).buildCreateItem(any());
+ doReturn(commandBuilder).when(service).createBaseCommandBuilder(any(), any());
}
@Test
- void shouldHaveSetOrder() {
- var command = service.buildCommand(postfachNachricht);
+ void shouldCallCreateBaseCommandBuilder() {
+ buildCreateCommand();
- assertThat(command.getOrder()).isEqualTo(PersistPostfachNachrichtServiceImpl.CREATE_ATTACHED_ITEM_ORDER);
+ verify(service).createBaseCommandBuilder(userIdOpt, nachricht);
}
@Test
- void shouldHaveSetVorgangId() {
- var command = service.buildCommand(postfachNachricht);
+ void shouldContainOrder() {
+ var command = buildCreateCommand();
- assertThat(command.getVorgangId()).hasToString(MessageTestFactory.VORGANG_ID);
+ assertThat(command.getOrder()).isEqualTo(PersistPostfachNachrichtServiceImpl.CREATE_ATTACHED_ITEM_ORDER);
}
@Test
- void shouldHaveSetRelationId() {
- var command = service.buildCommand(postfachNachricht);
+ void shouldContainRelationId() {
+ var command = buildCreateCommand();
assertThat(command.getRelationId()).hasToString(MessageTestFactory.VORGANG_ID);
}
@Test
- void shouldCallBuildCommandBody() {
- service.buildCommand(postfachNachricht);
+ void shouldContainBodyObject() {
+ var command = buildCreateCommand();
- verify(service).buildCommandBody(postfachNachricht);
+ assertThat(command.getBodyObject()).isEqualTo(itemMap);
}
- @Test
- void shouldHaveSetBodyObjet() {
- var command = service.buildCommand(postfachNachricht);
-
- assertThat(command.getBodyObject()).isNotEmpty();
+ private OzgCloudCommand buildCreateCommand() {
+ return service.buildCreateCommand(userIdOpt, nachricht);
}
}
- @DisplayName("Build command body")
+ @DisplayName("Build create item")
@Nested
class TestBuildCommandBody {
private final PostfachNachricht postfachNachricht = PostfachNachrichtTestFactory.create();
- private Map<String, Object> postfachNachrichtAsMap = Map.of("dummyKey", "dummyValue");
+ private final Map<String, Object> postfachNachrichtAsMap = Map.of("dummyKey", "dummyValue");
@BeforeEach
void mock() {
@@ -131,40 +364,63 @@ class PersistPostfachNachrichtServiceImplTest {
@Test
void shouldHaveSetClient() {
- var body = service.buildCommandBody(postfachNachricht);
+ var body = service.buildCreateItem(postfachNachricht);
assertThat(body).containsEntry(PersistPostfachNachrichtServiceImpl.CLIENT_FIELD, PersistPostfachNachrichtServiceImpl.CLIENT);
}
@Test
void shouldHaveSetVorgangId() {
- var body = service.buildCommandBody(postfachNachricht);
+ var body = service.buildCreateItem(postfachNachricht);
assertThat(body).containsEntry(PersistPostfachNachrichtServiceImpl.VORGANG_ID_FIELD, MessageTestFactory.VORGANG_ID);
}
@Test
void shouldHaveSetItemName() {
- var body = service.buildCommandBody(postfachNachricht);
+ var body = service.buildCreateItem(postfachNachricht);
assertThat(body).containsEntry(PersistPostfachNachrichtServiceImpl.ITEM_NAME_FIELD, PersistPostfachNachrichtServiceImpl.ITEM_NAME);
}
@Test
void shouldCallMapper() {
- service.buildCommandBody(postfachNachricht);
+ service.buildCreateItem(postfachNachricht);
verify(postfachNachrichtMapper).mapToMap(postfachNachricht);
}
@Test
void shouldHaveSetItem() {
- var body = service.buildCommandBody(postfachNachricht);
+ var body = service.buildCreateItem(postfachNachricht);
assertThat(body).containsEntry(PersistPostfachNachrichtServiceImpl.ITEM_FIELD, postfachNachrichtAsMap);
}
}
+ @DisplayName("Set has new postfach nachricht")
+ @Nested
+ class TestSetHasNewPostfachNachricht {
+
+ @Test
+ void shouldCallClientAttributeServiceIfIsIncomingNachricht() {
+ var incomingNachricht = PostfachNachrichtTestFactory.createBuilder().direction(Direction.IN).build();
+
+ service.setHasNewPostfachNachricht(incomingNachricht);
+
+ verify(clientAttributeService).setHasNewPostfachNachricht(MessageTestFactory.VORGANG_ID);
+ }
+
+ @Test
+ void shouldNOTCallClientAttributeServiceIfIsOutgoindNachricht() {
+ var outgoingNachricht = PostfachNachrichtTestFactory.createBuilder().direction(Direction.OUT).build();
+
+ service.setHasNewPostfachNachricht(outgoingNachricht);
+
+ verify(clientAttributeService, never()).setHasNewPostfachNachricht(any());
+ }
+ }
+
@DisplayName("Find answers")
@Nested
class TestFindAnswers {
diff --git a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PostfachServiceTest.java b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PostfachServiceTest.java
index 495a14faa0c0a0889dae79daf0d11a6703860748..ac8d6773fd1e363c8d9552a3307ea4a11c3c613d 100644
--- a/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PostfachServiceTest.java
+++ b/nachrichten-manager-server/src/test/java/de/ozgcloud/nachrichten/postfach/PostfachServiceTest.java
@@ -399,20 +399,6 @@ class PostfachServiceTest {
verify(postfachRemoteService).deleteMessage(MessageTestFactory.MESSAGE_ID);
}
- @Test
- void shouldSetNewPostfachNachricht() {
- service.fetchAndPersistReplies();
-
- verify(clientAttributeService).setHasNewPostfachNachricht(MessageTestFactory.VORGANG_ID);
- }
-
- @Test
- void shouldCallClientAttributeService() {
- service.fetchAndPersistReplies();
-
- verify(clientAttributeService).setHasNewPostfachNachricht(MessageTestFactory.VORGANG_ID);
- }
-
@Test
void shouldThrowNotConfiguredException() {
doReturn(false).when(service).isPostfachConfigured();