diff --git a/goofy-server/src/main/java/de/itvsh/goofy/attached_item/VorgangAttachedItem.java b/goofy-server/src/main/java/de/itvsh/goofy/attached_item/VorgangAttachedItem.java
new file mode 100644
index 0000000000000000000000000000000000000000..12d2e399feabccf3a41a0a6a2c5113d3e5318c01
--- /dev/null
+++ b/goofy-server/src/main/java/de/itvsh/goofy/attached_item/VorgangAttachedItem.java
@@ -0,0 +1,21 @@
+package de.itvsh.goofy.attached_item;
+
+import java.util.Map;
+
+import de.itvsh.goofy.common.command.CommandBody;
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class VorgangAttachedItem implements CommandBody {
+
+ private String id;
+ private long version;
+
+ private String client;
+ private String vorgangId;
+ private String itemName;
+
+ private Map<String, Object> item;
+}
\ No newline at end of file
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/attached_item/VorgangAttachedItemService.java b/goofy-server/src/main/java/de/itvsh/goofy/attached_item/VorgangAttachedItemService.java
new file mode 100644
index 0000000000000000000000000000000000000000..403e258f9f96ca389a398bfdd4d7ce6f60034a59
--- /dev/null
+++ b/goofy-server/src/main/java/de/itvsh/goofy/attached_item/VorgangAttachedItemService.java
@@ -0,0 +1,54 @@
+package de.itvsh.goofy.attached_item;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import de.itvsh.goofy.common.command.Command;
+import de.itvsh.goofy.common.command.CommandBody;
+import de.itvsh.goofy.common.command.CommandBodyMapper;
+import de.itvsh.goofy.common.command.CommandOrder;
+import de.itvsh.goofy.common.command.CommandService;
+import de.itvsh.goofy.common.command.CreateCommand;
+import de.itvsh.goofy.kommentar.Kommentar;
+import de.itvsh.goofy.wiedervorlage.Wiedervorlage;
+
+@Service
+public class VorgangAttachedItemService {
+
+ @Autowired
+ private CommandBodyMapper commandBodyMapper;
+ @Autowired
+ private CommandService commandService;
+
+ static final String WIEDERVORLAGE_ITEM_NAME = "Wiedervorlage";
+ static final String KOMMENTAR_ITEM_NAME = "Kommentar";
+
+ public Command createNewWiedervorlage(Wiedervorlage wiedervorlage, String vorgangId) {
+ var vorgangAttachedItem = buildVorgangAttachedItem(wiedervorlage, vorgangId, WIEDERVORLAGE_ITEM_NAME);
+
+ return commandService.createCommand(buildCreateCommand(vorgangId, vorgangAttachedItem));
+ }
+
+ public Command createNewKommentar(Kommentar kommentar, String vorgangId) {
+ var vorgangAttachedItem = buildVorgangAttachedItem(kommentar, vorgangId, KOMMENTAR_ITEM_NAME);
+
+ return commandService.createCommand(buildCreateCommand(vorgangId, vorgangAttachedItem));
+ }
+
+ VorgangAttachedItem buildVorgangAttachedItem(CommandBody body, String vorgangId, String itemName) {
+ return VorgangAttachedItem.builder()
+ .vorgangId(vorgangId)
+ .itemName(itemName)
+ .item(commandBodyMapper.fromObjectToMap(body))
+ .build();
+ }
+
+ CreateCommand buildCreateCommand(String vorgangId, CommandBody commandBody) {
+ return CreateCommand.builder()
+ .vorgangId(vorgangId)
+ .relationId(vorgangId)
+ .order(CommandOrder.CREATE_ATTACHED_ITEM)
+ .body(commandBody)
+ .build();
+ }
+}
\ No newline at end of file
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandBodyMapper.java b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandBodyMapper.java
index 7941e9f30b61bb38e2a3abc93812fbc39639c62d..1239d61fc27eaf9e55166c7565ad8801b748e55d 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandBodyMapper.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandBodyMapper.java
@@ -26,13 +26,6 @@ public interface CommandBodyMapper {
static final String ITEM_NAME_PROPERTY = "itemName";
static final String ITEM_PROPERTY = "item";
- private Object checkEnumValue(Entry<Object, Object> entry) {
- if (entry.getValue() instanceof Enum<?> enumValue) {
- return enumValue.name();
- }
- return entry.getValue();
- }
-
default GrpcCommandBody mapToBody(Map<String, String> bodyMap) {
if (Objects.isNull(bodyMap)) {
return GrpcCommandBody.getDefaultInstance();
@@ -86,4 +79,11 @@ public interface CommandBodyMapper {
.filter(IS_NOT_VERSION_VALUE)
.collect(Collectors.toMap(entry -> entry.getKey().toString(), this::checkEnumValue));
}
+
+ private Object checkEnumValue(Entry<Object, Object> entry) {
+ if (entry.getValue() instanceof Enum<?> enumValue) {
+ return enumValue.name();
+ }
+ return entry.getValue();
+ }
}
\ No newline at end of file
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandController.java b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandController.java
index 22ff718ba4814b519736975d6647ff2fd6cdccba..98059321e5f0afcc6cd914a3e2f5feefa921ffe6 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandController.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandController.java
@@ -81,14 +81,13 @@ public class CommandController {
command = command.toBuilder()
.vorgangId(vorgangId)
.relationId(relationId)
- .relationVersion(relationVersion)
.build();
if (isSendPostfachMailOrder(command)) {
command = prepareCommandForPostfachNachricht(command, vorgangId);
}
- var created = createCommand(command);
+ var created = createCommand(command, relationVersion);
return ResponseEntity.created(linkTo(CommandController.class).slash(created.getId()).toUri()).build();
}
@@ -119,16 +118,24 @@ public class CommandController {
return vorgangController.getVorgang(vorgangId);
}
- public Command createCommand(CreateCommand command) {
- return service.createCommand(command);
+ public Command createCommand(CreateCommand command, long relationVersion) {
+ return service.createCommand(command, relationVersion);
}
- public Command createCommand(CreateCommand command, String itemName) {
- return service.createCommand(command, itemName);
+ // Anlegen eines Commands fuer eine neue PostfachNachricht(resend)
+ public Command createCommandWithoutRelation(CreateCommand command) {
+ return service.createCommandWithoutRelation(command);
}
- public Command createCommandWithoutValidation(CreateCommand command, String itemName) {
- return service.createCommandWithoutValidation(command, itemName);
+ // Anlegen eines Commands fuer das Editieren einer Wiedervorlage/eines
+ // Kommentares
+ public Command createCommand(CreateCommand command, String itemName, long relationVersion) {
+ return service.createCommand(command, itemName, relationVersion);
+ }
+
+ // Anlegen eines Commands fuer das erledigen/wiedereroeffnen einer Wiedervorlage
+ public Command createCommandWithoutValidation(CreateCommand command, String itemName, long relationVersion) {
+ return service.createCommandWithoutValidation(command, itemName, relationVersion);
}
}
}
\ No newline at end of file
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandService.java b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandService.java
index c3254f8f432ec9fee52f983a7ab55570b00fc26e..28dac75b4cee8d3514bb764db01d2f7fdbf6bc61 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandService.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandService.java
@@ -11,24 +11,50 @@ import org.springframework.validation.annotation.Validated;
import lombok.NonNull;
-@Service
@Validated
-class CommandService {
+@Service
+public class CommandService {
+
+ static final long NO_RELATION_VERSION = -1;
@Autowired
private CommandRemoteService remoteService;
- public Command createCommand(@Valid CreateCommand command) {
+ public Command createCommand(CreateCommand command) {
+ command = command.toBuilder().relationVersion(NO_RELATION_VERSION).build();
+
+ return remoteService.createCommand(command);
+ }
+
+ //////////
+ public Command createCommand(@Valid CreateCommand command, long relationVersion) {
+ command = command.toBuilder().relationVersion(relationVersion).build();
+
return remoteService.createCommand(command);
}
- public Command createCommand(@Valid CreateCommand command, String itemName) {
+ // Anlegen eines Commands fuer eine neue PostfachNachricht(resend)
+ public Command createCommandWithoutRelation(CreateCommand command) {
+ command = command.toBuilder().relationVersion(NO_RELATION_VERSION).build();
+
+ return remoteService.createCommand(command);
+ }
+
+ // Anlegen eines Commands fuer das Editieren einer Wiedervorlage/eines
+ // Kommentares
+ public Command createCommand(@Valid CreateCommand command, String itemName, long relationVersion) {
+ command = command.toBuilder().relationVersion(relationVersion).build();
+
return remoteService.createCommand(command, itemName);
}
- public Command createCommandWithoutValidation(CreateCommand command, String itemName) {
+ // Anlegen eines Commands fuer das erledigen/wiedereroeffnen einer Wiedervorlage
+ public Command createCommandWithoutValidation(CreateCommand command, String itemName, long relationVersion) {
+ command = command.toBuilder().relationVersion(relationVersion).build();
+
return remoteService.createCommand(command, itemName);
}
+ /////////
public Command getById(String commandId) {
return remoteService.getCommand(commandId);
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarCommandController.java b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarCommandController.java
index ec6eff4ce49380eca4a2b631a1786e098b8e373c..02200186665d3280fa44bfced261ba1da9a593be 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarCommandController.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarCommandController.java
@@ -2,8 +2,6 @@ package de.itvsh.goofy.kommentar;
import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.*;
-import java.time.ZonedDateTime;
-
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
@@ -17,7 +15,6 @@ import de.itvsh.goofy.common.command.CommandController;
import de.itvsh.goofy.common.command.CommandController.CommandByRelationController;
import de.itvsh.goofy.common.command.CommandOrder;
import de.itvsh.goofy.common.command.CreateCommand;
-import de.itvsh.goofy.common.user.CurrentUserService;
@RestController
@RequestMapping(KommentarCommandController.KOMMENTAR_COMMANDS)
@@ -34,8 +31,8 @@ public class KommentarCommandController {
@PostMapping
public ResponseEntity<Void> editKommentar(@RequestBody KommentarCommand kommentarCommand, @PathVariable String kommentarId,
@PathVariable long kommentarVersion) {
- var command = commandByRelationController.createCommand(buildCommand(service.getById(kommentarId), kommentarCommand, kommentarVersion),
- KommentarRemoteService.ITEM_NAME);
+ var command = commandByRelationController.createCommand(buildCommand(service.getById(kommentarId), kommentarCommand),
+ KommentarRemoteService.ITEM_NAME, kommentarVersion);
return buildResponseLink(command);
}
@@ -43,11 +40,10 @@ public class KommentarCommandController {
return ResponseEntity.created(linkTo(CommandController.class).slash(createdKommentarCommand.getId()).toUri()).build();
}
- CreateCommand buildCommand(Kommentar kommentar, KommentarCommand command, long kommentarVersion) {
+ CreateCommand buildCommand(Kommentar kommentar, KommentarCommand command) {
var commandBuilder = CreateCommand.builder()
.order(CommandOrder.UPDATE_ATTACHED_ITEM)
.relationId(kommentar.getId())
- .relationVersion(kommentarVersion)
.vorgangId(kommentar.getVorgangId());
return commandBuilder.body(updateKommentarByCommand(kommentar, command)).build();
@@ -61,39 +57,16 @@ public class KommentarCommandController {
@RequestMapping(KommentarCommandByVorgangController.KOMMENTAR_COMMANDS_BY_VORGANG)
public static class KommentarCommandByVorgangController {
- static final String KOMMENTAR_COMMANDS_BY_VORGANG = "/api/vorgangs/{vorgangId}/{relationVersion}/kommentarCommands";
-
- @Autowired
- private CommandByRelationController commandByRelationController;
+ static final String KOMMENTAR_COMMANDS_BY_VORGANG = "/api/vorgangs/{vorgangId}/kommentarCommands";
@Autowired
- private CurrentUserService userService;
+ private KommentarService service;
@PostMapping
- public ResponseEntity<Void> createKommentar(@RequestBody KommentarCommand command, @PathVariable String vorgangId,
- @PathVariable long relationVersion) {
- var createdCommand = commandByRelationController.createCommand(buildCommand(vorgangId, command, relationVersion),
- KommentarRemoteService.ITEM_NAME);
+ public ResponseEntity<Void> createKommentar(@RequestBody KommentarCommand command, @PathVariable String vorgangId) {
+ var createdCommand = service.createKommentar(command, vorgangId);
return ResponseEntity.created(linkTo(CommandController.class).slash(createdCommand.getId()).toUri()).build();
}
-
- CreateCommand buildCommand(String vorgangId, KommentarCommand command, long relationVersion) {
- return CreateCommand.builder()
- .vorgangId(vorgangId)
- .order(CommandOrder.CREATE_ATTACHED_ITEM)
- .relationId(vorgangId)
- .relationVersion(relationVersion)
- .body(buildBody(command.getKommentar()))
- .build();
- }
-
- Kommentar buildBody(Kommentar kommentar) {
- return kommentar.toBuilder()
- .createdAt(ZonedDateTime.now().withNano(0))
- .createdBy(userService.getUserId().toString())
- .build();
- }
-
}
-}
+}
\ No newline at end of file
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarModelAssembler.java b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarModelAssembler.java
index 551ca7d1f3b91f8a1c8df602a45dccdfe95e1563..f1fda7f7fe86d4ef4e4e257c96e08b69a7dc5759 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarModelAssembler.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarModelAssembler.java
@@ -19,8 +19,6 @@ class KommentarModelAssembler implements RepresentationModelAssembler<Kommentar,
static final String REL_CREATE = "create-kommentar";
static final String REL_EDIT = "edit";
- static final long RELATION_ID_ON_CREATE = -1;
-
@Override
public EntityModel<Kommentar> toModel(Kommentar kommentar) {
var selfLink = linkTo(KommentarController.class).slash(kommentar.getId());
@@ -34,7 +32,7 @@ class KommentarModelAssembler implements RepresentationModelAssembler<Kommentar,
public CollectionModel<EntityModel<Kommentar>> toCollectionModel(Stream<Kommentar> entities, String vorgangId) {
return CollectionModel.of(entities.map(this::toModel).collect(Collectors.toList()),
linkTo(KommentarController.class).withSelfRel(),
- linkTo(methodOn(KommentarCommandByVorgangController.class).createKommentar(null, vorgangId, RELATION_ID_ON_CREATE))
+ linkTo(methodOn(KommentarCommandByVorgangController.class).createKommentar(null, vorgangId))
.withRel(REL_CREATE));
}
}
\ No newline at end of file
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarService.java b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarService.java
index 8b14e5f2262ef7a7628d9c2526f3704fa9654707..e2f8a698b46892fa04b36180d7e9285145f026e6 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarService.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarService.java
@@ -1,17 +1,39 @@
package de.itvsh.goofy.kommentar;
+import java.time.ZonedDateTime;
import java.util.stream.Stream;
+import javax.validation.Valid;
+
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
-@Service
+import de.itvsh.goofy.attached_item.VorgangAttachedItemService;
+import de.itvsh.goofy.common.command.Command;
+import de.itvsh.goofy.common.user.CurrentUserService;
+
@Validated
+@Service
class KommentarService {
@Autowired
private KommentarRemoteService remoteService;
+ @Autowired
+ private CurrentUserService currentUserService;
+ @Autowired
+ private VorgangAttachedItemService vorgangAttachedItemService;
+
+ public Command createKommentar(@Valid KommentarCommand kommentarCommand, String vorgangId) {
+ return vorgangAttachedItemService.createNewKommentar(addCreated(kommentarCommand.getKommentar()), vorgangId);
+ }
+
+ Kommentar addCreated(Kommentar kommentar) {
+ return kommentar.toBuilder()
+ .createdAt(ZonedDateTime.now().withNano(0))
+ .createdBy(currentUserService.getUserId().toString())
+ .build();
+ }
public Stream<Kommentar> findByVorgangId(String vorgangId) {
return remoteService.findByVorgangId(vorgangId);
@@ -20,4 +42,4 @@ class KommentarService {
public Kommentar getById(String kommentarId) {
return remoteService.getById(kommentarId);
}
-}
+}
\ No newline at end of file
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/postfach/PostfachMailController.java b/goofy-server/src/main/java/de/itvsh/goofy/postfach/PostfachMailController.java
index c295097dfb4d61ee615ed52ca17ee6c458b92669..aba1528f495b685b32fababbaeff557f283b4eae 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/postfach/PostfachMailController.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/postfach/PostfachMailController.java
@@ -81,8 +81,6 @@ public class PostfachMailController {
static final String POSTFACH_MAIL_COMMAND_PATH = "/api/vorgangs/{vorgangId}/postfachMails/{postfachMailId}/commands"; // NOSONAR
- static final long RELATION_ID_ON_CREATE = -1;
-
@Autowired
private PostfachMailService service;
@Autowired
@@ -94,9 +92,8 @@ public class PostfachMailController {
command = command.toBuilder()
.vorgangId(vorgangId)
.relationId(postfachMailId)
- .relationVersion(RELATION_ID_ON_CREATE)
.build();
- var created = commandByRelationController.createCommand(command);
+ var created = commandByRelationController.createCommandWithoutRelation(command);
service.resendPostfachMail(created.getId(), postfachMailId);
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandController.java b/goofy-server/src/main/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandController.java
index cf2bb3778a08c063cf7a55d81cdd4ac66cfef7ca..c2072d1a51af0629801f486444697fb60403873f 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandController.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandController.java
@@ -2,7 +2,6 @@ package de.itvsh.goofy.wiedervorlage;
import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.*;
-import java.time.ZonedDateTime;
import java.util.Objects;
import org.springframework.beans.factory.annotation.Autowired;
@@ -19,7 +18,6 @@ import de.itvsh.goofy.common.command.CommandController;
import de.itvsh.goofy.common.command.CommandController.CommandByRelationController;
import de.itvsh.goofy.common.command.CommandOrder;
import de.itvsh.goofy.common.command.CreateCommand;
-import de.itvsh.goofy.common.user.CurrentUserService;
@RestController
@RequestMapping(WiedervorlageCommandController.WIEDERVORLAGE_COMMANDS)
@@ -38,7 +36,7 @@ public class WiedervorlageCommandController {
@PathVariable long wiedervorlageVersion) {
var commandWithUpdatedWiedervorlage = buildCommand(service.getById(wiedervorlageId), command, wiedervorlageVersion);
- var createdCommand = createByOrder(commandWithUpdatedWiedervorlage, command.getOrder());
+ var createdCommand = createByOrder(commandWithUpdatedWiedervorlage, command.getOrder(), wiedervorlageVersion);
service.updateNextFrist((Wiedervorlage) commandWithUpdatedWiedervorlage.getBody(), commandWithUpdatedWiedervorlage.getVorgangId());
@@ -64,11 +62,11 @@ public class WiedervorlageCommandController {
}
}
- Command createByOrder(CreateCommand command, CommandOrder commandOrder) {
+ Command createByOrder(CreateCommand command, CommandOrder commandOrder, long wiedervorlageVersion) {
if (shouldBeValidated(commandOrder)) {
- return commandByRelationController.createCommand(command, WiedervorlageRemoteService.ITEM_NAME);
+ return commandByRelationController.createCommand(command, WiedervorlageRemoteService.ITEM_NAME, wiedervorlageVersion);
} else {
- return commandByRelationController.createCommandWithoutValidation(command, WiedervorlageRemoteService.ITEM_NAME);
+ return commandByRelationController.createCommandWithoutValidation(command, WiedervorlageRemoteService.ITEM_NAME, wiedervorlageVersion);
}
}
@@ -88,45 +86,20 @@ public class WiedervorlageCommandController {
@RequestMapping(WiedervorlageCommandByVorgangController.WIEDERVORLAGE_COMMANDS_BY_VORGANG)
public static class WiedervorlageCommandByVorgangController {
- static final String WIEDERVORLAGE_COMMANDS_BY_VORGANG = "/api/vorgangs/{vorgangId}/{relationVersion}/wiedervorlageCommands";
-
- @Autowired
- private CommandByRelationController commandByRelationController;
-
- @Autowired
- private CurrentUserService userService;
+ static final String WIEDERVORLAGE_COMMANDS_BY_VORGANG = "/api/vorgangs/{vorgangId}/wiedervorlageCommands";
@Autowired
private WiedervorlageService service;
@PostMapping
- public ResponseEntity<Void> createWiedervorlage(@RequestBody WiedervorlageCommand command, @PathVariable String vorgangId,
- @PathVariable long relationVersion) {
- var createdCommand = commandByRelationController.createCommand(buildCommand(vorgangId, command, relationVersion),
- WiedervorlageRemoteService.ITEM_NAME);
+ public ResponseEntity<Void> createWiedervorlage(@RequestBody WiedervorlageCommand command, @PathVariable String vorgangId) {
+ var preparedWiedervorlageCommand = command.toBuilder().wiedervorlage(stripAttachmentFileUriToId(command.getWiedervorlage())).build();
+ var createdCommand = service.createWiedervorlage(preparedWiedervorlageCommand, vorgangId);
- service.updateNextFrist(command.getWiedervorlage(), vorgangId);
+ service.updateNextFrist(preparedWiedervorlageCommand.getWiedervorlage(), vorgangId);
return ResponseEntity.created(linkTo(CommandController.class).slash(createdCommand.getId()).toUri()).build();
}
-
- CreateCommand buildCommand(String vorgangId, WiedervorlageCommand command, long relationVersion) {
- return CreateCommand.builder()
- .vorgangId(vorgangId)
- .relationId(vorgangId)
- .relationVersion(relationVersion)
- .order(CommandOrder.CREATE_ATTACHED_ITEM)
- .body(buildBody(command.getWiedervorlage()))
- .build();
- }
-
- Wiedervorlage buildBody(Wiedervorlage wiedervorlage) {
- wiedervorlage = wiedervorlage.toBuilder()
- .createdAt(ZonedDateTime.now().withNano(0))
- .createdBy(userService.getUserId().toString())
- .build();
- return stripAttachmentFileUriToId(wiedervorlage);
- }
}
// TODO Durch LinkedResource am attachment Attribute ersetzen
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/wiedervorlage/WiedervorlageModelAssembler.java b/goofy-server/src/main/java/de/itvsh/goofy/wiedervorlage/WiedervorlageModelAssembler.java
index f6a3282806962bf7d06bf74cc0c433852de550a4..c771af6325aa0bdfd9834eaea21866e3d466aa14 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/wiedervorlage/WiedervorlageModelAssembler.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/wiedervorlage/WiedervorlageModelAssembler.java
@@ -27,8 +27,6 @@ class WiedervorlageModelAssembler implements RepresentationModelAssembler<Wieder
static final String REL_CREATE = "create-wiedervorlage";
static final String REL_UPLOAD_FILE = "uploadFile";
- static final long RELATION_ID_ON_CREATE = -1;
-
private static final Predicate<Wiedervorlage> ALLOW_ERLEDIGEN = wiedervorlage -> !wiedervorlage.isDone();
private static final Predicate<Wiedervorlage> ALLOW_WIEDEREROEFFNEN = Wiedervorlage::isDone;
private static final Predicate<Wiedervorlage> HAS_ATTACHMENTS = wiedervorlage -> !wiedervorlage.getAttachments().isEmpty();
@@ -51,7 +49,7 @@ class WiedervorlageModelAssembler implements RepresentationModelAssembler<Wieder
public CollectionModel<EntityModel<Wiedervorlage>> toCollectionModel(Stream<Wiedervorlage> entities, String vorgangId) {
return CollectionModel.of(entities.map(this::toModel).collect(Collectors.toList()),
linkTo(WiedervorlageController.class).withSelfRel(),
- linkTo(methodOn(WiedervorlageCommandByVorgangController.class).createWiedervorlage(null, vorgangId, RELATION_ID_ON_CREATE))
+ linkTo(methodOn(WiedervorlageCommandByVorgangController.class).createWiedervorlage(null, vorgangId))
.withRel(REL_CREATE),
linkTo(BinaryFileController.class).slash(vorgangId).slash("wiedervorlageAttachment").slash("file")
.withRel(REL_UPLOAD_FILE));
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/wiedervorlage/WiedervorlageService.java b/goofy-server/src/main/java/de/itvsh/goofy/wiedervorlage/WiedervorlageService.java
index 4d6961375b53686657df8aa323f17c06f8eddd96..de585297ea0d63b551f8e6fae89211b88155e3fe 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/wiedervorlage/WiedervorlageService.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/wiedervorlage/WiedervorlageService.java
@@ -1,15 +1,24 @@
package de.itvsh.goofy.wiedervorlage;
import java.time.LocalDate;
+import java.time.ZonedDateTime;
import java.util.Comparator;
import java.util.Optional;
import java.util.function.Predicate;
import java.util.stream.Stream;
+import javax.validation.Valid;
+
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+import de.itvsh.goofy.attached_item.VorgangAttachedItemService;
+import de.itvsh.goofy.common.command.Command;
+import de.itvsh.goofy.common.user.CurrentUserService;
+@Validated
@Service
class WiedervorlageService {
@@ -17,6 +26,21 @@ class WiedervorlageService {
@Autowired
private WiedervorlageRemoteService remoteService;
+ @Autowired
+ private VorgangAttachedItemService vorgangAttachedItemService;
+ @Autowired
+ private CurrentUserService currentUserService;
+
+ public Command createWiedervorlage(@Valid WiedervorlageCommand wiedervorlageCommand, String vorgangId) {
+ return vorgangAttachedItemService.createNewWiedervorlage(addCreated(wiedervorlageCommand.getWiedervorlage()), vorgangId);
+ }
+
+ Wiedervorlage addCreated(Wiedervorlage wiedervorlage) {
+ return wiedervorlage.toBuilder()
+ .createdAt(ZonedDateTime.now().withNano(0))
+ .createdBy(currentUserService.getUserId().toString())
+ .build();
+ }
public Wiedervorlage getById(String wiedervorlageId) {
return remoteService.getById(wiedervorlageId);
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/attached_item/VorgangAttachedItemServiceTest.java b/goofy-server/src/test/java/de/itvsh/goofy/attached_item/VorgangAttachedItemServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab01cf545f688576b0f67c2270b18a9e43499cb5
--- /dev/null
+++ b/goofy-server/src/test/java/de/itvsh/goofy/attached_item/VorgangAttachedItemServiceTest.java
@@ -0,0 +1,180 @@
+package de.itvsh.goofy.attached_item;
+
+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 static org.assertj.core.api.Assertions.*;
+
+import de.itvsh.goofy.common.command.Command;
+import de.itvsh.goofy.common.command.CommandBodyMapper;
+import de.itvsh.goofy.common.command.CommandOrder;
+import de.itvsh.goofy.common.command.CommandService;
+import de.itvsh.goofy.common.command.CommandTestFactory;
+import de.itvsh.goofy.common.command.CreateCommand;
+import de.itvsh.goofy.kommentar.Kommentar;
+import de.itvsh.goofy.kommentar.KommentarTestFactory;
+import de.itvsh.goofy.vorgang.VorgangHeaderTestFactory;
+import de.itvsh.goofy.wiedervorlage.Wiedervorlage;
+import de.itvsh.goofy.wiedervorlage.WiedervorlageTestFactory;
+
+class VorgangAttachedItemServiceTest {
+
+ @Spy
+ @InjectMocks
+ private VorgangAttachedItemService service;
+ @Mock
+ private CommandBodyMapper commandBodyMapper;
+ @Mock
+ private CommandService commandService;
+
+ @DisplayName("Build vorgang attached item")
+ @Nested
+ class TestCreateNewWiedervorlage {
+
+ @DisplayName("should call")
+ @Nested
+ class TestCalls {
+
+ private Wiedervorlage wiedervorlage = WiedervorlageTestFactory.create();
+
+ @BeforeEach
+ void mockServices() {
+ doReturn(VorgangAttachedItemTestFactory.create()).when(service).buildVorgangAttachedItem(any(), any(), any());
+ doReturn(CommandTestFactory.createCreateCommand()).when(service).buildCreateCommand(any(), any());
+ }
+
+ @DisplayName("command service")
+ @Test
+ void shouldCallCommandService() {
+ callCreateNewWiedervorlage();
+
+ verify(commandService).createCommand(any());
+ }
+
+ private Command callCreateNewWiedervorlage() {
+ return service.createNewWiedervorlage(wiedervorlage, VorgangHeaderTestFactory.ID);
+ }
+ }
+ }
+
+ @DisplayName("Create new kommentar")
+ @Nested
+ class TestCreateNewKommentar {
+
+ @DisplayName("should call")
+ @Nested
+ class TestCalls {
+
+ private Kommentar kommentar = KommentarTestFactory.create();
+
+ @BeforeEach
+ void mockServices() {
+ doReturn(VorgangAttachedItemTestFactory.create()).when(service).buildVorgangAttachedItem(any(), any(), any());
+ doReturn(CommandTestFactory.createCreateCommand()).when(service).buildCreateCommand(any(), any());
+ }
+
+ @DisplayName("command service")
+ @Test
+ void shouldCallCommandService() {
+ callCreateNewKommentar();
+
+ verify(commandService).createCommand(any());
+ }
+
+ private Command callCreateNewKommentar() {
+ return service.createNewKommentar(kommentar, VorgangHeaderTestFactory.ID);
+ }
+ }
+ }
+
+ @DisplayName("build createCommand")
+ @Nested
+ class TestBuildVorgangAttachedItem {
+
+ private static final Wiedervorlage BODY = WiedervorlageTestFactory.create();
+
+ @BeforeEach
+ void mockServices() {
+ when(commandBodyMapper.fromObjectToMap(any())).thenReturn(VorgangAttachedItemTestFactory.ITEM);
+ }
+
+ @Test
+ void shouldCallCommandBodyMapper() {
+ buildVorgangAttachedItem();
+
+ verify(commandBodyMapper).fromObjectToMap(BODY);
+ }
+
+ @Test
+ void shouldContainsVorgangId() {
+ var vorgangAttachedItem = buildVorgangAttachedItem();
+
+ assertThat(vorgangAttachedItem.getVorgangId()).isEqualTo(VorgangHeaderTestFactory.ID);
+ }
+
+ @Test
+ void shouldContainsItemName() {
+ var vorgangAttachedItem = buildVorgangAttachedItem();
+
+ assertThat(vorgangAttachedItem.getItemName()).isEqualTo(VorgangAttachedItemService.WIEDERVORLAGE_ITEM_NAME);
+ }
+
+ @Test
+ void shouldContainsItem() {
+ var vorgangAttachedItem = buildVorgangAttachedItem();
+
+ assertThat(vorgangAttachedItem.getItem()).isEqualTo(VorgangAttachedItemTestFactory.ITEM);
+ }
+
+ private VorgangAttachedItem buildVorgangAttachedItem() {
+ return service.buildVorgangAttachedItem(BODY, VorgangHeaderTestFactory.ID,
+ VorgangAttachedItemService.WIEDERVORLAGE_ITEM_NAME);
+ }
+ }
+
+ @DisplayName("build createCommand")
+ @Nested
+ class TestBuildCreateCommand {
+
+ @Test
+ void shouldContainsVorgangId() throws Exception {
+ var createCommand = buildCommand();
+
+ assertThat(createCommand.getVorgangId()).isEqualTo(VorgangHeaderTestFactory.ID);
+ }
+
+ @Test
+ void shouldContainsRelationId() throws Exception {
+ var createCommand = buildCommand();
+
+ assertThat(createCommand.getRelationId()).isEqualTo(VorgangHeaderTestFactory.ID);
+ }
+
+ @Test
+ void shouldContainsOrder() throws Exception {
+ var createCommand = buildCommand();
+
+ assertThat(createCommand.getOrder()).isEqualTo(CommandOrder.CREATE_ATTACHED_ITEM);
+ }
+
+ @Test
+ void shouldContainsBody() throws Exception {
+ var createCommand = buildCommand();
+
+ assertThat(((VorgangAttachedItem) createCommand.getBody())).usingRecursiveComparison()
+ .isEqualTo(VorgangAttachedItemTestFactory.create());
+ }
+
+ private CreateCommand buildCommand() {
+ return service.buildCreateCommand(VorgangHeaderTestFactory.ID, VorgangAttachedItemTestFactory.create());
+ }
+ }
+}
\ No newline at end of file
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/attached_item/VorgangAttachedItemTestFactory.java b/goofy-server/src/test/java/de/itvsh/goofy/attached_item/VorgangAttachedItemTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..e60eb908369e7814decfbda69ee8436618764bcc
--- /dev/null
+++ b/goofy-server/src/test/java/de/itvsh/goofy/attached_item/VorgangAttachedItemTestFactory.java
@@ -0,0 +1,26 @@
+package de.itvsh.goofy.attached_item;
+
+import java.util.Map;
+import java.util.UUID;
+
+public class VorgangAttachedItemTestFactory {
+
+ public static final String ID = UUID.randomUUID().toString();
+ public static final long VERSION = 42;
+ public static final String CLIENT = "Goofy";
+ public static final String ITEM_NAME = "ItemName";
+ public static final Map<String, Object> ITEM = Map.of("oneKey", "oneValue");
+
+ public static VorgangAttachedItem create() {
+ return createBuilder().build();
+ }
+
+ public static VorgangAttachedItem.VorgangAttachedItemBuilder createBuilder() {
+ return VorgangAttachedItem.builder()
+ .id(ID)
+ .version(VERSION)
+ .client(CLIENT)
+ .itemName(ITEM_NAME)
+ .item(ITEM);
+ }
+}
\ No newline at end of file
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/common/command/CommandControllerTest.java b/goofy-server/src/test/java/de/itvsh/goofy/common/command/CommandControllerTest.java
index f7792d08c6f0c4f255f9744f6a32f96c22e6290b..d1974d77858aef0cae2f9b3852af412bc8c4bf2f 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/common/command/CommandControllerTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/common/command/CommandControllerTest.java
@@ -146,7 +146,7 @@ class CommandControllerTest {
@BeforeEach
void initTest() {
- when(service.createCommand(any(CreateCommand.class))).thenReturn(CommandTestFactory.create());
+ when(service.createCommand(any(CreateCommand.class), anyLong())).thenReturn(CommandTestFactory.create());
}
@DisplayName("should return CREATED")
@@ -160,11 +160,11 @@ class CommandControllerTest {
void callService() throws Exception {
doRequest();
- verify(service).createCommand(createCommandCaptor.capture());
+ verify(service).createCommand(createCommandCaptor.capture(), eq(CommandTestFactory.RELATION_VERSION));
assertThat(createCommandCaptor.getValue().getOrder()).isEqualTo(CommandTestFactory.ORDER);
assertThat(createCommandCaptor.getValue().getVorgangId()).isEqualTo(CommandTestFactory.VORGANG_ID);
assertThat(createCommandCaptor.getValue().getRelationId()).isEqualTo(CommandTestFactory.RELATION_ID);
- assertThat(createCommandCaptor.getValue().getRelationVersion()).isEqualTo(CommandTestFactory.RELATION_VERSION);
+ assertThat(createCommandCaptor.getValue().getRelationVersion()).isZero();
}
@DisplayName("should have location header")
@@ -251,6 +251,20 @@ class CommandControllerTest {
}
}
+ @DisplayName("Create by vorgang with relation id")
+ @Nested
+ class TestCreateByVorgangWithoutRelationId {
+
+ private final CreateCommand command = CommandTestFactory.createCreateCommand();
+
+ @Test
+ void shouldCallSerice() {
+ controller.createCommandWithoutRelation(command);
+
+ verify(service).createCommandWithoutRelation(command);
+ }
+ }
+
@Nested
class CreateByVorgangAndItemName {
@@ -262,9 +276,9 @@ class CommandControllerTest {
@Test
void shouldCallService() {
- controller.createCommand(command, ITEM_NAME);
+ controller.createCommand(command, ITEM_NAME, CommandTestFactory.RELATION_VERSION);
- verify(service).createCommand(command, ITEM_NAME);
+ verify(service).createCommand(command, ITEM_NAME, CommandTestFactory.RELATION_VERSION);
}
}
@@ -273,11 +287,10 @@ class CommandControllerTest {
@Test
void shouldCallService() {
- controller.createCommandWithoutValidation(command, ITEM_NAME);
+ controller.createCommandWithoutValidation(command, ITEM_NAME, CommandTestFactory.RELATION_VERSION);
- verify(service).createCommandWithoutValidation(command, ITEM_NAME);
+ verify(service).createCommandWithoutValidation(command, ITEM_NAME, CommandTestFactory.RELATION_VERSION);
}
-
}
}
}
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/common/command/CommandServiceTest.java b/goofy-server/src/test/java/de/itvsh/goofy/common/command/CommandServiceTest.java
index 759269e308b7733181a6b4f2113288d7ffd29e72..a3462fc704138553c8bdfa59344abd35eedb0668 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/common/command/CommandServiceTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/common/command/CommandServiceTest.java
@@ -29,27 +29,61 @@ class CommandServiceTest {
private final CreateCommand command = CommandTestFactory.createCreateCommand();
- @Test
- void shouldCallRemoteServiceWithVersion() {
- service.createCommand(command);
+ @Nested
+ class TestWithCreateCommandOnly {
+
+ @Test
+ void shouldCallRemoteService() {
+ service.createCommand(command);
- verify(remoteService).createCommand(command);
+ verify(remoteService).createCommand(any(CreateCommand.class));
+ }
+
+ @Test
+ void shouldHaveSetRelationVersion() {
+ service.createCommand(command);
+
+ verify(remoteService).createCommand(createCommandCaptor.capture());
+ assertThat(createCommandCaptor.getValue().getRelationVersion()).isEqualTo(CommandService.NO_RELATION_VERSION);
+ }
}
- @Test
- void shouldHaveVorgangId() {
- service.createCommand(command);
+ @Nested
+ class TestWithRelationVersion {
+
+ @Test
+ void shouldCallRemoteService() {
+ service.createCommand(command, CommandTestFactory.RELATION_VERSION);
+
+ verify(remoteService).createCommand(any(CreateCommand.class));
+ }
+
+ @Test
+ void shouldHaveSetRelationId() {
+ service.createCommand(command, CommandTestFactory.RELATION_VERSION);
- verify(remoteService).createCommand(createCommandCaptor.capture());
- assertThat(createCommandCaptor.getValue().getVorgangId()).isEqualTo(CommandTestFactory.VORGANG_ID);
+ verify(remoteService).createCommand(createCommandCaptor.capture());
+ assertThat(createCommandCaptor.getValue().getRelationVersion()).isEqualTo(CommandTestFactory.RELATION_VERSION);
+ }
}
- @Test
- void shouldHaveRelationId() {
- service.createCommand(command);
+ @Nested
+ class TestWithoutRelationVersion {
+
+ @Test
+ void shouldCallRemoteService() {
+ service.createCommandWithoutRelation(command);
+
+ verify(remoteService).createCommand(any(CreateCommand.class));
+ }
+
+ @Test
+ void shouldHaveSetRelationId() {
+ service.createCommandWithoutRelation(command);
- verify(remoteService).createCommand(createCommandCaptor.capture());
- assertThat(createCommandCaptor.getValue().getRelationId()).isEqualTo(CommandTestFactory.RELATION_ID);
+ verify(remoteService).createCommand(createCommandCaptor.capture());
+ assertThat(createCommandCaptor.getValue().getRelationVersion()).isEqualTo(CommandService.NO_RELATION_VERSION);
+ }
}
}
@@ -64,9 +98,17 @@ class CommandServiceTest {
@Test
void shouldCallRemoteService() {
- service.createCommand(command, ITEM_NAME);
+ service.createCommand(command, ITEM_NAME, CommandTestFactory.RELATION_VERSION);
+
+ verify(remoteService).createCommand(any(CreateCommand.class), eq(ITEM_NAME));
+ }
+
+ @Test
+ void shouldHaveSetRelationId() {
+ service.createCommand(command, ITEM_NAME, CommandTestFactory.RELATION_VERSION);
- verify(remoteService).createCommand(command, ITEM_NAME);
+ verify(remoteService).createCommand(createCommandCaptor.capture(), eq(ITEM_NAME));
+ assertThat(createCommandCaptor.getValue().getRelationVersion()).isEqualTo(CommandTestFactory.RELATION_VERSION);
}
}
@@ -75,9 +117,17 @@ class CommandServiceTest {
@Test
void shouldCallRemoteService() {
- service.createCommandWithoutValidation(command, ITEM_NAME);
+ service.createCommandWithoutValidation(command, ITEM_NAME, CommandTestFactory.RELATION_VERSION);
+
+ verify(remoteService).createCommand(any(CreateCommand.class), eq(ITEM_NAME));
+ }
+
+ @Test
+ void shouldHaveSetRelationId() {
+ service.createCommandWithoutValidation(command, ITEM_NAME, CommandTestFactory.RELATION_VERSION);
- verify(remoteService).createCommand(command, ITEM_NAME);
+ verify(remoteService).createCommand(createCommandCaptor.capture(), eq(ITEM_NAME));
+ assertThat(createCommandCaptor.getValue().getRelationVersion()).isEqualTo(CommandTestFactory.RELATION_VERSION);
}
}
}
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/common/user/GoofyUserTestFactory.java b/goofy-server/src/test/java/de/itvsh/goofy/common/user/GoofyUserTestFactory.java
index dd713bdae5e65d6ada50b375071cc6adefb25c4c..fb8a5c667c83e35d0b986946b6a2c45cb59116ff 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/common/user/GoofyUserTestFactory.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/common/user/GoofyUserTestFactory.java
@@ -1,15 +1,20 @@
package de.itvsh.goofy.common.user;
+import java.util.UUID;
+
import de.itvsh.goofy.vorgang.ZustaendigeStelleTestFactory;
public class GoofyUserTestFactory {
+ public static final UserId ID = UserId.from(UUID.randomUUID().toString());
+
public static GoofyUser create() {
return createBuilder().build();
}
public static GoofyUser.GoofyUserBuilder createBuilder() {
return GoofyUser.builder()
+ .id(ID)
.organisationseinheitId(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID);
}
}
\ No newline at end of file
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandControllerTest.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandControllerTest.java
index 219acc66a0825b4d96c68987374a368df05b2228..9f1b8757e60a9fa24b1bc6f89d85296dc56488c9 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandControllerTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandControllerTest.java
@@ -6,8 +6,6 @@ import static org.mockito.Mockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
-import java.util.UUID;
-
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
@@ -27,8 +25,6 @@ import de.itvsh.goofy.common.command.CommandController.CommandByRelationControll
import de.itvsh.goofy.common.command.CommandOrder;
import de.itvsh.goofy.common.command.CommandTestFactory;
import de.itvsh.goofy.common.command.CreateCommand;
-import de.itvsh.goofy.common.user.CurrentUserService;
-import de.itvsh.goofy.common.user.UserId;
import de.itvsh.goofy.kommentar.KommentarCommandController.KommentarCommandByVorgangController;
import de.itvsh.goofy.vorgang.VorgangHeaderTestFactory;
@@ -47,51 +43,26 @@ class KommentarCommandControllerTest {
private KommentarCommandByVorgangController controller;
@Mock
private KommentarService service;
- @Mock
- private CommandByRelationController commandByRelationController;
- @Mock
- private CurrentUserService userService;
private MockMvc mockMvc;
@BeforeEach
void init() {
mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
- when(userService.getUserId()).thenReturn(UserId.from(UUID.randomUUID()));
- when(commandByRelationController.createCommand(any(), anyString())).thenReturn(CommandTestFactory.create());
- }
- @Test
- void shouldReturnCreated() throws Exception {
- doRequest().andExpect(status().isCreated());
+ when(service.createKommentar(any(), any())).thenReturn(CommandTestFactory.create());
}
@Test
void shouldCallService() throws Exception {
doRequest();
- verify(commandByRelationController).createCommand(any(), eq(KommentarRemoteService.ITEM_NAME));
- }
-
- @Test
- void shouldBuildCommand() throws Exception {
- doRequest();
-
- verify(controller).buildCommand(eq(VorgangHeaderTestFactory.ID), any(), eq(RELATION_ID_ON_CREATE));
+ verify(service).createKommentar(any(KommentarCommand.class), eq(VorgangHeaderTestFactory.ID));
}
@Test
- void shouldGiveCommandToService() throws Exception {
- doRequest();
-
- verify(commandByRelationController).createCommand(commandCaptor.capture(), anyString());
- var command = commandCaptor.getValue();
-
- assertThat(command).usingRecursiveComparison()
- .ignoringFields("body", "status", "relationVersion")// TODO relationVersion beachten OZG-2684
- .isEqualTo(CommandTestFactory.createCreateCommandBuilder().order(CommandOrder.CREATE_ATTACHED_ITEM)
- .relationId(VorgangHeaderTestFactory.ID)
- .build());
+ void shouldReturnCreated() throws Exception {
+ doRequest().andExpect(status().isCreated());
}
private ResultActions doRequest() throws Exception {
@@ -120,7 +91,7 @@ class KommentarCommandControllerTest {
@BeforeEach
void init() {
mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
- when(commandByRelationController.createCommand(any(), anyString())).thenReturn(CommandTestFactory.create());
+ when(commandByRelationController.createCommand(any(), anyString(), anyLong())).thenReturn(CommandTestFactory.create());
when(service.getById(any())).thenReturn(KommentarTestFactory.createBuilder().vorgangId(VorgangHeaderTestFactory.ID).build());
}
@@ -140,14 +111,14 @@ class KommentarCommandControllerTest {
void shouldBuildCommand() throws Exception {
doRequest();
- verify(controller).buildCommand(any(Kommentar.class), any(KommentarCommand.class), eq(KommentarTestFactory.VERSION));
+ verify(controller).buildCommand(any(Kommentar.class), any(KommentarCommand.class));
}
@Test
void shouldGiveCommandToService() throws Exception {
doRequest();
- verify(commandByRelationController).createCommand(commandCaptor.capture(), anyString());
+ verify(commandByRelationController).createCommand(commandCaptor.capture(), anyString(), anyLong());
var command = commandCaptor.getValue();
assertThat(command).usingRecursiveComparison()
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandITCase.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandITCase.java
index 32783371fc29bcfedc774f68e76e8bd213531a61..45ce5ed15a923cf3daaa9d7d919e6bbbd7695461 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandITCase.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandITCase.java
@@ -115,14 +115,14 @@ class KommentarCommandITCase {
@BeforeEach
void initTest() {
when(remoteService.getById(any())).thenReturn(KommentarTestFactory.create());
- when(commandRemoteService.createCommand(any(), anyString())).thenReturn(CommandTestFactory.create());
+ when(commandRemoteService.createCommand(any())).thenReturn(CommandTestFactory.create());
}
@Test
void shouldCreateCommand() throws Exception {
doRequestByVorgangId(createValidRequestContent()).andExpect(status().isCreated());
- verify(commandRemoteService).createCommand(any(), eq(KommentarRemoteService.ITEM_NAME));
+ verify(commandRemoteService).createCommand(any());
}
@WithMockUser
@@ -130,6 +130,8 @@ class KommentarCommandITCase {
@Nested
class TestValidation {
+ private static final String FIELD_PREFIX = "kommentarCommand.kommentar";
+
@DisplayName("for null Text")
@Test
void createCommandWithInvalidText() throws Exception {
@@ -137,7 +139,7 @@ class KommentarCommandITCase {
doRequestByVorgangId(content).andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.issues.length()").value(1))
- .andExpect(jsonPath("$.issues.[0].field").value("command.body.text"))
+ .andExpect(jsonPath("$.issues.[0].field").value(FIELD_PREFIX + ".text"))
.andExpect(jsonPath("$.issues.[0].messageCode").value(ValidationMessageCodes.FIELD_IS_EMPTY));
}
@@ -147,7 +149,7 @@ class KommentarCommandITCase {
String content = buildContentWithText(StringUtils.EMPTY);
doRequestByVorgangId(content).andExpect(status().isUnprocessableEntity())
- .andExpect(jsonPath("$.issues.[0].field").value("command.body.text"));
+ .andExpect(jsonPath("$.issues.[0].field").value(FIELD_PREFIX + ".text"));
}
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarModelAssemblerTest.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarModelAssemblerTest.java
index 8599e12e747a09a2d0a6fe59ac16e12d87ae2a31..9e605466c1e115ca671e7152d75376ba46ada19d 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarModelAssemblerTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarModelAssemblerTest.java
@@ -76,7 +76,7 @@ class KommentarModelAssemblerTest {
assertThat(link).isPresent();
assertThat(link.get().getHref()).isEqualTo(
- "/api/vorgangs/" + VorgangHeaderTestFactory.ID + "/" + KommentarModelAssembler.RELATION_ID_ON_CREATE + "/kommentarCommands");
+ "/api/vorgangs/" + VorgangHeaderTestFactory.ID + "/kommentarCommands");
}
}
}
\ No newline at end of file
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarServiceTest.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarServiceTest.java
index d7193d38b9d8ba7ae8385d7e2414f0e42a2d45e8..084812e5f76e99e0efbbb4430605467c68a57c57 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarServiceTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarServiceTest.java
@@ -1,21 +1,103 @@
package de.itvsh.goofy.kommentar;
+import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
+import java.time.ZonedDateTime;
+import java.time.temporal.ChronoUnit;
+
+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 static org.assertj.core.api.Assertions.*;
+import de.itvsh.goofy.attached_item.VorgangAttachedItemService;
+import de.itvsh.goofy.common.command.Command;
+import de.itvsh.goofy.common.command.CommandTestFactory;
+import de.itvsh.goofy.common.user.CurrentUserService;
+import de.itvsh.goofy.common.user.GoofyUserTestFactory;
import de.itvsh.goofy.vorgang.VorgangHeaderTestFactory;
class KommentarServiceTest {
+ @Spy
@InjectMocks
private KommentarService service;
-
@Mock
private KommentarRemoteService remoteService;
+ @Mock
+ private VorgangAttachedItemService vorgangAttachedItemService;
+ @Mock
+ private CurrentUserService currentUserService;
+
+ @DisplayName("Create kommentar")
+ @Nested
+ class TestCreateKommentar {
+
+ @DisplayName("should")
+ @Nested
+ class TestCalls {
+
+ @BeforeEach
+ void mockServices() {
+ doReturn(KommentarTestFactory.create()).when(service).addCreated(any());
+ when(vorgangAttachedItemService.createNewKommentar(any(), any())).thenReturn(CommandTestFactory.create());
+ }
+
+ @DisplayName("add created")
+ @Test
+ void shouldAddCreated() {
+ callCreateKommentar();
+
+ verify(service).addCreated(any(Kommentar.class));
+ }
+
+ @DisplayName("call vorgangattacheditem service")
+ @Test
+ void shouldCallVorgangAttachedItemService() {
+ callCreateKommentar();
+
+ verify(vorgangAttachedItemService).createNewKommentar(any(Kommentar.class), eq(VorgangHeaderTestFactory.ID));
+ }
+ }
+
+ @DisplayName("Add created")
+ @Nested
+ class TestAddCreated {
+
+ @BeforeEach
+ void mockServices() {
+ when(currentUserService.getUserId()).thenReturn(GoofyUserTestFactory.ID);
+ }
+
+ @Test
+ void shouldSetCreatedAt() throws Exception {
+ var kommentar = callAddCreated();
+
+ assertThat(kommentar.getCreatedAt()).isNotNull().isCloseTo(ZonedDateTime.now(), within(2, ChronoUnit.SECONDS));
+ }
+
+ @Test
+ void shouldSetCreatedBy() throws Exception {
+ var kommentar = callAddCreated();
+
+ assertThat(kommentar.getCreatedBy()).isEqualTo(GoofyUserTestFactory.ID.toString());
+ }
+
+ private Kommentar callAddCreated() {
+ return service.addCreated(KommentarTestFactory.createBuilder().createdAt(null).createdBy(null).build());
+ }
+ }
+
+ private Command callCreateKommentar() {
+ return service.createKommentar(KommentarCommandTestFactory.create(), VorgangHeaderTestFactory.ID);
+ }
+ }
@Nested
class TestGetById {
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/postfach/PostfachMailCommandControllerTest.java b/goofy-server/src/test/java/de/itvsh/goofy/postfach/PostfachMailCommandControllerTest.java
index 607cc4ada5037eb8aef73b6350b786ebe6837b86..77f85fb625a2744ebe45085cd8731efaf93104c1 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/postfach/PostfachMailCommandControllerTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/postfach/PostfachMailCommandControllerTest.java
@@ -17,8 +17,6 @@ import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultActions;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
-import static org.assertj.core.api.Assertions.*;
-
import de.itvsh.goofy.common.command.CommandController.CommandByRelationController;
import de.itvsh.goofy.common.command.CommandTestFactory;
import de.itvsh.goofy.common.command.CreateCommand;
@@ -49,15 +47,14 @@ class PostfachMailCommandControllerTest {
@BeforeEach
void mockController() {
- when(commandByRelationController.createCommand(any(CreateCommand.class))).thenReturn(CommandTestFactory.create());
+ when(commandByRelationController.createCommandWithoutRelation(any(CreateCommand.class))).thenReturn(CommandTestFactory.create());
}
@Test
void shouldCallCommandByRelationController() throws Exception {
doRequest();
- verify(commandByRelationController).createCommand(createCommandCaptor.capture());
- assertThat(createCommandCaptor.getValue().getRelationVersion()).isEqualTo(PostfachMailCommandController.RELATION_ID_ON_CREATE);
+ verify(commandByRelationController).createCommandWithoutRelation(createCommandCaptor.capture());
}
@Test
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandByVorgangControllerTest.java b/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandByVorgangControllerTest.java
index 552717bfd37235877ec24a5ba13208001ecfadd0..d7943300b584b4b9ab37f935fa05e6b3aebb3c25 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandByVorgangControllerTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandByVorgangControllerTest.java
@@ -5,9 +5,6 @@ import static org.mockito.Mockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
-import java.time.ZonedDateTime;
-import java.time.temporal.ChronoUnit;
-
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
@@ -22,16 +19,10 @@ import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultActions;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
-import static org.assertj.core.api.Assertions.*;
-
-import de.itvsh.goofy.common.binaryfile.BinaryFileTestFactory;
-import de.itvsh.goofy.common.binaryfile.FileId;
import de.itvsh.goofy.common.command.CommandController.CommandByRelationController;
-import de.itvsh.goofy.common.command.CommandOrder;
import de.itvsh.goofy.common.command.CommandTestFactory;
import de.itvsh.goofy.common.command.CreateCommand;
import de.itvsh.goofy.common.user.CurrentUserService;
-import de.itvsh.goofy.common.user.UserTestFactory;
import de.itvsh.goofy.vorgang.VorgangHeaderTestFactory;
import de.itvsh.goofy.wiedervorlage.WiedervorlageCommandController.WiedervorlageCommandByVorgangController;
@@ -51,8 +42,6 @@ class WiedervorlageCommandByVorgangControllerTest {
private ArgumentCaptor<CreateCommand> createCommandCaptor;
private MockMvc mockMvc;
- private static final long RELATION_VERSION = -1;
-
@BeforeEach
void init() {
mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
@@ -64,30 +53,17 @@ class WiedervorlageCommandByVorgangControllerTest {
@BeforeEach
void mockUserService() {
- when(userService.getUserId()).thenReturn(UserTestFactory.ID);
+ when(service.createWiedervorlage(any(), any())).thenReturn(CommandTestFactory.create());
}
@Nested
class ServiceMethod {
- @BeforeEach
- void initMocks() {
- when(commandByRelationController.createCommand(any(), any())).thenReturn(CommandTestFactory.create());
- }
-
- @Test
- void shouldCallCommandByRelationController() throws Exception {
- doRequest();
-
- verify(commandByRelationController).createCommand(any(CreateCommand.class),
- eq(WiedervorlageRemoteService.ITEM_NAME));
- }
-
@Test
- void shouldBuildCommand() throws Exception {
+ void shouldCallService() throws Exception {
doRequest();
- verify(controller).buildCommand(eq(VorgangHeaderTestFactory.ID), any(WiedervorlageCommand.class), eq(RELATION_VERSION));
+ verify(service).createWiedervorlage(any(WiedervorlageCommand.class), eq(VorgangHeaderTestFactory.ID));
}
@Test
@@ -102,95 +78,12 @@ class WiedervorlageCommandByVorgangControllerTest {
doRequest().andExpect(status().isCreated());
}
}
-
- @Nested
- class BuildCreateCommand {
-
- @Test
- void shouldContainsOrder() throws Exception {
- var createCommand = buildCommand();
-
- assertThat(createCommand.getOrder()).isEqualTo(CommandOrder.CREATE_ATTACHED_ITEM);
- }
-
- @Test
- void shouldContainsVorgangId() throws Exception {
- var createCommand = buildCommand();
-
- assertThat(createCommand.getVorgangId()).isEqualTo(VorgangHeaderTestFactory.ID);
- }
-
- @Test
- void shouldContainsRelationId() throws Exception {
- var createCommand = buildCommand();
-
- assertThat(createCommand.getRelationId()).isEqualTo(VorgangHeaderTestFactory.ID);
- }
-
- @Test
- void shouldContainsRelationVersion() throws Exception {
- var createCommand = buildCommand();
-
- assertThat(createCommand.getRelationVersion()).isEqualTo(RELATION_VERSION);
- }
-
- @Test
- void shouldContainsBody() throws Exception {
- var createCommand = buildCommand();
-
- assertThat(((Wiedervorlage) createCommand.getBody())).usingRecursiveComparison().ignoringFields("createdAt", "createdBy")
- .isEqualTo(WiedervorlageTestFactory.create());
- }
-
- private CreateCommand buildCommand() {
- return controller.buildCommand(VorgangHeaderTestFactory.ID, WiedervorlageCommandTestFactory.create(), RELATION_VERSION);
- }
- }
-
- @Nested
- class BuildBody {
-
- private final Wiedervorlage wiedervorlage = WiedervorlageTestFactory.create();
-
- @Test
- void shouldSetCreatedAt() {
- var enrichedWiedervorlage = buildBody(wiedervorlage.toBuilder().createdAt(null).build());
-
- assertThat(enrichedWiedervorlage.getCreatedAt()).isCloseTo(ZonedDateTime.now().withNano(0),
- within(2, ChronoUnit.SECONDS));
- }
-
- @Test
- void shouldSetCreatedBy() {
- var enrichedWiedervorlage = buildBody(wiedervorlage.toBuilder().createdBy(null).build());
-
- assertThat(enrichedWiedervorlage.getCreatedBy()).isEqualTo(UserTestFactory.ID.toString());
- }
-
- @Nested
- class StripAttachmentFileUriToId {
-
- @Test
- void shouldStripFileUriToFileId() {
- var fileIdAsUri = FileId.from("api/irgendwas/dazwischen/" + BinaryFileTestFactory.ID);
- var wiedervorlageWithAttachmentAsFileUri = WiedervorlageTestFactory.createBuilder().attachment(fileIdAsUri).build();
-
- var wiedervorlage = buildBody(wiedervorlageWithAttachmentAsFileUri);
-
- assertThat(wiedervorlage.getAttachments().get(0)).isEqualTo(BinaryFileTestFactory.FILE_ID);
- }
- }
-
- private Wiedervorlage buildBody(Wiedervorlage wiedervorlage) {
- return controller.buildBody(wiedervorlage);
- }
- }
}
private ResultActions doRequest() throws Exception {
return mockMvc.perform(
post(WiedervorlageCommandByVorgangController.WIEDERVORLAGE_COMMANDS_BY_VORGANG,
- VorgangHeaderTestFactory.ID, RELATION_VERSION)
+ VorgangHeaderTestFactory.ID)
.content(WiedervorlageCommandTestFactory.createValidRequestContent())
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().is2xxSuccessful());
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandControllerTest.java b/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandControllerTest.java
index ae40b90507521a107252fa025df4682772dd11bf..a5d337f05f22aac349185fff4d2d83de23b0d027 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandControllerTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandControllerTest.java
@@ -22,6 +22,7 @@ import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import static org.assertj.core.api.Assertions.*;
import de.itvsh.goofy.common.binaryfile.BinaryFileTestFactory;
+import de.itvsh.goofy.common.binaryfile.FileId;
import de.itvsh.goofy.common.command.Command;
import de.itvsh.goofy.common.command.CommandController.CommandByRelationController;
import de.itvsh.goofy.common.command.CommandOrder;
@@ -62,7 +63,7 @@ class WiedervorlageCommandControllerTest {
@BeforeEach
void init() {
when(service.getById(any())).thenReturn(WiedervorlageTestFactory.create());
- doReturn(CommandTestFactory.create()).when(controller).createByOrder(any(), any());
+ doReturn(CommandTestFactory.create()).when(controller).createByOrder(any(), any(), anyLong());
}
@Test
@@ -76,7 +77,7 @@ class WiedervorlageCommandControllerTest {
void shouldCallCreateByOrderController() throws Exception {
doRequest();
- verify(controller).createByOrder(any(), any());
+ verify(controller).createByOrder(any(), any(), anyLong());
}
@Test
@@ -246,7 +247,8 @@ class WiedervorlageCommandControllerTest {
void shouldCallCreateCommand() {
createCommandByOrder(CommandOrder.EDIT_WIEDERVORLAGE);
- verify(commandByRelationController).createCommand(any(), eq(WiedervorlageRemoteService.ITEM_NAME));
+ verify(commandByRelationController).createCommand(any(), eq(WiedervorlageRemoteService.ITEM_NAME),
+ eq(WiedervorlageTestFactory.VERSION));
}
}
@@ -257,7 +259,8 @@ class WiedervorlageCommandControllerTest {
void shouldCallCreateCommandWithoutValidation() {
createCommandByOrder(CommandOrder.WIEDERVORLAGE_ERLEDIGEN);
- verify(commandByRelationController).createCommandWithoutValidation(any(), eq(WiedervorlageRemoteService.ITEM_NAME));
+ verify(commandByRelationController).createCommandWithoutValidation(any(), eq(WiedervorlageRemoteService.ITEM_NAME),
+ eq(WiedervorlageTestFactory.VERSION));
}
}
@@ -268,13 +271,28 @@ class WiedervorlageCommandControllerTest {
void shouldCallCreateCommandWithoutValidation() {
createCommandByOrder(CommandOrder.WIEDERVORLAGE_WIEDEREROEFFNEN);
- verify(commandByRelationController).createCommandWithoutValidation(any(), eq(WiedervorlageRemoteService.ITEM_NAME));
+ verify(commandByRelationController).createCommandWithoutValidation(any(), eq(WiedervorlageRemoteService.ITEM_NAME),
+ eq(WiedervorlageTestFactory.VERSION));
}
}
private Command createCommandByOrder(CommandOrder order) {
- return controller.createByOrder(CommandTestFactory.createCreateCommand(), order);
+ return controller.createByOrder(CommandTestFactory.createCreateCommand(), order, WiedervorlageTestFactory.VERSION);
}
}
}
+
+ @Nested
+ class StripAttachmentFileUriToId {
+
+ @Test
+ void shouldStripFileUriToFileId() {
+ var fileIdAsUri = FileId.from("api/irgendwas/dazwischen/" + BinaryFileTestFactory.ID);
+ var wiedervorlageWithAttachmentAsFileUri = WiedervorlageTestFactory.createBuilder().attachment(fileIdAsUri).build();
+
+ var wiedervorlage = WiedervorlageCommandController.stripAttachmentFileUriToId(wiedervorlageWithAttachmentAsFileUri);
+
+ assertThat(wiedervorlage.getAttachments().get(0)).isEqualTo(BinaryFileTestFactory.FILE_ID);
+ }
+ }
}
\ No newline at end of file
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandITCase.java b/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandITCase.java
index e93af260521099e54007a668668f9283457ed1d8..d6041830348dbd90fce3fc6d6ebbcb7f70b1e532 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandITCase.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageCommandITCase.java
@@ -150,7 +150,7 @@ class WiedervorlageCommandITCase {
@BeforeEach
void initTest() {
- when(commandRemoteService.createCommand(any(), anyString())).thenReturn(CommandTestFactory.create());
+ when(commandRemoteService.createCommand(any())).thenReturn(CommandTestFactory.create());
when(wiedervorlageRemoteService.getById(anyString())).thenReturn(WiedervorlageTestFactory.create());
}
@@ -158,7 +158,7 @@ class WiedervorlageCommandITCase {
void shouldCreateCommand() throws Exception {
doRequest(createValidRequestContent()).andExpect(status().isCreated());
- verify(commandRemoteService).createCommand(any(), anyString());
+ verify(commandRemoteService).createCommand(any());
}
@WithMockUser
@@ -166,6 +166,8 @@ class WiedervorlageCommandITCase {
@Nested
class TestValidation {
+ private static final String FIELD_PREFIX = "wiedervorlageCommand.wiedervorlage";
+
@DisplayName("for null Betreff")
@Test
void createCommandWithInvalidBetreff() throws Exception {
@@ -173,7 +175,7 @@ class WiedervorlageCommandITCase {
doRequest(content).andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.issues.length()").value(1))
- .andExpect(jsonPath("$.issues.[0].field").value("command.body.betreff"))
+ .andExpect(jsonPath("$.issues.[0].field").value(FIELD_PREFIX + ".betreff"))
.andExpect(jsonPath("$.issues.[0].messageCode").value(ValidationMessageCodes.FIELD_IS_EMPTY));
}
@@ -183,7 +185,7 @@ class WiedervorlageCommandITCase {
String content = buildContentWithBetreff("a");
doRequest(content).andExpect(status().isUnprocessableEntity())
- .andExpect(jsonPath("$.issues.[0].field").value("command.body.betreff"));
+ .andExpect(jsonPath("$.issues.[0].field").value(FIELD_PREFIX + ".betreff"));
}
@@ -215,7 +217,7 @@ class WiedervorlageCommandITCase {
doRequest(content).andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.issues.length()").value(1))
- .andExpect(jsonPath("$.issues.[0].field").value("command.body.frist"))
+ .andExpect(jsonPath("$.issues.[0].field").value(FIELD_PREFIX + ".frist"))
.andExpect(jsonPath("$.issues.[0].messageCode").value(ValidationMessageCodes.FIELD_DATE_PAST));
}
@@ -227,7 +229,7 @@ class WiedervorlageCommandITCase {
doRequest(content).andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.issues.length()").value(1))
- .andExpect(jsonPath("$.issues.[0].field").value("command.body.frist"))
+ .andExpect(jsonPath("$.issues.[0].field").value(FIELD_PREFIX + ".frist"))
.andExpect(jsonPath("$.issues.[0].messageCode").value(ValidationMessageCodes.FIELD_IS_EMPTY));
}
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageModelAssemblerTest.java b/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageModelAssemblerTest.java
index 6d29f9637bc0aa28701358c9e50efb46abada82b..9106cf6495d827777b93143782f93cdc6d52dd1e 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageModelAssemblerTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageModelAssemblerTest.java
@@ -133,8 +133,7 @@ class WiedervorlageModelAssemblerTest {
var link = collectionModel.getLink(WiedervorlageModelAssembler.REL_CREATE);
assertThat(link).isPresent();
- assertThat(link.get().getHref()).isEqualTo("/api/vorgangs/" + VorgangHeaderTestFactory.ID + "/"
- + WiedervorlageModelAssembler.RELATION_ID_ON_CREATE + "/wiedervorlageCommands");
+ assertThat(link.get().getHref()).isEqualTo("/api/vorgangs/" + VorgangHeaderTestFactory.ID + "/wiedervorlageCommands");
}
@Test
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageServiceTest.java b/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageServiceTest.java
index 1609042fd1f5e58458f8dffa0dd91f1970e9c338..7ce0f902d948916578a78eb94589685a507fe0bd 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageServiceTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/wiedervorlage/WiedervorlageServiceTest.java
@@ -1,15 +1,16 @@
package de.itvsh.goofy.wiedervorlage;
-import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import java.time.LocalDate;
+import java.time.ZonedDateTime;
import java.time.temporal.ChronoUnit;
import java.util.Optional;
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.ArgumentMatchers;
@@ -17,6 +18,14 @@ import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
+import static org.assertj.core.api.Assertions.*;
+
+import de.itvsh.goofy.attached_item.VorgangAttachedItemService;
+import de.itvsh.goofy.common.command.Command;
+import de.itvsh.goofy.common.command.CommandService;
+import de.itvsh.goofy.common.command.CommandTestFactory;
+import de.itvsh.goofy.common.user.CurrentUserService;
+import de.itvsh.goofy.common.user.GoofyUserTestFactory;
import de.itvsh.goofy.vorgang.VorgangHeaderTestFactory;
class WiedervorlageServiceTest {
@@ -24,9 +33,78 @@ class WiedervorlageServiceTest {
@Spy
@InjectMocks
private WiedervorlageService service;
-
@Mock
private WiedervorlageRemoteService remoteService;
+ @Mock
+ private VorgangAttachedItemService vorgangAttachedItemService;
+ @Mock
+ private CommandService commandService;
+ @Mock
+ private CurrentUserService currentUserService;
+
+ @DisplayName("Create wiedervorlage")
+ @Nested
+ class TestCreateWiedervorlage {
+
+ @DisplayName("should")
+ @Nested
+ class TestCalls {
+
+ @BeforeEach
+ void mockServices() {
+ doReturn(WiedervorlageTestFactory.create()).when(service).addCreated(any());
+ when(vorgangAttachedItemService.createNewWiedervorlage(any(), any())).thenReturn(CommandTestFactory.create());
+ }
+
+ @DisplayName("add created")
+ @Test
+ void shouldAddCreated() {
+ callCreateWiedervorlage();
+
+ verify(service).addCreated(any(Wiedervorlage.class));
+ }
+
+ @DisplayName("call vorgangattacheditem service")
+ @Test
+ void shouldCallVorgangAttachedItemService() {
+ callCreateWiedervorlage();
+
+ verify(vorgangAttachedItemService).createNewWiedervorlage(any(Wiedervorlage.class), eq(VorgangHeaderTestFactory.ID));
+ }
+ }
+
+ @DisplayName("Add created")
+ @Nested
+ class TestAddCreated {
+
+ @BeforeEach
+ void mockServices() {
+ when(currentUserService.getUserId()).thenReturn(GoofyUserTestFactory.ID);
+ }
+
+ @Test
+ void shouldSetCreatedAt() throws Exception {
+ var wiedervorlage = callAddCreated();
+
+ assertThat(wiedervorlage.getCreatedAt()).isNotNull().isCloseTo(ZonedDateTime.now(), within(2, ChronoUnit.SECONDS));
+ }
+
+ @Test
+ void shouldSetCreatedBy() throws Exception {
+ var wiedervorlage = callAddCreated();
+
+ assertThat(wiedervorlage.getCreatedBy()).isEqualTo(GoofyUserTestFactory.ID.toString());
+ }
+
+ private Wiedervorlage callAddCreated() {
+ return service.addCreated(WiedervorlageTestFactory.createBuilder().createdAt(null).createdBy(null).build());
+ }
+ }
+
+ private Command callCreateWiedervorlage() {
+ return service.createWiedervorlage(WiedervorlageCommandTestFactory.create(), VorgangHeaderTestFactory.ID);
+ }
+ }
@Nested
class TestGetById {