Merge branch 'master' into OZG-4897-tailwind-umstellung

alfa-client/pom.xml

@@ -29,7 +29,7 @@
 	<parent>
 		<groupId>de.ozgcloud.alfa</groupId>
 		<artifactId>alfa</artifactId>
-		<version>2.3.0-SNAPSHOT</version>
+		<version>2.4.0-SNAPSHOT</version>
 	</parent>
 
     <modelVersion>4.0.0</modelVersion>

alfa-server/pom.xml

@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>de.ozgcloud.alfa</groupId>
 		<artifactId>alfa</artifactId>
-		<version>2.3.0-SNAPSHOT</version>
+		<version>2.4.0-SNAPSHOT</version>
 	</parent>
 
 	<artifactId>alfa-server</artifactId>

alfa-service/pom.xml

@@ -31,7 +31,7 @@
 	<parent>
 		<groupId>de.ozgcloud.alfa</groupId>
 		<artifactId>alfa</artifactId>
-		<version>2.3.0-SNAPSHOT</version>
+		<version>2.4.0-SNAPSHOT</version>
 	</parent>
 
 	<artifactId>alfa-service</artifactId>

alfa-service/src/main/java/de/ozgcloud/alfa/historie/AktenzeichenChangeHistoryBuilder.java

+package de.ozgcloud.alfa.historie;
+
+import java.util.Optional;
+
+import org.apache.commons.lang3.StringUtils;
+
+import de.ozgcloud.alfa.common.command.Command;
+import de.ozgcloud.alfa.common.command.CommandOrder;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+class AktenzeichenChangeHistoryBuilder extends ChangeHistoryBuilder<AktenzeichenChangeHistoryBuilder> {
+
+	static final String BODY_PROPERTY_AKTENZEICHEN = "aktenzeichen";
+
+	public static AktenzeichenChangeHistoryBuilder builder() {
+		return new AktenzeichenChangeHistoryBuilder();
+	}
+
+	@Override
+	boolean isRelevant(Command command) {
+		return command.getOrder().equals(CommandOrder.SET_AKTENZEICHEN);
+	}
+
+	@Override
+	CommandWithChangeValues toCommandWithChangeValues(CommandWithPrevious commandWithPrevious) {
+		return new CommandWithChangeValues(
+				commandWithPrevious.getCommand(),
+				getAktenzeichenBeforeChange(commandWithPrevious),
+				getAktenzeichenAfterChange(commandWithPrevious)
+		);
+	}
+
+	String getAktenzeichenBeforeChange(CommandWithPrevious commandWithPrevious) {
+		return Optional.ofNullable(commandWithPrevious.getPrevious())
+				.map(this::getAktenzeichen)
+				.orElse(StringUtils.EMPTY);
+	}
+
+	String getAktenzeichenAfterChange(CommandWithPrevious commandWithPrevious) {
+		return getAktenzeichen(commandWithPrevious.getCommand());
+	}
+
+	String getAktenzeichen(Command command) {
+		return getValueFromCommandBody(BODY_PROPERTY_AKTENZEICHEN, command);
+	}
+}

alfa-service/src/main/java/de/ozgcloud/alfa/historie/AssignedUserChangeHistoryBuilder.java

+package de.ozgcloud.alfa.historie;
+
+import java.util.Optional;
+
+import org.apache.commons.lang3.StringUtils;
+
+import de.ozgcloud.alfa.common.command.Command;
+import de.ozgcloud.alfa.common.command.CommandOrder;
+import de.ozgcloud.alfa.common.user.UserId;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+class AssignedUserChangeHistoryBuilder extends ChangeHistoryBuilder<AssignedUserChangeHistoryBuilder> {
+
+	static final String BODY_PROPERTY_ASSIGNED_USER = "assignedTo";
+
+	private UserProfileCache userProfileCache;
+
+	public static AssignedUserChangeHistoryBuilder builder() {
+		return new AssignedUserChangeHistoryBuilder();
+	}
+
+	public AssignedUserChangeHistoryBuilder withUserProfileCache(UserProfileCache userProfileCache) {
+		this.userProfileCache = userProfileCache;
+		return this;
+	}
+
+	@Override
+	boolean isRelevant(Command command) {
+		return command.getOrder().equals(CommandOrder.ASSIGN_USER);
+	}
+
+	@Override
+	CommandWithChangeValues toCommandWithChangeValues(CommandWithPrevious commandWithPrevious) {
+		return new CommandWithChangeValues(
+				commandWithPrevious.getCommand(),
+				getAssignedUserBeforeChange(commandWithPrevious),
+				getAssignedUserAfterChange(commandWithPrevious));
+	}
+
+	String getAssignedUserBeforeChange(CommandWithPrevious commandWithPrevious) {
+		return Optional.ofNullable(commandWithPrevious.getPrevious())
+				.map(this::getAssignedUserFullNameFromCommand)
+				.orElse(StringUtils.EMPTY);
+	}
+
+	String getAssignedUserAfterChange(CommandWithPrevious commandWithPrevious) {
+		return getAssignedUserFullNameFromCommand(commandWithPrevious.getCommand());
+	}
+
+	String getAssignedUserFullNameFromCommand(Command command) {
+		var assignedUserId = UserId.from(getValueFromCommandBody(BODY_PROPERTY_ASSIGNED_USER, command));
+		return userProfileCache.getUserProfile(assignedUserId).getFullName();
+	}
+}

alfa-service/src/main/java/de/ozgcloud/alfa/historie/ChangeHistoryBuilder.java

+package de.ozgcloud.alfa.historie;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import org.apache.commons.lang3.StringUtils;
+
+import de.ozgcloud.alfa.common.command.Command;
+import de.ozgcloud.alfa.historie.CommandWithPrevious.CommandWithPreviousBuilder;
+
+abstract class ChangeHistoryBuilder<T extends ChangeHistoryBuilder<T>> {
+
+	List<Command> commands;
+	String organisationseinheitenID;
+
+	@SuppressWarnings("unchecked")
+	public T withCommands(List<Command> commands) {
+		this.commands = commands;
+		return (T) this;
+	}
+
+	@SuppressWarnings("unchecked")
+	public T withOrganisationseinheitenID(String organisationseinheitenID) {
+		this.organisationseinheitenID = organisationseinheitenID;
+		return (T) this;
+	}
+
+	public Stream<VorgangChange> build() {
+		return Stream.of(retrieveRelevantCommands())
+				.map(this::inChronologicalOrder)
+				.map(this::addPreviousCommand)
+				.map(this::toCommandsWithChangeValues)
+				.flatMap(this::toVorgangChanges);
+	}
+
+	Stream<Command> retrieveRelevantCommands() {
+		return commands.stream().filter(this::isRelevant);
+	}
+
+	abstract boolean isRelevant(Command command);
+
+	Stream<Command> inChronologicalOrder(Stream<Command> commands) {
+		return commands.sorted(Comparator.comparing(Command::getFinishedAt));
+	}
+
+	Stream<CommandWithPrevious> addPreviousCommand(Stream<Command> commands) {
+		var commandsList = commands.toList();
+		var result = new ArrayList<CommandWithPrevious>(commandsList.size());
+		for (int i = 0; i < commandsList.size(); i++) {
+			CommandWithPreviousBuilder builder = new CommandWithPreviousBuilder().command(commandsList.get(i));
+			if (i > 0) {
+				builder.previous(commandsList.get(i - 1));
+			}
+			result.add(builder.build());
+		}
+		return result.stream();
+	}
+
+	Stream<CommandWithChangeValues> toCommandsWithChangeValues(Stream<CommandWithPrevious> commands) {
+		return commands.map(this::toCommandWithChangeValues);
+	}
+
+	abstract CommandWithChangeValues toCommandWithChangeValues(CommandWithPrevious commandWithPrevious);
+
+	Stream<VorgangChange> toVorgangChanges(Stream<CommandWithChangeValues> commandsWithChangeValues) {
+		return commandsWithChangeValues.map(this::toVorgangChange);
+	}
+
+	VorgangChange toVorgangChange(CommandWithChangeValues commandChangeValues) {
+		return VorgangChange.builder()
+				.valueBeforeChange(commandChangeValues.valueBeforeChange())
+				.valueAfterChange(commandChangeValues.valueAfterChange())
+				.authorFullName(commandChangeValues.command().getCreatedByName())
+				.finishedAt(commandChangeValues.command().getFinishedAt())
+				.order(commandChangeValues.command().getOrder())
+				.organisationseinheitenID(organisationseinheitenID)
+				.build();
+	}
+
+	String getValueFromCommandBody(String propertyName, Command command) {
+		return Optional.ofNullable(command.getBody()).map(body -> body.get(propertyName)).map(Object::toString).orElse(StringUtils.EMPTY);
+	}
+
+	record CommandWithChangeValues(Command command, String valueBeforeChange, String valueAfterChange) {
+	}
+}

alfa-service/src/main/java/de/ozgcloud/alfa/historie/CommandWithPrevious.java

+package de.ozgcloud.alfa.historie;
+
+import de.ozgcloud.alfa.common.command.Command;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Builder(toBuilder = true)
+@Getter
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+class CommandWithPrevious {
+
+	private Command command;
+	private Command previous;
+}

alfa-service/src/main/java/de/ozgcloud/alfa/historie/HistorieService.java

@@ -41,7 +41,6 @@ class HistorieService {
 
 	@Autowired
 	private CommandService commandService;
-
 	@Autowired
 	private HistorieCommandHandler historieCommandHandler;
 

alfa-service/src/main/java/de/ozgcloud/alfa/historie/StatusChangeHistoryBuilder.java

+package de.ozgcloud.alfa.historie;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+import de.ozgcloud.alfa.common.command.Command;
+import de.ozgcloud.alfa.common.command.CommandOrder;
+import de.ozgcloud.alfa.vorgang.Vorgang.VorgangStatus;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class StatusChangeHistoryBuilder extends ChangeHistoryBuilder<StatusChangeHistoryBuilder> {
+
+	static final String GELOESCHT_NAME = "Gelöscht";
+	static final Map<VorgangStatus, String> VORGANG_STATUS_TO_NAME = Map.of(
+			VorgangStatus.NEU, "Neu",
+			VorgangStatus.ANGENOMMEN, "Angenommen",
+			VorgangStatus.VERWORFEN, "Verworfen",
+			VorgangStatus.IN_BEARBEITUNG, "In Bearbeitung",
+			VorgangStatus.BESCHIEDEN, "Beschieden",
+			VorgangStatus.ABGESCHLOSSEN, "Abgeschlossen",
+			VorgangStatus.WEITERGELEITET, "Weitergeleitet",
+			VorgangStatus.ZU_LOESCHEN, "Zu Löschen"
+	);
+	static final Set<CommandOrder> STATUS_CHANGE_COMMAND_ORDER = Set.of(
+			CommandOrder.VORGANG_ANNEHMEN,
+			CommandOrder.VORGANG_VERWERFEN,
+			CommandOrder.VORGANG_ZURUECKHOLEN,
+			CommandOrder.VORGANG_BEARBEITEN,
+			CommandOrder.VORGANG_BESCHEIDEN,
+			CommandOrder.VORGANG_ABSCHLIESSEN,
+			CommandOrder.VORGANG_ZUM_LOESCHEN_MARKIEREN,
+			CommandOrder.VORGANG_WIEDEREROEFFNEN,
+			CommandOrder.VORGANG_LOESCHEN,
+			CommandOrder.VORGANG_ZURUECKSTELLEN);
+
+	public static StatusChangeHistoryBuilder builder() {
+		return new StatusChangeHistoryBuilder();
+	}
+
+	@Override
+	boolean isRelevant(Command command) {
+		return STATUS_CHANGE_COMMAND_ORDER.contains(command.getOrder());
+	}
+
+	@Override
+	CommandWithChangeValues toCommandWithChangeValues(CommandWithPrevious commandWithPrevious) {
+		return new CommandWithChangeValues(commandWithPrevious.getCommand(),
+				getStatusBeforeChange(commandWithPrevious),
+				getStatusAfterChange(commandWithPrevious));
+	}
+
+	String getStatusBeforeChange(CommandWithPrevious commandWithPrevious) {
+		return Optional.ofNullable(commandWithPrevious.getPrevious())
+				.map(this::getStatus)
+				.orElse(VORGANG_STATUS_TO_NAME.get(VorgangStatus.NEU));
+	}
+
+	String getStatusAfterChange(CommandWithPrevious commandWithPrevious) {
+		return getStatus(commandWithPrevious.getCommand());
+	}
+
+	String getStatus(Command command) {
+		return switch (command.getOrder()) {
+			case VORGANG_ANNEHMEN, VORGANG_ZURUECKSTELLEN -> VORGANG_STATUS_TO_NAME.get(VorgangStatus.ANGENOMMEN);
+			case VORGANG_VERWERFEN -> VORGANG_STATUS_TO_NAME.get(VorgangStatus.VERWORFEN);
+			case VORGANG_ZURUECKHOLEN -> VORGANG_STATUS_TO_NAME.get(VorgangStatus.NEU);
+			case VORGANG_BEARBEITEN, VORGANG_WIEDEREROEFFNEN -> VORGANG_STATUS_TO_NAME.get(VorgangStatus.IN_BEARBEITUNG);
+			case VORGANG_BESCHEIDEN -> VORGANG_STATUS_TO_NAME.get(VorgangStatus.BESCHIEDEN);
+			case VORGANG_ABSCHLIESSEN -> VORGANG_STATUS_TO_NAME.get(VorgangStatus.ABGESCHLOSSEN);
+			case VORGANG_ZUM_LOESCHEN_MARKIEREN -> VORGANG_STATUS_TO_NAME.get(VorgangStatus.ZU_LOESCHEN);
+			case VORGANG_LOESCHEN -> GELOESCHT_NAME;
+			default -> throw new IllegalArgumentException("Unexpected or unknown command order " + command.getOrder());
+		};
+	}
+}

alfa-service/src/main/java/de/ozgcloud/alfa/historie/UserProfileCache.java

+package de.ozgcloud.alfa.historie;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+
+import de.ozgcloud.alfa.common.user.UserId;
+import de.ozgcloud.alfa.common.user.UserProfile;
+import de.ozgcloud.common.errorhandling.TechnicalException;
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+class UserProfileCache {
+
+	private final Function<UserId, UserProfile> findUserProfileForUserId;
+
+	private final Map<UserId, UserProfile> cache = new HashMap<>();
+
+	public static UserProfileCache create(Function<UserId, UserProfile> findUserProfileForUserId) {
+		return new UserProfileCache(findUserProfileForUserId);
+	}
+
+	public UserProfile getUserProfile(UserId userId) {
+		if (!cache.containsKey(userId)) {
+			findAndAddToCache(userId);
+		}
+		return cache.get(userId);
+	}
+
+	private void findAndAddToCache(UserId userId) {
+		var userProfile = findUserProfileForUserId.apply(userId);
+		if (userProfile == null) {
+			throw new TechnicalException("UserProfile not found for user with ID " + userId);
+		}
+		cache.put(userId, userProfile);
+	}
+}

alfa-service/src/main/java/de/ozgcloud/alfa/historie/VorgangChange.java

+package de.ozgcloud.alfa.historie;
+
+import java.time.ZonedDateTime;
+
+import de.ozgcloud.alfa.common.command.CommandOrder;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Builder(toBuilder = true)
+@Getter
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class VorgangChange {
+
+	private String valueBeforeChange;
+	private String valueAfterChange;
+	private String authorFullName;
+	private ZonedDateTime finishedAt;
+	private CommandOrder order;
+	private String organisationseinheitenID;
+}

alfa-service/src/main/java/de/ozgcloud/alfa/historie/VorgangChangeHistory.java

+package de.ozgcloud.alfa.historie;
+
+import java.util.List;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Builder(toBuilder = true)
+@Getter
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class VorgangChangeHistory {
+
+	private List<VorgangChange> statusChangeHistory;
+	private List<VorgangChange> aktenzeichenChangeHistory;
+	private List<VorgangChange> assignedUserChangeHistory;
+}

alfa-service/src/main/java/de/ozgcloud/alfa/historie/VorgangChangeHistoryService.java

+package de.ozgcloud.alfa.historie;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import org.springframework.stereotype.Service;
+
+import de.ozgcloud.alfa.common.command.Command;
+import de.ozgcloud.alfa.common.command.CommandService;
+import de.ozgcloud.alfa.common.user.UserService;
+import de.ozgcloud.alfa.vorgang.Eingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.ZustaendigeStelle;
+import lombok.RequiredArgsConstructor;
+
+@Service
+@RequiredArgsConstructor
+public class VorgangChangeHistoryService {
+
+	private final HistorieService historieService;
+	private final UserService userService;
+	private final CommandService commandService;
+
+	public VorgangChangeHistory createVorgangChangeHistory(VorgangWithEingang vorgang) {
+		var commands = commandService.findFinishedCommands(vorgang.getId()).toList();
+		return VorgangChangeHistory.builder()
+				.statusChangeHistory(createStatusChangeHistory(vorgang, commands).toList())
+				.aktenzeichenChangeHistory(createAktenzeichenChangeHistory(vorgang, commands).toList())
+				.assignedUserChangeHistory(createAssignedUserChangeHistory(vorgang, commands).toList())
+				.build();
+	}
+
+	Stream<VorgangChange> createStatusChangeHistory(VorgangWithEingang vorgang, List<Command> commands) {
+		return StatusChangeHistoryBuilder.builder()
+				.withCommands(commands)
+				.withOrganisationseinheitenID(getOrganisationseinheitenID(vorgang))
+				.build();
+	}
+
+	Stream<VorgangChange> createAktenzeichenChangeHistory(VorgangWithEingang vorgang, List<Command> commands) {
+		return AktenzeichenChangeHistoryBuilder.builder()
+				.withCommands(commands)
+				.withOrganisationseinheitenID(getOrganisationseinheitenID(vorgang))
+				.build();
+	}
+
+	Stream<VorgangChange> createAssignedUserChangeHistory(VorgangWithEingang vorgang, List<Command> commands) {
+		return AssignedUserChangeHistoryBuilder.builder()
+				.withCommands(commands)
+				.withOrganisationseinheitenID(getOrganisationseinheitenID(vorgang))
+				.withUserProfileCache(UserProfileCache.create(userService::getById))
+				.build();
+	}
+
+	String getOrganisationseinheitenID(VorgangWithEingang vorgang) {
+		return Optional.ofNullable(vorgang.getEingang()).map(Eingang::getZustaendigeStelle).map(ZustaendigeStelle::getOrganisationseinheitenId)
+				.orElse(null);
+	}
+}

alfa-service/src/main/java/de/ozgcloud/alfa/statistic/CountVorgangResponse.java

-// TODO sebo: diese Datei soll später komplett gelöscht werden
-package de.ozgcloud.alfa.statistic;
-
-import java.util.Map;
-
-import lombok.Builder;
-import lombok.Getter;
-
-@Getter
-@Builder
-class CountVorgangResponse {
-
-	private ByStatus byStatus;
-	private Map<String, Integer> pathCountResult;
-}

alfa-service/src/main/java/de/ozgcloud/alfa/statistic/StatisticController.java

@@ -10,20 +10,6 @@ public class StatisticController {
 	private StatisticService statisticService;
 
 	public Statistic getVorgaengeStatistic() {
-		var countStatistic = statisticService.countVorgang();
-		var statistic = statisticService.getVorgaengeStatistic();
-		return Statistic.builder()
-				.existsWiedervorlageOverdue(statistic.isExistsWiedervorlageOverdue())
-				.wiedervorlagen(countStatistic.getWiedervorlagen())
-				.byStatus(ByStatus.builder()
-						.verworfen(countStatistic.getByStatus().getVerworfen())
-						.inBearbeitung(countStatistic.getByStatus().getInBearbeitung())
-						.angenommen(countStatistic.getByStatus().getAngenommen())
-						.beschieden(countStatistic.getByStatus().getBeschieden())
-						.neu(countStatistic.getByStatus().getNeu())
-						.abgeschlossen(countStatistic.getByStatus().getAbgeschlossen())
-						.zuLoeschen(statistic.getByStatus().getZuLoeschen())
-						.build())
-				.build();
+		return statisticService.getVorgaengeStatistic();
 	}
 }

alfa-service/src/main/java/de/ozgcloud/alfa/statistic/StatisticMapper.java

 package de.ozgcloud.alfa.statistic;
 
-import java.util.Map;
-import java.util.stream.Collectors;
-
 import org.mapstruct.CollectionMappingStrategy;
 import org.mapstruct.Mapper;
 import org.mapstruct.Mapping;
 import org.mapstruct.NullValueCheckStrategy;
 import org.mapstruct.ReportingPolicy;
 
-import de.ozgcloud.vorgang.statistic.GrpcByStatusResult;
-import de.ozgcloud.vorgang.statistic.GrpcPathCountResult;
-import de.ozgcloud.vorgang.statistic.GrpcVorgangCountResponse;
 import de.ozgcloud.vorgang.statistic.GrpcVorgangStatisticResult;
 
 @Mapper(unmappedTargetPolicy = ReportingPolicy.WARN,
@@ -23,16 +17,4 @@ interface StatisticMapper {
 	@Mapping(target = "boolValue", source = "resultBoolValue")
 	@Mapping(target = "intValue", source = "resultIntValue")
 	StatisticResult toResult(GrpcVorgangStatisticResult grpcVorgangStatisticResult);
-
-	// TODO sebo: der Code muss später gelöscht werden
-	@Mapping(target = "pathCountResult", expression = "java(toMap(response))")
-	CountVorgangResponse fromCountVorgangResponse(GrpcVorgangCountResponse response);
-
-	ByStatus fromByStatus(GrpcByStatusResult byStatus);
-
-	default Map<String, Integer> toMap(GrpcVorgangCountResponse response) {
-		return response.getPathCountResultList().stream()
-				.collect(Collectors.toMap(GrpcPathCountResult::getName, pathCountResult -> Integer.valueOf(pathCountResult.getValue())));
-	}
-	// END: code löschen
 }
\ No newline at end of file

alfa-service/src/main/java/de/ozgcloud/alfa/statistic/StatisticRemoteService.java

@@ -11,7 +11,6 @@ import org.springframework.stereotype.Service;
 import de.ozgcloud.alfa.AlfaProperties;
 import de.ozgcloud.alfa.common.GrpcUtil;
 import de.ozgcloud.alfa.vorgang.Vorgang.VorgangStatus;
-import de.ozgcloud.vorgang.statistic.GrpcVorgangCountRequest;
 import de.ozgcloud.vorgang.statistic.GrpcVorgangStatisticQuery;
 import de.ozgcloud.vorgang.statistic.GrpcVorgangStatisticQuery.GroupMethod;
 import de.ozgcloud.vorgang.statistic.GrpcVorgangStatisticQuery.Operator;
@@ -41,8 +40,9 @@ class StatisticRemoteService {
 
 	public Map<String, StatisticResult> getVorgaengeStatistics(List<VorgangStatus> countByVorgangStatus) {
 		var grpcRequest = GrpcVorgangStatisticRequest.newBuilder()
-				.addQuery(buildExistsWiedervorlageOverdueQuery())
 				.addAllQuery(buildCountByStatusQueries(countByVorgangStatus))
+				.addQuery(buildCountWiedervorlageNextFristQuery())
+				.addQuery(buildExistsWiedervorlageOverdueQuery())
 				.build();
 
 		var grpcResponse = statisticServiceStub.getVorgangStatistic(grpcRequest);
@@ -64,6 +64,15 @@ class StatisticRemoteService {
 				.build();
 	}
 
+	GrpcVorgangStatisticQuery buildCountWiedervorlageNextFristQuery() {
+		return GrpcVorgangStatisticQuery.newBuilder()
+				.setResultName(COUNT_WIEDERVORLAGE_NEXT_FRIST_RESULT_NAME)
+				.setPath(String.format(WIEDERVORLAGE_NEXT_FRIST_PATH_TEMPLATE, alfaProperties.getApplicationName()))
+				.setGroupMethod(GroupMethod.COUNT)
+				.setOperator(Operator.UNEQUAL)
+				.build();
+	}
+
 	GrpcVorgangStatisticQuery buildExistsWiedervorlageOverdueQuery() {
 		return GrpcVorgangStatisticQuery.newBuilder()
 				.setResultName(EXISTS_WIEDERVORLAGE_OVERDUE_RESULT_NAME)
@@ -84,16 +93,4 @@ class StatisticRemoteService {
 				.map(mapper::toResult)
 				.collect(Collectors.toMap(StatisticResult::getName, Function.identity()));
 	}
-
-	// TODO sebo: der Code muss später gelöscht werden
-	public CountVorgangResponse countVorgang(List<String> countByPath) {
-		var response = statisticServiceStub.countVorgang(buildVorgangCountRequest(countByPath));
-
-		return mapper.fromCountVorgangResponse(response);
-	}
-
-	GrpcVorgangCountRequest buildVorgangCountRequest(List<String> countByPath) {
-		return GrpcVorgangCountRequest.newBuilder().addAllCountByPath(countByPath).build();
-	}
-	// END: code löschen
 }
\ No newline at end of file

alfa-service/src/main/java/de/ozgcloud/alfa/statistic/StatisticService.java

@@ -8,7 +8,6 @@ import java.util.Optional;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import de.ozgcloud.alfa.AlfaProperties;
 import de.ozgcloud.alfa.common.user.CurrentUserService;
 import de.ozgcloud.alfa.common.user.UserRole;
 import de.ozgcloud.alfa.vorgang.Vorgang.VorgangStatus;
@@ -16,15 +15,10 @@ import de.ozgcloud.alfa.vorgang.Vorgang.VorgangStatus;
 @Service
 class StatisticService {
 
-	// TODO sebo: dieser Code wird später gelöscht
-	static final String COUNT_WIEDERVORLAGE_NEXT_FRIST_KEY = "countWiedervorlage";
-	static final String COUNT_WIEDERVORLAGE_NEXT_FRIST_TEMPLATE = COUNT_WIEDERVORLAGE_NEXT_FRIST_KEY + ":ClientAttribute.%s.nextWiedervorlageFrist";
-	// END: code löschen
-
-	static final List<VorgangStatus> VORGAENGE_STATUS_COUNT_VERWALTUNG_USER = List.of(VorgangStatus.NEU, VorgangStatus.ANGENOMMEN,
+	static final List<VorgangStatus> COUNT_BY_VORGANG_STATUS_VERWALTUNG_USER = List.of(VorgangStatus.NEU, VorgangStatus.ANGENOMMEN,
 			VorgangStatus.IN_BEARBEITUNG, VorgangStatus.BESCHIEDEN, VorgangStatus.ABGESCHLOSSEN, VorgangStatus.VERWORFEN, VorgangStatus.ZU_LOESCHEN);
-	static final List<VorgangStatus> VORGAENGE_STATUS_COUNT_POSTSTELLE_USER = Collections.emptyList();
-	static final List<VorgangStatus> VORGAENGE_STATUS_COUNT_EINHEITLICHER_ANSPRECHPARTNER = Collections.emptyList();
+	static final List<VorgangStatus> COUNT_BY_VORGANG_STATUS_POSTSTELLE_USER = Collections.emptyList();
+	static final List<VorgangStatus> COUNT_BY_VORGANG_EINHEITLICHER_ANSPRECHPARTNER = Collections.emptyList();
 
 	@Autowired
 	private StatisticRemoteService remoteService;
@@ -32,23 +26,20 @@ class StatisticService {
 	@Autowired
 	private CurrentUserService currentUserService;
 
-	@Autowired
-	private AlfaProperties alfaProperties;
-
 	public Statistic getVorgaengeStatistic() {
-		var response = remoteService.getVorgaengeStatistics(List.of(VorgangStatus.ZU_LOESCHEN));
+		var response = remoteService.getVorgaengeStatistics(getCountByVorgangStatusList());
 		return buildGetVorgaengeStatisticResult(response);
 	}
 
 	List<VorgangStatus> getCountByVorgangStatusList() {
 		if (currentUserService.hasRole(UserRole.VERWALTUNG_USER)) {
-			return VORGAENGE_STATUS_COUNT_VERWALTUNG_USER;
+			return COUNT_BY_VORGANG_STATUS_VERWALTUNG_USER;
 		}
 		if (currentUserService.hasRole(UserRole.VERWALTUNG_POSTSTELLE)) {
-			return VORGAENGE_STATUS_COUNT_POSTSTELLE_USER;
+			return COUNT_BY_VORGANG_STATUS_POSTSTELLE_USER;
 		}
 		if (currentUserService.hasRole(UserRole.EINHEITLICHER_ANSPRECHPARTNER)) {
-			return VORGAENGE_STATUS_COUNT_EINHEITLICHER_ANSPRECHPARTNER;
+			return COUNT_BY_VORGANG_EINHEITLICHER_ANSPRECHPARTNER;
 		}
 		return Collections.emptyList();
 	}
@@ -76,26 +67,4 @@ class StatisticService {
 	private boolean getBooleanResult(Map<String, StatisticResult> response, String resultName) {
 		return Optional.ofNullable(response.get(resultName)).map(StatisticResult::getBoolValue).orElse(false);
 	}
-
-	// TODO sebo: dieser Code wird später gelöscht
-	public Statistic countVorgang() {
-		var response = remoteService.countVorgang(createCountByPathList());
-
-		return buildStatistic(response);
-	}
-
-	List<String> createCountByPathList() {
-		return List.of(String.format(COUNT_WIEDERVORLAGE_NEXT_FRIST_TEMPLATE, alfaProperties.getApplicationName()));
-	}
-
-	Statistic buildStatistic(CountVorgangResponse response) {
-		return Statistic.builder().byStatus(response.getByStatus()).wiedervorlagen(extractWiedervorlageCount(response)).build();
-	}
-
-	Integer extractWiedervorlageCount(CountVorgangResponse response) {
-		return Optional.ofNullable(response.getPathCountResult())
-				.map(pathResultEntry -> pathResultEntry.get(COUNT_WIEDERVORLAGE_NEXT_FRIST_KEY))
-				.orElse(0);
-	}
-	// END: code löschen
 }
\ No newline at end of file

alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/TestUtils.java → alfa-service/src/test/java/de/ozgcloud/alfa/common/TestUtils.java

@@ -19,4 +19,5 @@ public class TestUtils {
 		when(mockStream.toList()).thenReturn(list);
 		mock.accept(mockStream);
 	}
+
 }

alfa-service/src/test/java/de/ozgcloud/alfa/common/command/CommandTestFactory.java

@@ -52,7 +52,8 @@ public class CommandTestFactory {
 				.relationId(RELATION_ID)
 				.status(STATUS)
 				.order(ORDER)
-				.createdBy(UserProfileTestFactory.ID);
+				.createdBy(UserProfileTestFactory.ID)
+				.createdByName(UserProfileTestFactory.FULLNAME);
 	}
 
 	public static CreateCommand createCreateCommand() {