OZG-5044 SettingService

pom.xml

@@ -24,6 +24,7 @@
 		<testcontainers-keycloak.version>3.2.0</testcontainers-keycloak.version>
 		<keycloak-admin-client.version>23.0.6</keycloak-admin-client.version>
 		<mongock.version>5.4.0</mongock.version>
+        <lombok-mapstruct-binding.version>0.2.0</lombok-mapstruct-binding.version>
 	</properties>
 
 	<dependencies>
@@ -70,6 +71,11 @@
 		    <artifactId>spring-boot-configuration-processor</artifactId>
 		    <optional>true</optional>
 		</dependency>
+		<!-- tools -->
+		<dependency>
+			<groupId>org.mapstruct</groupId>
+			<artifactId>mapstruct</artifactId>
+		</dependency>
 		<!-- mongock -->
 		<dependency>
 			<groupId>io.mongock</groupId>
@@ -222,6 +228,38 @@
 					</execution>
 				</executions>
 			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+                    <configuration>
+                        <source>1.8</source>
+                        <target>1.8</target>
+                        <!-- See https://maven.apache.org/plugins/maven-compiler-plugin/compile-mojo.html -->
+                        <!-- Classpath elements to supply as annotation processor path. If specified, the compiler   -->
+                        <!-- will detect annotation processors only in those classpath elements. If omitted, the     -->
+                        <!-- default classpath is used to detect annotation processors. The detection itself depends -->
+                        <!-- on the configuration of annotationProcessors.                                           -->
+                        <!--                                                                                         -->
+                        <!-- According to this documentation, the provided dependency processor is not considered!   -->
+                        <annotationProcessorPaths>
+                            <path>
+                                <groupId>org.mapstruct</groupId>
+                                <artifactId>mapstruct-processor</artifactId>
+                                <version>${org.mapstruct.version}</version>
+                            </path>
+                            <path>
+                                <groupId>org.projectlombok</groupId>
+                                <artifactId>lombok</artifactId>
+                                <version>${org.projectlombok.version}</version>
+                            </path>
+                            <path>
+                                <groupId>org.projectlombok</groupId>
+                                <artifactId>lombok-mapstruct-binding</artifactId>
+                                <version>${lombok-mapstruct-binding.version}</version>
+                            </path>
+                        </annotationProcessorPaths>
+                    </configuration>
+			</plugin>
 		</plugins>
 	</build>
 

src/main/java/de/ozgcloud/admin/settings/AlfaKonfiguration.java

 package de.ozgcloud.admin.settings;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
 
 import lombok.Builder;
 
 @Builder
 class AlfaKonfiguration implements AnwendungsKonfiguration {
+	@JsonIgnore
+	protected static final String[] KONFIGURATIONS_TYPES = new String[] { "Postfach" };
+
 	@JsonProperty("ozgcloud.postfach.signatur")
 	@Builder.Default
 	String signatur = "";

src/main/java/de/ozgcloud/admin/settings/SettingMapper.java

+package de.ozgcloud.admin.settings;
+
+import org.mapstruct.Mapper;
+import org.mapstruct.MappingTarget;
+
+import de.ozgcloud.admin.settings.AlfaKonfiguration.AlfaKonfigurationBuilder;
+import de.ozgcloud.admin.settings.AnwendungsKonfiguration.AnwendungsKonfigurationBuilder;
+import de.ozgcloud.admin.settings.VorgangManagerKonfiguration.VorgangManagerKonfigurationBuilder;
+import de.ozgcloud.admin.settings.postfach.Absender;
+import de.ozgcloud.admin.settings.postfach.AbsenderVorgangManager;
+import de.ozgcloud.admin.settings.postfach.PostfachSettingBody;
+
+@Mapper
+public interface SettingMapper {
+
+	public default AnwendungsKonfigurationBuilder mapToAnwendungKonfiguration(@MappingTarget AnwendungsKonfigurationBuilder builder,
+			SettingBody body) {
+		if (body == null) {
+			return builder;
+		}
+		if (body instanceof PostfachSettingBody) {
+			if (builder instanceof AlfaKonfigurationBuilder) {
+				return addPostfachToAlfaKonfiguration((AlfaKonfigurationBuilder) builder, (PostfachSettingBody) body);
+			} else if (builder instanceof VorgangManagerKonfigurationBuilder) {
+				return addPostfachToVorgangManagerKonfiguration((VorgangManagerKonfigurationBuilder) builder, (PostfachSettingBody) body);
+			}
+		}
+		return builder;
+	}
+
+	AlfaKonfigurationBuilder addPostfachToAlfaKonfiguration(@MappingTarget AlfaKonfigurationBuilder builder, PostfachSettingBody body);
+
+	VorgangManagerKonfigurationBuilder addPostfachToVorgangManagerKonfiguration(@MappingTarget VorgangManagerKonfigurationBuilder builder,
+			PostfachSettingBody body);
+
+	AbsenderVorgangManager mapAbsenderToAbsenderVorgangManager(Absender absender);
+}

src/main/java/de/ozgcloud/admin/settings/SettingRepository.java

@@ -21,10 +21,14 @@
  */
 package de.ozgcloud.admin.settings;
 
+import java.util.List;
+
 import org.springframework.data.mongodb.repository.MongoRepository;
+import org.springframework.data.mongodb.repository.Query;
 import org.springframework.data.rest.core.annotation.RepositoryRestResource;
 
 @RepositoryRestResource(collectionResourceRel = SettingConstant.REL, path = SettingConstant.PATH)
 interface SettingRepository extends MongoRepository<Setting, String> {
-
+	@Query("{'name' : {$in : ?0}}")
+	List<Setting> findByNames(String[] names);
 }

src/main/java/de/ozgcloud/admin/settings/SettingService.java

 package de.ozgcloud.admin.settings;
 
+import java.util.List;
+
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
+import de.ozgcloud.admin.settings.AnwendungsKonfiguration.AnwendungsKonfigurationBuilder;
+
 @Service
 public class SettingService {
+	@Autowired
+	private SettingRepository repository;
+	@Autowired
+	private SettingMapper mapper;
+
 	public AlfaKonfiguration getAlfaKonfiguration() {
-		return null;
+		var settings = getSettingListFromDb(AlfaKonfiguration.KONFIGURATIONS_TYPES);
+		var alfaKonfigurationBuilder = AlfaKonfiguration.builder();
+		buildKonfiguration(alfaKonfigurationBuilder, settings);
+		return alfaKonfigurationBuilder.build();
 	}
 
 	public VorgangManagerKonfiguration getVorgangManagerKonfiguration() {
-		return null;
+		var settings = getSettingListFromDb(VorgangManagerKonfiguration.KONFIGURATIONS_TYPES);
+		var vorgangManagerKonfigurationBuilder = VorgangManagerKonfiguration.builder();
+		buildKonfiguration(vorgangManagerKonfigurationBuilder, settings);
+		return vorgangManagerKonfigurationBuilder.build();
+	}
+
+	private List<Setting> getSettingListFromDb(String[] settingTypes) {
+		return repository.findByNames(settingTypes);
+	}
+
+	private void buildKonfiguration(AnwendungsKonfigurationBuilder builder, List<Setting> settings) {
+		settings.forEach(setting -> mapper.mapToAnwendungKonfiguration(builder, setting.getSettingBody()));
 	}
 }

src/main/java/de/ozgcloud/admin/settings/VorgangManagerKonfiguration.java

 package de.ozgcloud.admin.settings;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonUnwrapped;
 
 import de.ozgcloud.admin.settings.postfach.AbsenderVorgangManager;
@@ -9,6 +10,9 @@ import lombok.Getter;
 @Builder
 @Getter
 class VorgangManagerKonfiguration implements AnwendungsKonfiguration {
+	@JsonIgnore
+	protected static final String[] KONFIGURATIONS_TYPES = new String[] { "Postfach" };
+
 	@JsonUnwrapped(prefix = "ozgcloud.postfach.absender.")
 	@Builder.Default
 	private AbsenderVorgangManager absender = AbsenderVorgangManager.builder().build();

src/main/java/de/ozgcloud/admin/settings/postfach/Absender.java

@@ -11,7 +11,7 @@ import lombok.extern.jackson.Jacksonized;
 @Getter
 @Builder
 @Jacksonized
-class Absender {
+public class Absender {
 	@NotEmpty(message = FIELD_IS_EMPTY)
 	private String name;
 	@NotEmpty(message = FIELD_IS_EMPTY)

src/test/java/de/ozgcloud/admin/settings/SettingEnvironmentRepositoryTest.java

@@ -5,15 +5,12 @@ import static org.mockito.Mockito.*;
 
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Spy;
-import org.mockito.junit.jupiter.MockitoExtension;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 
-@ExtendWith(MockitoExtension.class)
 public class SettingEnvironmentRepositoryTest {
     @InjectMocks
     @Spy

src/test/java/de/ozgcloud/admin/settings/SettingServiceTest.java

+package de.ozgcloud.admin.settings;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import de.ozgcloud.admin.settings.AlfaKonfiguration.AlfaKonfigurationBuilder;
+import de.ozgcloud.admin.settings.VorgangManagerKonfiguration.VorgangManagerKonfigurationBuilder;
+import de.ozgcloud.admin.settings.postfach.PostfachSettingBody;
+import de.ozgcloud.admin.settings.postfach.PostfachSettingBodyTestFactory;
+
+@ExtendWith(MockitoExtension.class)
+public class SettingServiceTest {
+	private final static String[] POSTFACH_ARRAY = new String[] { "Postfach" };
+
+	@InjectMocks
+	@Spy
+	private SettingService service;
+
+	@Mock
+	private SettingRepository repository;
+
+	@Mock
+	private SettingMapper mapper;
+
+	private final String POSTFACH = "Postfach";
+	private final PostfachSettingBody postfach = PostfachSettingBodyTestFactory.create();
+	private final Setting settingWithPostfach = SettingTestFactory.createBuilder().name(POSTFACH).settingBody(postfach).build();
+	@Captor
+	private ArgumentCaptor<SettingBody> bodyCaptor;
+
+	@Nested
+	class TestGetAlfaKonfiguration {
+		private final AlfaKonfigurationBuilder ALFA_KONFIGURATION_BUILDER = AlfaKonfiguration.builder();
+		@Captor
+		private ArgumentCaptor<AlfaKonfigurationBuilder> alfaBuilderCaptor;
+
+		private final AlfaKonfiguration alfaSetting = AlfaKonfigurationTestFactory.create();
+
+		@BeforeEach
+		void mockRepository() {
+			when(repository.findByNames(POSTFACH_ARRAY)).thenReturn(List.of(settingWithPostfach));
+		}
+
+		@Test
+		void shouldQueryRepositoryWithPostfachArray() {
+			service.getAlfaKonfiguration();
+
+			verify(repository).findByNames(POSTFACH_ARRAY);
+		}
+
+		@Test
+		void shouldCallMapToAlfaKonfigurationWithAlfaBuilder() {
+			service.getAlfaKonfiguration();
+
+			verify(mapper).mapToAnwendungKonfiguration(alfaBuilderCaptor.capture(), bodyCaptor.capture());
+
+			assertThat(alfaBuilderCaptor.getValue()).usingRecursiveComparison().isEqualTo(ALFA_KONFIGURATION_BUILDER);
+		}
+
+		@Test
+		void shouldCallMapToAlfaKonfigurationWithPostfachSettingBody() {
+			service.getAlfaKonfiguration();
+
+			verify(mapper).mapToAnwendungKonfiguration(alfaBuilderCaptor.capture(), bodyCaptor.capture());
+
+			assertThat(bodyCaptor.getValue()).usingRecursiveComparison().isEqualTo(postfach);
+		}
+
+		@Test
+		void shouldReturnBuiltAlfaKonfiguration() {
+			when(mapper.mapToAnwendungKonfiguration(any(), eq(postfach))).thenAnswer(input -> {
+				((AlfaKonfigurationBuilder) input.getArgument(0)).signatur(PostfachSettingBodyTestFactory.SIGNATUR);
+				return input.getArgument(0);
+			});
+
+			var resultAppSetting = service.getAlfaKonfiguration();
+
+			assertThat(resultAppSetting).usingRecursiveComparison().isEqualTo(alfaSetting);
+		}
+
+	}
+
+	@Nested
+	class TestGetVorgangManagerKonfiguration {
+		private final VorgangManagerKonfigurationBuilder VORGANG_MANAGER_KONFIGURATION_BUILDER = VorgangManagerKonfiguration.builder();
+		@Captor
+		private ArgumentCaptor<VorgangManagerKonfigurationBuilder> vorgangManagerBuilderCaptor;
+
+		private final VorgangManagerKonfiguration vorgangManagerSetting = VorgangManagerKonfigurationTestFactory.create();
+
+		@BeforeEach
+		void mockRepository() {
+			when(repository.findByNames(POSTFACH_ARRAY)).thenReturn(List.of(settingWithPostfach));
+		}
+
+		@Test
+		void shouldQueryRepositoryWithPostfachArray() {
+			service.getVorgangManagerKonfiguration();
+
+			verify(repository).findByNames(POSTFACH_ARRAY);
+		}
+
+		@Test
+		void shouldCallMapToVorgangManagerKonfigurationWithVorgangManagerBuilder() {
+			service.getVorgangManagerKonfiguration();
+
+			verify(mapper).mapToAnwendungKonfiguration(vorgangManagerBuilderCaptor.capture(), bodyCaptor.capture());
+
+			assertThat(vorgangManagerBuilderCaptor.getValue()).usingRecursiveComparison().isEqualTo(VORGANG_MANAGER_KONFIGURATION_BUILDER);
+		}
+
+		@Test
+		void shouldCallMapToVorgangManagerKonfigurationWithPostfachSettingBody() {
+			service.getVorgangManagerKonfiguration();
+
+			verify(mapper).mapToAnwendungKonfiguration(vorgangManagerBuilderCaptor.capture(), bodyCaptor.capture());
+
+			assertThat(bodyCaptor.getValue()).usingRecursiveComparison().isEqualTo(postfach);
+		}
+
+		@Test
+		void shouldReturnBuiltVorgangManagerKonfiguration() {
+			when(mapper.mapToAnwendungKonfiguration(any(), eq(postfach))).thenAnswer(input -> {
+				((VorgangManagerKonfigurationBuilder) input.getArgument(0)).absender(VorgangManagerKonfigurationTestFactory.ABSENDER_VM);
+				return input.getArgument(0);
+			});
+
+			var resultAppSetting = service.getVorgangManagerKonfiguration();
+
+			assertThat(resultAppSetting).usingRecursiveComparison().isEqualTo(vorgangManagerSetting);
+		}
+
+	}
+}

src/test/java/de/ozgcloud/admin/settings/VorgangManagerKonfigurationTestFactory.java

 package de.ozgcloud.admin.settings;
 
+import de.ozgcloud.admin.settings.postfach.AbsenderVorgangManager;
 import de.ozgcloud.admin.settings.postfach.AbsenderVorgangManagerTestFactory;
 
 public class VorgangManagerKonfigurationTestFactory {
+	public static AbsenderVorgangManager ABSENDER_VM = AbsenderVorgangManagerTestFactory.create();
+
 	public static VorgangManagerKonfiguration create() {
 		return createBuilder().build();
 	}
 
 	public static VorgangManagerKonfiguration.VorgangManagerKonfigurationBuilder createBuilder() {
-		return VorgangManagerKonfiguration.builder().absender(AbsenderVorgangManagerTestFactory.create());
+		return VorgangManagerKonfiguration.builder().absender(ABSENDER_VM);
 	}
 }