jakalx/flex
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: Initial import of FLEX training material

Browse source
This commit is contained in:
Alexander Kobjolke 2024-11-07 21:02:53 +01:00
parent c01246d4f7
commit 12235acc42
1020 changed files with 53940 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

14
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/SpotbugsExcludeFilter.xml Normal file
View file

@ -0,0 +1,14 @@
<?xml version="1.0" encoding="UTF-8"?>
<FindBugsFilter>
<Match>
<!-- spotbugs message is Possible null pointer dereference of Kino.kinoSaele in equals method.
But the if statements before that line guarantee not null. -->
<Class name="de.accso.flexinale.backoffice.domain.model.Kino" />
<Bug pattern="NP_NULL_ON_SOME_PATH_MIGHT_BE_INFEASIBLE" />
</Match>
<Match>
<Class name="de.accso.flexinale.infrastructure.FlexinaleSpringConfig" />
<Bug pattern="CT_CONSTRUCTOR_THROW"/>
</Match>
</FindBugsFilter>

8
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/infrastructure/docker/Dockerfile Normal file
View file

@ -0,0 +1,8 @@
FROM amazoncorretto:21.0.1-alpine3.18
WORKDIR /app
COPY ../../target/flexinale-distributed-backoffice-2024.3.0-spring-boot-fat-jar.jar /app
EXPOSE 8081
CMD ["java", "-jar", "flexinale-distributed-backoffice-2024.3.0-spring-boot-fat-jar.jar"]

1
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/infrastructure/docker/docker_build.sh Normal file
View file

@ -0,0 +1 @@
docker build -t de.accso/flexinale-distributed-backoffice:2024.3.0 -f Dockerfile ../../

8
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/infrastructure/podman/Dockerfile Normal file
View file

@ -0,0 +1,8 @@
FROM amazoncorretto:21.0.1-alpine3.18
WORKDIR /app
COPY ../../target/flexinale-distributed-backoffice-2024.3.0-spring-boot-fat-jar.jar /app
EXPOSE 8081
CMD ["java", "-jar", "flexinale-distributed-backoffice-2024.3.0-spring-boot-fat-jar.jar"]

1
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/infrastructure/podman/podman_build.bat Normal file
View file

@ -0,0 +1 @@
podman build -t de.accso/flexinale-distributed-backoffice:2024.3.0 -f Dockerfile ../../

167
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/pom.xml Normal file
View file

@ -0,0 +1,167 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>de.accso</groupId>
<artifactId>flexinale-distributed</artifactId>
<version>2024.3.0</version>
<relativePath>../pom.xml</relativePath> <!-- lookup parent from repository -->
</parent>
<artifactId>flexinale-distributed-backoffice</artifactId>
<version>2024.3.0</version>
<name>Flexinale Distributed Backoffice</name>
<description>Flexinale - FLEX case-study &quot;film festival&quot;, distributed services, backoffice</description>
<packaging>jar</packaging>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>io.micrometer</groupId>
<artifactId>micrometer-registry-prometheus</artifactId>
<version>${micrometer.version}</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>${commons-lang3.version}</version>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>${org-postgres.version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>${apache-poi.version}</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>${apache-poi.version}</version>
</dependency>
<dependency>
<groupId>de.accso</groupId>
<artifactId>flexinale-distributed-common</artifactId>
<version>2024.3.0</version>
</dependency>
<dependency>
<groupId>de.accso</groupId>
<artifactId>flexinale-distributed-common</artifactId>
<version>2024.3.0</version>
<type>test-jar</type>
<scope>test</scope>
</dependency>
<dependency>
<groupId>de.accso</groupId>
<artifactId>flexinale-distributed-security</artifactId>
<scope>runtime</scope>
<version>2024.3.0</version>
</dependency>
<dependency>
<groupId>de.accso</groupId>
<artifactId>flexinale-distributed-security_api_contract</artifactId>
<version>2024.3.0</version>
</dependency>
<dependency>
<groupId>de.accso</groupId>
<artifactId>flexinale-distributed-backoffice_api_contract</artifactId>
<version>2024.3.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<!-- name extension of spring boot fat jar-->
<configuration>
<classifier>spring-boot-fat-jar</classifier>
</configuration>
<executions>
<execution>
<goals>
<goal>build-info</goal>
</goals>
<configuration>
<additionalProperties>
<flexinale.implementation>Distributed</flexinale.implementation>
<flexinale.app>Backoffice</flexinale.app>
</additionalProperties>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>com.github.spotbugs</groupId>
<artifactId>spotbugs-maven-plugin</artifactId>
<version>${spotbugs-maven-plugin.version}</version>
<configuration>
<plugins>
<plugin>
<groupId>com.h3xstream.findsecbugs</groupId>
<artifactId>findsecbugs-plugin</artifactId>
<version>${findsecbugs-maven-plugin.version}</version>
</plugin>
</plugins>
<excludeFilterFile>SpotbugsExcludeFilter.xml</excludeFilterFile>
</configuration>
<dependencies>
<!-- overwrite dependency on spotbugs if you want to specify the version of spotbugs -->
<dependency>
<groupId>com.github.spotbugs</groupId>
<artifactId>spotbugs</artifactId>
<version>${spotbugs.version}</version>
</dependency>
</dependencies>
<executions>
<execution>
<phase>verify</phase>
<goals>
<goal>check</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

16
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/run-configurations/Distributed - start Backoffice app (_FlexinaleDistributedApplicationBackoffice_).run.xml Normal file
View file

@ -0,0 +1,16 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Distributed - start Backoffice app (&quot;FlexinaleDistributedApplicationBackoffice&quot;)" type="SpringBootApplicationConfigurationType" factoryName="Spring Boot" folderName="App Distributed">
<option name="ENABLE_LAUNCH_OPTIMIZATION" value="false" />
<module name="flexinale-distributed-backoffice" />
<option name="SPRING_BOOT_MAIN_CLASS" value="de.accso.flexinale.FlexinaleDistributedApplicationBackoffice" />
<extension name="coverage">
<pattern>
<option name="PATTERN" value="de.accso.flexinale.*" />
<option name="ENABLED" value="true" />
</pattern>
</extension>
<method v="2">
<option name="Make" enabled="true" />
</method>
</configuration>
</component>

5
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/run-configurations/Distributed Backoffice - Actuator Events Published.run.xml Normal file
View file

@ -0,0 +1,5 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Distributed Backoffice - Actuator Events Published" type="HttpClient.HttpRequestRunConfigurationType" factoryName="HTTP Request" folderName="Actuator Distributed" path="$PROJECT_DIR$/flexinale-distributed/flexinale-distributed-backoffice/src/test/curl/backoffice-actuator-events-published.http" requestIdentifier="#1">
<method v="2" />
</configuration>
</component>

5
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/run-configurations/Distributed Backoffice - Actuator Health.run.xml Normal file
View file

@ -0,0 +1,5 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Distributed Backoffice - Actuator Health" type="HttpClient.HttpRequestRunConfigurationType" factoryName="HTTP Request" folderName="Actuator Distributed" path="$PROJECT_DIR$/flexinale-distributed/flexinale-distributed-backoffice/src/test/curl/backoffice-actuator-health.http" requestIdentifier="#1">
<method v="2" />
</configuration>
</component>

5
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/run-configurations/Distributed Backoffice - Actuator Info.run.xml Normal file
View file

@ -0,0 +1,5 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Distributed Backoffice - Actuator Info" type="HttpClient.HttpRequestRunConfigurationType" factoryName="HTTP Request" folderName="Actuator Distributed" path="$PROJECT_DIR$/flexinale-distributed/flexinale-distributed-backoffice/src/test/curl/backoffice-actuator-info.http" requestIdentifier="#1">
<method v="2" />
</configuration>
</component>

5
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/run-configurations/Distributed Backoffice - Actuator Metrics.run.xml Normal file
View file

@ -0,0 +1,5 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Distributed Backoffice - Actuator Metrics" type="HttpClient.HttpRequestRunConfigurationType" factoryName="HTTP Request" folderName="Actuator Distributed" path="$PROJECT_DIR$/flexinale-distributed/flexinale-distributed-backoffice/src/test/curl/backoffice-actuator-metrics.http" requestIdentifier="#1">
<method v="2" />
</configuration>
</component>

5
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/run-configurations/Distributed Backoffice - Actuator Prometheus.run.xml Normal file
View file

@ -0,0 +1,5 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Distributed Backoffice - Actuator Prometheus" type="HttpClient.HttpRequestRunConfigurationType" factoryName="HTTP Request" folderName="Actuator Distributed" path="$PROJECT_DIR$/flexinale-distributed/flexinale-distributed-backoffice/src/test/curl/backoffice-actuator-prometheus.http" requestIdentifier="#1">
<method v="2" />
</configuration>
</component>

23
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/FlexinaleDistributedApplicationBackoffice.java Normal file
View file

@ -0,0 +1,23 @@
package de.accso.flexinale;
import jakarta.persistence.EntityManagerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Profile;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
@SpringBootApplication
@Profile({"!test-integrated &!test-distributed & !testdata"})
public class FlexinaleDistributedApplicationBackoffice {
public static void main(String[] args) {
SpringApplication.run(FlexinaleDistributedApplicationBackoffice.class, args);
}
@Bean
public PlatformTransactionManager transactionManager(final EntityManagerFactory entityManagerFactory) {
return new JpaTransactionManager(entityManagerFactory);
}
}

15
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_in/rest/ExcelHelper.java Normal file
View file

@ -0,0 +1,15 @@
package de.accso.flexinale.backoffice.api_in.rest;
import org.apache.poi.poifs.filesystem.FileMagic;
import java.io.IOException;
import java.io.InputStream;
final class ExcelHelper {
private ExcelHelper() {
}
static boolean isExcelFile(final InputStream stream) throws IOException {
return (FileMagic.valueOf(stream) == FileMagic.OOXML);
}
}

130
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_in/rest/FilmRestController.java Normal file
View file

@ -0,0 +1,130 @@
package de.accso.flexinale.backoffice.api_in.rest;
import de.accso.flexinale.backoffice.api_out.event.FilmPublisher;
import de.accso.flexinale.backoffice.api_out.event.VorfuehrungPublisher;
import de.accso.flexinale.backoffice.application.services.FilmUploadService;
import de.accso.flexinale.backoffice.domain.model.Film;
import de.accso.flexinale.backoffice.domain.model.Vorfuehrung;
import de.accso.flexinale.backoffice.application.services.FilmService;
import de.accso.flexinale.backoffice.application.services.VorfuehrungService;
import de.accso.flexinale.common.application.PersistMode;
import de.accso.flexinale.common.application.PersistedEntityAndResult;
import de.accso.flexinale.common.shared_kernel.FlexinaleIllegalStateException;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Profile;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
import static de.accso.flexinale.common.application.PersistedEntityAndResult.PersistedResult.ADDED;
import static de.accso.flexinale.common.application.PersistedEntityAndResult.PersistedResult.UPDATED;
@RestController
@Profile({ "!testdata-besucherportal & !testdata-ticketing" })
public class FilmRestController {
private static final Logger LOGGER = LoggerFactory.getLogger(FilmRestController.class);
@Autowired
private FilmService filmService;
@Autowired
private FilmUploadService filmUploadService;
@Autowired
private FilmPublisher filmPublisher;
@Autowired
private VorfuehrungService vorfuehrungService;
@Autowired
private VorfuehrungPublisher vorfuehrungPublisher;
@GetMapping(value = "/rest/filme", produces = "application/json")
@PreAuthorize("hasRole('ROLE_BESUCHER')")
public List<Film> filme() {
return filmService.filme();
}
@GetMapping(value = "/rest/film/{id}", produces = "application/json")
@PreAuthorize("hasRole('ROLE_BESUCHER')")
public Film film(@PathVariable final String id) {
Identifiable.Id filmId = Identifiable.Id.of(id);
Film film = filmService.film(filmId);
if (film == null) {
throw new RestResourceNotFoundException("no Film %s found.".formatted(id));
}
return film;
}
// -----------------------------------------------------------------------------------------------------------
ResponseEntity<RestResponseMessage> loadAndPersistAndPublishNewFilme(
final BufferedInputStream stream, final String originalFilename) throws IOException
{
// load and persist
Collection<PersistedEntityAndResult<Film>> addedAndUpdatedFilms =
filmUploadService.loadDataFromExcelSheetAndPersistAndReturn(stream, PersistMode.UPDATE);
List<Film> addedFilms = addedAndUpdatedFilms.stream()
.filter(filmWithResult -> filmWithResult.result().equals(ADDED))
.map(PersistedEntityAndResult::entity)
.toList();
List<Film> updatedFilms = addedAndUpdatedFilms.stream()
.filter(filmWithResult -> filmWithResult.result().equals(UPDATED))
.map(PersistedEntityAndResult::entity)
.toList();
publishFilmsAndVorfuehrungen(addedFilms, updatedFilms);
String message = "Uploaded the Excel file %s adding %d new Film entities and updating %d existing Film entities."
.formatted(originalFilename, addedFilms.size(), updatedFilms.size());
RestUploadResult restUploadResult = new RestUploadResult(HttpStatus.OK, message);
return ResponseEntity.status(restUploadResult.status())
.body(new RestResponseMessage(restUploadResult.message()));
}
private void publishFilmsAndVorfuehrungen(final List<Film> addedFilms, final List<Film> updatedFilms) {
filmPublisher.publishNewFilms(addedFilms);
filmPublisher.publishUpdatedFilms(updatedFilms);
List<Vorfuehrung> vorfuehrungen = vorfuehrungService.vorfuehrungen();
for (Film updatedFilm: updatedFilms) {
List<Vorfuehrung> vorfuehrungenToPublishAsUpdated = vorfuehrungen.stream()
.filter(vorfuehrung -> vorfuehrung.film.id.equals(updatedFilm.id))
.toList();
vorfuehrungPublisher.publishUpdatedVorfuehrungen(vorfuehrungenToPublishAsUpdated);
}
}
@PostMapping("/rest/filme")
@PreAuthorize("hasRole('ROLE_ADMIN')")
public ResponseEntity<RestResponseMessage> uploadFilme(@RequestParam("file") final MultipartFile file) {
try (BufferedInputStream stream = new BufferedInputStream(file.getInputStream())) {
if (!ExcelHelper.isExcelFile(stream)) {
String message = "Please upload a valid Excel file!";
throw new FlexinaleIllegalStateException(message);
}
return loadAndPersistAndPublishNewFilme(stream, file.getOriginalFilename());
}
catch (Exception ex) {
String message = "Could not upload the Excel file: %s: %s".formatted(file.getOriginalFilename(), ex.getMessage());
RestBadRequestException exception = new RestBadRequestException(message, ex);
LOGGER.error(message, exception);
throw exception;
}
}
}

167
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_in/rest/KinoKinoSaalRestController.java Normal file
View file

@ -0,0 +1,167 @@
package de.accso.flexinale.backoffice.api_in.rest;
import de.accso.flexinale.backoffice.api_out.event.KinoPublisher;
import de.accso.flexinale.backoffice.api_out.event.VorfuehrungPublisher;
import de.accso.flexinale.backoffice.application.services.KinoUploadService;
import de.accso.flexinale.backoffice.application.services.KinoSaalUploadService;
import de.accso.flexinale.backoffice.domain.model.Kino;
import de.accso.flexinale.backoffice.domain.model.KinoSaal;
import de.accso.flexinale.backoffice.domain.model.Vorfuehrung;
import de.accso.flexinale.backoffice.application.services.KinoService;
import de.accso.flexinale.backoffice.application.services.VorfuehrungService;
import de.accso.flexinale.common.application.PersistMode;
import de.accso.flexinale.common.application.PersistedEntityAndResult;
import de.accso.flexinale.common.shared_kernel.FlexinaleIllegalStateException;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Profile;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import static de.accso.flexinale.common.application.PersistedEntityAndResult.PersistedResult.ADDED;
import static de.accso.flexinale.common.application.PersistedEntityAndResult.PersistedResult.UPDATED;
@RestController
@Profile({ "!testdata-besucherportal & !testdata-ticketing" })
public class KinoKinoSaalRestController {
private static final Logger LOGGER = LoggerFactory.getLogger(KinoKinoSaalRestController.class);
@Autowired
private KinoService kinoService;
@Autowired
private KinoUploadService kinoUploadService;
@Autowired
private KinoSaalUploadService kinoSaalUploadService;
@Autowired
private KinoPublisher kinoPublisher;
@Autowired
private VorfuehrungService vorfuehrungService;
@Autowired
private VorfuehrungPublisher vorfuehrungPublisher;
@GetMapping(value = "/rest/kinos", produces = "application/json")
@PreAuthorize("hasRole('ROLE_BESUCHER')")
public List<Kino> kinos() {
return kinoService.kinos();
}
@GetMapping(value = "/rest/kino/{id}", produces = "application/json")
@PreAuthorize("hasRole('ROLE_BESUCHER')")
public Kino kino(@PathVariable final String id) {
Identifiable.Id kinoId = Identifiable.Id.of(id);
Kino kino = kinoService.kino(kinoId);
if (kino == null) {
throw new RestResourceNotFoundException("no Kino %s found.".formatted(id));
}
return kino;
}
// -----------------------------------------------------------------------------------------------------------
@PostMapping("/rest/kinos")
@PreAuthorize("hasRole('ROLE_ADMIN')")
public ResponseEntity<RestResponseMessage> uploadKinosKinoSaele(@RequestParam("file") final MultipartFile file) {
String originalFilename = file.getOriginalFilename();
try {
Collection<KinoSaal> alleKinoSaele;
// we need to open the stream twice, separately for KinoSaele ...
try (BufferedInputStream stream = new BufferedInputStream(file.getInputStream())) {
if (!ExcelHelper.isExcelFile(stream)) {
String message = "Please upload a valid Excel file!";
throw new FlexinaleIllegalStateException(message);
}
alleKinoSaele = loadKinoSaele(stream);
}
// ... and for Kino
try (BufferedInputStream stream = new BufferedInputStream(file.getInputStream())) {
return loadAndPersistAndPublishNewKinosKinoSaele(stream, originalFilename, alleKinoSaele);
}
}
catch (Exception ex) {
String message = "Could not upload the Excel file: %s: %s".formatted(file.getOriginalFilename(), ex.getMessage());
RestBadRequestException exception = new RestBadRequestException(message, ex);
LOGGER.error(message, exception);
throw exception;
}
}
Collection<KinoSaal> loadKinoSaele(final BufferedInputStream stream) throws IOException {
return kinoSaalUploadService.loadDataFromExcelSheet(stream);
}
ResponseEntity<RestResponseMessage> loadAndPersistAndPublishNewKinosKinoSaele(
final BufferedInputStream stream, final String originalFilename,
final Collection<KinoSaal> alleKinoSaele) throws IOException {
// and then load and persist all Kinos (including their KinoSaele)
Map<Identifiable.Id, Collection<KinoSaal>> alleKinosUndIhreSaele =
kinoSaalUploadService.mapKinoSaeleToKino(alleKinoSaele);
List<Kino> addedKinos;
List<Kino> updatedKinos;
try {
kinoUploadService.beforeLoad(alleKinosUndIhreSaele); // fix state of Kino-KinoSaal in map
// load and persist
Collection<PersistedEntityAndResult<Kino>> addedAndUpdatedKinos =
kinoUploadService.loadDataFromExcelSheetAndPersistAndReturn(stream, PersistMode.UPDATE);
addedKinos = addedAndUpdatedKinos.stream()
.filter(kinoWithResult -> kinoWithResult.result().equals(ADDED))
.map(PersistedEntityAndResult::entity)
.toList();
updatedKinos = addedAndUpdatedKinos.stream()
.filter(kinoWithResult -> kinoWithResult.result().equals(UPDATED))
.map(PersistedEntityAndResult::entity)
.toList();
publishKinosAndVorfuehrungen(addedKinos, updatedKinos);
}
finally {
kinoUploadService.afterLoad(); // clear map
}
String message = "Uploaded the Excel file %s adding %d new Kinos entities and updating %d existing Kinos entities."
.formatted(originalFilename, addedKinos.size(), updatedKinos.size());
RestUploadResult restUploadResult = new RestUploadResult(HttpStatus.OK, message);
return ResponseEntity.status(restUploadResult.status())
.body(new RestResponseMessage(restUploadResult.message()));
}
private void publishKinosAndVorfuehrungen(final List<Kino> addedKinos, final List<Kino> updatedKinos) {
kinoPublisher.publishNewKinos(addedKinos);
kinoPublisher.publishUpdatedKinos(updatedKinos);
List<Vorfuehrung> vorfuehrungen = vorfuehrungService.vorfuehrungen();
List<Vorfuehrung> vorfuehrungenToPublishAsUpdated = new ArrayList<>();
for (Kino updatedKino: updatedKinos) {
for (KinoSaal updatedKinoSaal: updatedKino.kinoSaele) {
vorfuehrungen.stream()
.filter(vorfuehrung -> vorfuehrung.kinoSaal.id.equals(updatedKinoSaal.id))
.forEach(vorfuehrungenToPublishAsUpdated::add);
}
}
vorfuehrungPublisher.publishUpdatedVorfuehrungen(vorfuehrungenToPublishAsUpdated);
}
}

19
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_in/rest/RestBadRequestException.java Normal file
View file

@ -0,0 +1,19 @@
package de.accso.flexinale.backoffice.api_in.rest;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;
@ResponseStatus(HttpStatus.BAD_REQUEST)
@SuppressWarnings("unused")
public class RestBadRequestException extends RuntimeException {
// see https://www.springboottutorial.com/spring-boot-exception-handling-for-rest-services
public RestBadRequestException(final String message) {
super(message);
}
public RestBadRequestException(final String message, final Exception ex) {
super(message, ex);
}
}

14
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_in/rest/RestResourceNotFoundException.java Normal file
View file

@ -0,0 +1,14 @@
package de.accso.flexinale.backoffice.api_in.rest;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;
@ResponseStatus(HttpStatus.NOT_FOUND)
public class RestResourceNotFoundException extends RuntimeException {
// see https://www.springboottutorial.com/spring-boot-exception-handling-for-rest-services
public RestResourceNotFoundException(final String message) {
super(message);
}
}

4
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_in/rest/RestResponseMessage.java Normal file
View file

@ -0,0 +1,4 @@
package de.accso.flexinale.backoffice.api_in.rest;
record RestResponseMessage(String message) {
}

7
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_in/rest/RestUploadResult.java Normal file
View file

@ -0,0 +1,7 @@
package de.accso.flexinale.backoffice.api_in.rest;
import org.springframework.http.HttpStatus;
@SuppressWarnings("SameParameterValue")
record RestUploadResult(HttpStatus status, String message) {
}

109
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_in/rest/VorfuehrungRestController.java Normal file
View file

@ -0,0 +1,109 @@
package de.accso.flexinale.backoffice.api_in.rest;
import de.accso.flexinale.backoffice.api_out.event.VorfuehrungPublisher;
import de.accso.flexinale.backoffice.application.services.VorfuehrungUploadService;
import de.accso.flexinale.backoffice.domain.model.Vorfuehrung;
import de.accso.flexinale.backoffice.application.services.VorfuehrungService;
import de.accso.flexinale.common.application.PersistMode;
import de.accso.flexinale.common.application.PersistedEntityAndResult;
import de.accso.flexinale.common.shared_kernel.FlexinaleIllegalStateException;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Profile;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
import static de.accso.flexinale.common.application.PersistedEntityAndResult.PersistedResult.ADDED;
import static de.accso.flexinale.common.application.PersistedEntityAndResult.PersistedResult.UPDATED;
@RestController
@Profile({ "!testdata-besucherportal & !testdata-ticketing" })
public class VorfuehrungRestController {
private static final Logger LOGGER = LoggerFactory.getLogger(VorfuehrungRestController.class);
@Autowired
private VorfuehrungService vorfuehrungService;
@Autowired
private VorfuehrungUploadService vorfuehrungUploadService;
@Autowired
private VorfuehrungPublisher vorfuehrungPublisher;
@GetMapping(value = "/rest/vorfuehrungen", produces = "application/json")
@PreAuthorize("hasRole('ROLE_BESUCHER')")
public List<Vorfuehrung> vorfuehrungen() {
return vorfuehrungService.vorfuehrungen();
}
@GetMapping(value = "/rest/vorfuehrungen/{id}", produces = "application/json")
@PreAuthorize("hasRole('ROLE_BESUCHER')")
public Vorfuehrung vorfuehrung(@PathVariable final String id) {
Identifiable.Id vorfuehrungId = Identifiable.Id.of(id);
Vorfuehrung vorfuehrung = vorfuehrungService.vorfuehrung(vorfuehrungId);
if (vorfuehrung == null) {
throw new RestResourceNotFoundException("no Vorfuehrung %s found.".formatted(id));
}
return vorfuehrung;
}
// -----------------------------------------------------------------------------------------------------------
@PostMapping("/rest/vorfuehrungen")
@PreAuthorize("hasRole('ROLE_ADMIN')")
public ResponseEntity<RestResponseMessage> uploadVorfuehrungen(@RequestParam("file") final MultipartFile file) {
try (BufferedInputStream stream = new BufferedInputStream(file.getInputStream())) {
if (!ExcelHelper.isExcelFile(stream)) {
String message = "Please upload a valid Excel file!";
throw new FlexinaleIllegalStateException(message);
}
return loadAndPersistAndPublishNewVorfuehrungen(stream, file.getOriginalFilename());
}
catch (Exception ex) {
String message = "Could not upload the Excel file: %s: %s".formatted(file.getOriginalFilename(), ex.getMessage());
RestBadRequestException exception = new RestBadRequestException(message, ex);
LOGGER.error(message, exception);
throw exception;
}
}
ResponseEntity<RestResponseMessage> loadAndPersistAndPublishNewVorfuehrungen(
final BufferedInputStream stream, final String originalFilename) throws IOException
{
// load and persist
Collection<PersistedEntityAndResult<Vorfuehrung>> addedAndUpdatedVorfuehrungen =
vorfuehrungUploadService.loadDataFromExcelSheetAndPersistAndReturn(stream, PersistMode.UPDATE);
// publish as events
List<Vorfuehrung> addedVorfuehrungen = addedAndUpdatedVorfuehrungen.stream()
.filter(vorfuehrungWithResult -> vorfuehrungWithResult.result().equals(ADDED))
.map(PersistedEntityAndResult::entity)
.toList();
vorfuehrungPublisher.publishNewVorfuehrungen(addedVorfuehrungen);
List<Vorfuehrung> updatedVorfuehrungen = addedAndUpdatedVorfuehrungen.stream()
.filter(vorfuehrungWithResult -> vorfuehrungWithResult.result().equals(UPDATED))
.map(PersistedEntityAndResult::entity)
.toList();
vorfuehrungPublisher.publishUpdatedVorfuehrungen(updatedVorfuehrungen);
String message = "Uploaded the Excel file %s adding %d new Vorfuehrungen entities and updating %d existing Vorfuehrungen entities."
.formatted(originalFilename, addedVorfuehrungen.size(), updatedVorfuehrungen.size());
RestUploadResult restUploadResult = new RestUploadResult(HttpStatus.OK, message);
return ResponseEntity.status(restUploadResult.status())
.body(new RestResponseMessage(restUploadResult.message()));
}
}

59
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_out/event/BootstrappingPostConstructBackoffice.java Normal file
View file

@ -0,0 +1,59 @@
package de.accso.flexinale.backoffice.api_out.event;
import de.accso.flexinale.backoffice.application.services.FilmService;
import de.accso.flexinale.backoffice.application.services.KinoService;
import de.accso.flexinale.backoffice.application.services.VorfuehrungService;
import jakarta.annotation.PostConstruct;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
@Component
@Profile({"!test-integrated & !testdata"})
public class BootstrappingPostConstructBackoffice {
private static final Logger LOGGER = LoggerFactory.getLogger(BootstrappingPostConstructBackoffice.class);
@Autowired
FilmService filmService;
@Autowired
FilmPublisher filmPublisher;
@Autowired
KinoService kinoService;
@Autowired
KinoPublisher kinoPublisher;
@Autowired
VorfuehrungService vorfuehrungService;
@Autowired
VorfuehrungPublisher vorfuehrungPublisher;
// Alternatively annotate method with @EventListener(ApplicationReadyEvent.class)
@PostConstruct
public void postConstruct() {
LOGGER.info("Publishing existing data for FKKsV as *Created events");
loadAllFilmeFromDatabaseAndPublish();
loadAllKinosFromDatabaseAndPublish();
loadAllVorfuehrungenFromDatabaseAndPublish();
LOGGER.info("Publishing existing data for FKKsV as *Created events ... done");
}
private void loadAllVorfuehrungenFromDatabaseAndPublish() {
filmPublisher.publishNewFilms( filmService.filme() );
}
private void loadAllKinosFromDatabaseAndPublish() {
kinoPublisher.publishNewKinos( kinoService.kinos() );
}
private void loadAllFilmeFromDatabaseAndPublish() {
vorfuehrungPublisher.publishNewVorfuehrungen( vorfuehrungService.vorfuehrungen() );
}
}

80
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_out/event/FilmPublisher.java Normal file
View file

@ -0,0 +1,80 @@
package de.accso.flexinale.backoffice.api_out.event;
import de.accso.flexinale.backoffice.api_contract.event.FilmCRUDEvent;
import de.accso.flexinale.backoffice.api_contract.event.FilmCreatedEvent;
import de.accso.flexinale.backoffice.api_contract.event.FilmDeletedEvent;
import de.accso.flexinale.backoffice.api_contract.event.FilmUpdatedEvent;
import de.accso.flexinale.backoffice.api_contract.event.model.FilmTO;
import de.accso.flexinale.backoffice.api_out.event.mapper.Film2FilmTOMapper;
import de.accso.flexinale.backoffice.domain.model.Film;
import de.accso.flexinale.common.api.eventbus.EventBus;
import de.accso.flexinale.common.api.eventbus.EventBusFactory;
import de.accso.flexinale.common.api.eventbus.EventNotification;
import de.accso.flexinale.common.api.eventbus.EventPublisher.EventPublisher3;
import java.util.Collection;
@SuppressWarnings("unused")
public class FilmPublisher implements EventPublisher3<FilmCreatedEvent, FilmUpdatedEvent, FilmDeletedEvent> {
private final EventBus<FilmCreatedEvent> createBus;
private final EventBus<FilmUpdatedEvent> updateBus;
private final EventBus<FilmDeletedEvent> deleteBus;
private final EventNotification notification;
public FilmPublisher(final EventBusFactory eventBusFactory,
final EventNotification notification) {
this.createBus = eventBusFactory.createOrGetEventBusFor(FilmCreatedEvent.class);
this.updateBus = eventBusFactory.createOrGetEventBusFor(FilmUpdatedEvent.class);
this.deleteBus = eventBusFactory.createOrGetEventBusFor(FilmDeletedEvent.class);
this.notification = notification;
}
public void publishNewFilms(final Collection<Film> films) {
publishCRUDEvents(films, FilmCRUDEvent.CRUD.CREATE);
}
public void publishUpdatedFilms(final Collection<Film> films) {
publishCRUDEvents(films, FilmCRUDEvent.CRUD.UPDATE);
}
// currently we do not publish Deletions events
public void publishDeletedFilms(final Collection<Film> films) {
publishCRUDEvents(films, FilmCRUDEvent.CRUD.DELETE);
}
private void publishCRUDEvents(final Collection<Film> changedFilms, final FilmCRUDEvent.CRUD mode) {
for (Film film: changedFilms) {
FilmTO filmTO = Film2FilmTOMapper.map(film);
switch (mode) {
case CREATE -> this.post (FilmCreatedEvent.class, new FilmCreatedEvent(filmTO));
case UPDATE -> this.post2(FilmUpdatedEvent.class, new FilmUpdatedEvent(filmTO));
case DELETE -> this.post3(FilmDeletedEvent.class, new FilmDeletedEvent(filmTO));
}
}
}
@Override
public String getName() {
return FilmPublisher.class.getName();
}
@Override
public void post(final Class<FilmCreatedEvent> eventType, final FilmCreatedEvent event) {
this.createBus.publish(eventType, event);
this.notification.notify(event);
}
@Override
public void post2(final Class<FilmUpdatedEvent> eventType, final FilmUpdatedEvent event) {
this.updateBus.publish(eventType, event);
this.notification.notify(event);
}
@Override
public void post3(final Class<FilmDeletedEvent> eventType, final FilmDeletedEvent event) {
this.deleteBus.publish(eventType, event);
this.notification.notify(event);
}
}

80
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_out/event/KinoPublisher.java Normal file
View file

@ -0,0 +1,80 @@
package de.accso.flexinale.backoffice.api_out.event;
import de.accso.flexinale.backoffice.api_contract.event.KinoCRUDEvent;
import de.accso.flexinale.backoffice.api_contract.event.KinoCreatedEvent;
import de.accso.flexinale.backoffice.api_contract.event.KinoDeletedEvent;
import de.accso.flexinale.backoffice.api_contract.event.KinoUpdatedEvent;
import de.accso.flexinale.backoffice.api_contract.event.model.KinoTO;
import de.accso.flexinale.backoffice.api_out.event.mapper.KinoKinoSaal2KinoKinoSaalTOMapper;
import de.accso.flexinale.backoffice.domain.model.Kino;
import de.accso.flexinale.common.api.eventbus.EventBus;
import de.accso.flexinale.common.api.eventbus.EventBusFactory;
import de.accso.flexinale.common.api.eventbus.EventNotification;
import de.accso.flexinale.common.api.eventbus.EventPublisher.EventPublisher3;
import java.util.Collection;
@SuppressWarnings("unused")
public class KinoPublisher implements EventPublisher3<KinoCreatedEvent, KinoUpdatedEvent, KinoDeletedEvent> {
private final EventBus<KinoCreatedEvent> createBus;
private final EventBus<KinoUpdatedEvent> updateBus;
private final EventBus<KinoDeletedEvent> deleteBus;
private final EventNotification notification;
public KinoPublisher(final EventBusFactory eventBusFactory,
final EventNotification notification) {
this.createBus = eventBusFactory.createOrGetEventBusFor(KinoCreatedEvent.class);
this.updateBus = eventBusFactory.createOrGetEventBusFor(KinoUpdatedEvent.class);
this.deleteBus = eventBusFactory.createOrGetEventBusFor(KinoDeletedEvent.class);
this.notification = notification;
}
public void publishNewKinos(final Collection<Kino> kinos) {
publishCRUDEvents(kinos, KinoCRUDEvent.CRUD.CREATE);
}
public void publishUpdatedKinos(final Collection<Kino> kinos) {
publishCRUDEvents(kinos, KinoCRUDEvent.CRUD.UPDATE);
}
// currently we do not publish Deletions events
public void publishDeletedKinos(final Collection<Kino> kinos) {
publishCRUDEvents(kinos, KinoCRUDEvent.CRUD.DELETE);
}
private void publishCRUDEvents(final Collection<Kino> changedKinos, final KinoCRUDEvent.CRUD mode) {
for (Kino kino: changedKinos) {
KinoTO kinoTO = KinoKinoSaal2KinoKinoSaalTOMapper.mapKino(kino);
switch (mode) {
case CREATE -> this.post (KinoCreatedEvent.class, new KinoCreatedEvent(kinoTO));
case UPDATE -> this.post2(KinoUpdatedEvent.class, new KinoUpdatedEvent(kinoTO));
case DELETE -> this.post3(KinoDeletedEvent.class, new KinoDeletedEvent(kinoTO));
}
}
}
@Override
public String getName() {
return KinoPublisher.class.getName();
}
@Override
public void post(final Class<KinoCreatedEvent> eventType, final KinoCreatedEvent event) {
this.createBus.publish(eventType, event);
this.notification.notify(event);
}
@Override
public void post2(final Class<KinoUpdatedEvent> eventType, final KinoUpdatedEvent event) {
this.updateBus.publish(eventType, event);
this.notification.notify(event);
}
@Override
public void post3(final Class<KinoDeletedEvent> eventType, final KinoDeletedEvent event) {
this.deleteBus.publish(eventType, event);
this.notification.notify(event);
}
}

80
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_out/event/VorfuehrungPublisher.java Normal file
View file

@ -0,0 +1,80 @@
package de.accso.flexinale.backoffice.api_out.event;
import de.accso.flexinale.backoffice.api_contract.event.VorfuehrungCRUDEvent;
import de.accso.flexinale.backoffice.api_contract.event.VorfuehrungCreatedEvent;
import de.accso.flexinale.backoffice.api_contract.event.VorfuehrungDeletedEvent;
import de.accso.flexinale.backoffice.api_contract.event.VorfuehrungUpdatedEvent;
import de.accso.flexinale.backoffice.api_contract.event.model.VorfuehrungTO;
import de.accso.flexinale.backoffice.api_out.event.mapper.Vorfuehrung2VorfuehrungTOMapper;
import de.accso.flexinale.backoffice.domain.model.Vorfuehrung;
import de.accso.flexinale.common.api.eventbus.EventBus;
import de.accso.flexinale.common.api.eventbus.EventBusFactory;
import de.accso.flexinale.common.api.eventbus.EventNotification;
import de.accso.flexinale.common.api.eventbus.EventPublisher.EventPublisher3;
import java.util.Collection;
@SuppressWarnings("unused")
public class VorfuehrungPublisher implements EventPublisher3<VorfuehrungCreatedEvent, VorfuehrungUpdatedEvent, VorfuehrungDeletedEvent> {
private final EventBus<VorfuehrungCreatedEvent> createBus;
private final EventBus<VorfuehrungUpdatedEvent> updateBus;
private final EventBus<VorfuehrungDeletedEvent> deleteBus;
private final EventNotification notification;
public VorfuehrungPublisher(final EventBusFactory eventBusFactory,
final EventNotification notification) {
this.createBus = eventBusFactory.createOrGetEventBusFor(VorfuehrungCreatedEvent.class);
this.updateBus = eventBusFactory.createOrGetEventBusFor(VorfuehrungUpdatedEvent.class);
this.deleteBus = eventBusFactory.createOrGetEventBusFor(VorfuehrungDeletedEvent.class);
this.notification = notification;
}
public void publishNewVorfuehrungen(final Collection<Vorfuehrung> vorfuehrungen) {
publishCRUDEvents(vorfuehrungen, VorfuehrungCRUDEvent.CRUD.CREATE);
}
public void publishUpdatedVorfuehrungen(final Collection<Vorfuehrung> vorfuehrungen) {
publishCRUDEvents(vorfuehrungen, VorfuehrungCRUDEvent.CRUD.UPDATE);
}
// currently we do not publish Deletions events
public void publishDeletedVorfuehrungen(final Collection<Vorfuehrung> vorfuehrungen) {
publishCRUDEvents(vorfuehrungen, VorfuehrungCRUDEvent.CRUD.DELETE);
}
private void publishCRUDEvents(final Collection<Vorfuehrung> changedVorfuehrungen, final VorfuehrungCRUDEvent.CRUD mode) {
for (Vorfuehrung vorfuehrung: changedVorfuehrungen) {
VorfuehrungTO vorfuehrungTO = Vorfuehrung2VorfuehrungTOMapper.map(vorfuehrung);
switch (mode) {
case CREATE -> this.post (VorfuehrungCreatedEvent.class, new VorfuehrungCreatedEvent(vorfuehrungTO));
case UPDATE -> this.post2(VorfuehrungUpdatedEvent.class, new VorfuehrungUpdatedEvent(vorfuehrungTO));
case DELETE -> this.post3(VorfuehrungDeletedEvent.class, new VorfuehrungDeletedEvent(vorfuehrungTO));
}
}
}
@Override
public String getName() {
return VorfuehrungPublisher.class.getName();
}
@Override
public void post(final Class<VorfuehrungCreatedEvent> eventType, final VorfuehrungCreatedEvent event) {
this.createBus.publish(eventType, event);
this.notification.notify(event);
}
@Override
public void post2(final Class<VorfuehrungUpdatedEvent> eventType, final VorfuehrungUpdatedEvent event) {
this.updateBus.publish(eventType, event);
this.notification.notify(event);
}
@Override
public void post3(final Class<VorfuehrungDeletedEvent> eventType, final VorfuehrungDeletedEvent event) {
this.deleteBus.publish(eventType, event);
this.notification.notify(event);
}
}

16
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_out/event/mapper/Film2FilmTOMapper.java Normal file
View file

@ -0,0 +1,16 @@
package de.accso.flexinale.backoffice.api_out.event.mapper;
import de.accso.flexinale.backoffice.api_contract.event.model.FilmTO;
import de.accso.flexinale.backoffice.domain.model.Film;
import static de.accso.flexinale.common.shared_kernel.RawWrapper.getRawOrNull;
public final class Film2FilmTOMapper {
public static FilmTO map(final Film film) {
return new FilmTO(film.id(), film.version,
new FilmTO.Titel(getRawOrNull(film.titel)),
new FilmTO.ImdbUrl(getRawOrNull(film.imdbUrl)),
new FilmTO.DauerInMinuten(getRawOrNull(film.dauerInMinuten)));
}
}

43
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_out/event/mapper/KinoKinoSaal2KinoKinoSaalTOMapper.java Normal file
View file

@ -0,0 +1,43 @@
package de.accso.flexinale.backoffice.api_out.event.mapper;
import de.accso.flexinale.backoffice.api_contract.event.model.KinoSaalTO;
import de.accso.flexinale.backoffice.api_contract.event.model.KinoTO;
import de.accso.flexinale.backoffice.domain.model.Kino;
import de.accso.flexinale.backoffice.domain.model.KinoSaal;
import java.util.HashSet;
import static de.accso.flexinale.common.shared_kernel.RawWrapper.getRawOrNull;
public final class KinoKinoSaal2KinoKinoSaalTOMapper {
public static KinoTO mapKino(final Kino kino) {
final KinoTO mappedKino = new KinoTO(kino.id(), kino.version(),
new KinoTO.Name(getRawOrNull(kino.name)),
new KinoTO.Adresse(getRawOrNull(kino.adresse)),
new KinoTO.EmailAdresse(getRawOrNull(kino.emailAdresse)),
new HashSet<>());
kino.kinoSaele.stream()
.map(kinoSaal -> mapKinoSaal(kinoSaal, mappedKino))
.forEach(kinoSaal -> mappedKino.kinoSaele().add(kinoSaal));
return mappedKino;
}
static KinoSaalTO mapKinoSaal(final KinoSaal kinoSaal) {
Kino kino = kinoSaal.kino;
KinoTO mappedKino = mapKino(kino);
return new KinoSaalTO(kinoSaal.id(), kino.version,
new KinoSaalTO.Name(getRawOrNull(kinoSaal.name)),
new KinoSaalTO.AnzahlPlaetze(getRawOrNull(kinoSaal.anzahlPlaetze)),
mappedKino);
}
private static KinoSaalTO mapKinoSaal(final KinoSaal kinoSaal, final KinoTO kino) {
return new KinoSaalTO(kinoSaal.id(), kinoSaal.version,
new KinoSaalTO.Name(getRawOrNull(kinoSaal.name)),
new KinoSaalTO.AnzahlPlaetze(getRawOrNull(kinoSaal.anzahlPlaetze)),
kino);
}
}

20
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/api_out/event/mapper/Vorfuehrung2VorfuehrungTOMapper.java Normal file
View file

@ -0,0 +1,20 @@
package de.accso.flexinale.backoffice.api_out.event.mapper;
import de.accso.flexinale.backoffice.api_contract.event.model.FilmTO;
import de.accso.flexinale.backoffice.api_contract.event.model.KinoSaalTO;
import de.accso.flexinale.backoffice.api_contract.event.model.VorfuehrungTO;
import de.accso.flexinale.backoffice.domain.model.Vorfuehrung;
import static de.accso.flexinale.common.shared_kernel.RawWrapper.getRawOrNull;
public final class Vorfuehrung2VorfuehrungTOMapper {
public static VorfuehrungTO map(final Vorfuehrung vorfuehrung) {
FilmTO filmTO = Film2FilmTOMapper.map(vorfuehrung.film);
KinoSaalTO kinoSaalTO = KinoKinoSaal2KinoKinoSaalTOMapper.mapKinoSaal(vorfuehrung.kinoSaal);
return new VorfuehrungTO(vorfuehrung.id(), vorfuehrung.version(),
new VorfuehrungTO.Zeit(getRawOrNull(vorfuehrung.zeit)),
filmTO, kinoSaalTO, kinoSaalTO.kino().id());
}
}

25
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/application/services/FilmService.java Normal file
View file

@ -0,0 +1,25 @@
package de.accso.flexinale.backoffice.application.services;
import de.accso.flexinale.backoffice.domain.model.Film;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import jakarta.transaction.Transactional;
import java.util.List;
@Transactional
public class FilmService {
private final de.accso.flexinale.backoffice.domain.services.FilmService filmService;
public FilmService(de.accso.flexinale.backoffice.domain.services.FilmService filmService) {
this.filmService = filmService;
}
public List<Film> filme() {
return filmService.filme();
}
public Film film(Identifiable.Id filmId) {
return filmService.film(filmId);
}
}

58
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/application/services/FilmUploadService.java Normal file
View file

@ -0,0 +1,58 @@
package de.accso.flexinale.backoffice.application.services;
import de.accso.flexinale.backoffice.domain.dao.FilmDao;
import de.accso.flexinale.backoffice.domain.model.Film;
import de.accso.flexinale.common.domain.model.AbstractDao;
import de.accso.flexinale.common.application.services.AbstractExcelDataUploadService;
import de.accso.flexinale.common.shared_kernel.FlexinaleIllegalArgumentException;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import jakarta.transaction.Transactional;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Transactional
public class FilmUploadService extends AbstractExcelDataUploadService<Film> {
private static final Logger LOGGER = LoggerFactory.getLogger(FilmUploadService.class);
private final FilmDao filmDao;
public FilmUploadService(final FilmDao filmDao) {
this.filmDao = filmDao;
}
@Override
public AbstractDao<Film> getDao() {
return filmDao;
}
@Override
public String getNameOfExcelDataType() {
return Film.class.getSimpleName();
}
@Override
public Film createDataFromExcelRow(final Row excelRow) {
String filmId = excelRow.getCell(0).getStringCellValue();
Cell cellDauer = excelRow.getCell(3);
int dauerInMinuten =
switch(cellDauer.getCellType()) {
case NUMERIC -> (int) cellDauer.getNumericCellValue();
case STRING -> Integer.parseInt(cellDauer.getStringCellValue());
default -> throw new FlexinaleIllegalArgumentException("Dauer is not a number");
};
Film film = new Film(
Identifiable.Id.of(filmId),
new Film.Titel(excelRow.getCell(1).getStringCellValue()),
new Film.ImdbUrl(excelRow.getCell(2).getStringCellValue()),
new Film.DauerInMinuten(dauerInMinuten)
);
LOGGER.debug("New Film created " + film);
return film;
}
}

95
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/application/services/KinoSaalUploadService.java Normal file
View file

@ -0,0 +1,95 @@
package de.accso.flexinale.backoffice.application.services;
import de.accso.flexinale.backoffice.domain.dao.KinoSaalDao;
import de.accso.flexinale.backoffice.domain.model.Kino;
import de.accso.flexinale.backoffice.domain.model.KinoSaal;
import de.accso.flexinale.common.application.PersistMode;
import de.accso.flexinale.common.application.PersistedEntityAndResult;
import de.accso.flexinale.common.domain.model.AbstractDao;
import de.accso.flexinale.common.application.services.AbstractExcelDataUploadService;
import de.accso.flexinale.common.shared_kernel.DeveloperMistakeException;
import de.accso.flexinale.common.shared_kernel.FlexinaleIllegalArgumentException;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import jakarta.transaction.Transactional;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.InputStream;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
@Transactional
public class KinoSaalUploadService extends AbstractExcelDataUploadService<KinoSaal> {
private static final Logger LOGGER = LoggerFactory.getLogger(KinoSaalUploadService.class);
private final KinoSaalDao kinoSaalDao;
public KinoSaalUploadService(final KinoSaalDao kinoSaalDao) {
this.kinoSaalDao = kinoSaalDao;
}
@Override
public AbstractDao<KinoSaal> getDao() {
return kinoSaalDao;
}
@Override
public String getNameOfExcelDataType() {
return KinoSaal.class.getSimpleName();
}
@Override
public Collection<PersistedEntityAndResult<KinoSaal>> loadDataFromExcelSheetAndPersistAndReturn(
final InputStream stream, final PersistMode mode) {
throw new DeveloperMistakeException("method must not be called on KinoSaalUploadService");
}
@Override
public KinoSaal createDataFromExcelRow(final Row excelRow) {
String kinoSaalId = excelRow.getCell(0).getStringCellValue();
String kinoId = excelRow.getCell(3).getStringCellValue();
Cell cellAnzahlPlaetze = excelRow.getCell(2);
int anzahlPlaetze =
switch(cellAnzahlPlaetze.getCellType()) {
case NUMERIC -> (int) cellAnzahlPlaetze.getNumericCellValue();
case STRING -> Integer.parseInt(cellAnzahlPlaetze.getStringCellValue());
default -> throw new FlexinaleIllegalArgumentException("Anzahl Plaetze is not a number");
};
KinoSaal kinoSaal = new KinoSaal(
Identifiable.Id.of(kinoSaalId),
new KinoSaal.Name(excelRow.getCell(1).getStringCellValue()),
new KinoSaal.AnzahlPlaetze(anzahlPlaetze),
new Kino(Identifiable.Id.of(kinoId))
);
LOGGER.debug("New KinoSaal created: " + kinoSaal);
return kinoSaal;
}
public Map<Identifiable.Id, Collection<KinoSaal>> mapKinoSaeleToKino(final Collection<KinoSaal> kinoSaele) {
Map<Identifiable.Id, Collection<KinoSaal>> saeleUndKinos = new HashMap<>();
for (KinoSaal saal : kinoSaele) {
Identifiable.Id key = saal.kino.id();
Collection<KinoSaal> kinoSaeleAlreadyMapped = saeleUndKinos.get(key);
if (kinoSaeleAlreadyMapped == null) {
HashSet<KinoSaal> saele = new HashSet<>();
saele.add(saal);
saeleUndKinos.put(key, saele);
}
else {
kinoSaeleAlreadyMapped.add(saal);
saeleUndKinos.put(key, kinoSaeleAlreadyMapped);
}
}
return saeleUndKinos;
}
}

26
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/application/services/KinoService.java Normal file
View file

@ -0,0 +1,26 @@
package de.accso.flexinale.backoffice.application.services;
import de.accso.flexinale.backoffice.domain.model.Kino;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import jakarta.transaction.Transactional;
import java.util.List;
@Transactional
public class KinoService {
private final de.accso.flexinale.backoffice.domain.services.KinoService kinoService;
public KinoService(de.accso.flexinale.backoffice.domain.services.KinoService kinoService) {
this.kinoService = kinoService;
}
public Kino kino(Identifiable.Id kinoId) {
return kinoService.kino(kinoId);
}
public List<Kino> kinos() {
return kinoService.kinos();
}
}

81
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/application/services/KinoUploadService.java Normal file
View file

@ -0,0 +1,81 @@
package de.accso.flexinale.backoffice.application.services;
import de.accso.flexinale.backoffice.domain.dao.KinoDao;
import de.accso.flexinale.backoffice.domain.model.Kino;
import de.accso.flexinale.backoffice.domain.model.KinoSaal;
import de.accso.flexinale.common.domain.model.AbstractDao;
import de.accso.flexinale.common.application.services.AbstractExcelDataUploadService;
import de.accso.flexinale.common.shared_kernel.DeveloperMistakeException;
import de.accso.flexinale.common.shared_kernel.FlexinaleIllegalStateException;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import jakarta.transaction.Transactional;
import org.apache.poi.ss.usermodel.Row;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
@Transactional
public class KinoUploadService extends AbstractExcelDataUploadService<Kino> {
private static final Logger LOGGER = LoggerFactory.getLogger(KinoUploadService.class);
private final KinoDao kinoDao;
private final Map<Identifiable.Id, Collection<KinoSaal>> alleKinosUndIhreSaele = new HashMap<>();
public KinoUploadService(KinoDao kinoDao) {
this.kinoDao = kinoDao;
}
@Override
public AbstractDao<Kino> getDao() {
return kinoDao;
}
@Override
public String getNameOfExcelDataType() {
return Kino.class.getSimpleName();
}
@Override
public void beforeLoad(Object... o) {
if ((o.length != 1) && (!(o[0] instanceof Map))) {
throw new DeveloperMistakeException("wrong type: expecting a " +
"Map<Identifiable.Id, Collection<KinoSaal>> of Kino and their KinoSaele");
}
@SuppressWarnings("unchecked")
Map<Identifiable.Id, Collection<KinoSaal>> newKinoAndKinoSaele = (Map<Identifiable.Id, Collection<KinoSaal>>) o[0];
this.alleKinosUndIhreSaele.putAll(newKinoAndKinoSaele);
}
@Override
public void afterLoad(Object... o) {
alleKinosUndIhreSaele.clear();
}
@Override
public Kino createDataFromExcelRow(final Row excelRow) {
String kinoId = excelRow.getCell(0).getStringCellValue();
Collection<KinoSaal> saeleImKino = alleKinosUndIhreSaele.get(Identifiable.Id.of(kinoId));
if (saeleImKino == null || saeleImKino.isEmpty()) {
throw new FlexinaleIllegalStateException("no Saele for Kino %s found".formatted(kinoId));
}
Kino kino = new Kino(
Identifiable.Id.of(kinoId),
new Kino.Name(excelRow.getCell(1).getStringCellValue()),
new Kino.Adresse(excelRow.getCell(2).getStringCellValue()),
new Kino.EmailAdresse(excelRow.getCell(3).getStringCellValue()),
Set.copyOf(saeleImKino)
);
LOGGER.debug("New Kino created: " + kino);
return kino;
}
}

26
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/application/services/VorfuehrungService.java Normal file
View file

@ -0,0 +1,26 @@
package de.accso.flexinale.backoffice.application.services;
import de.accso.flexinale.backoffice.domain.model.Vorfuehrung;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import jakarta.transaction.Transactional;
import java.util.List;
@Transactional
public class VorfuehrungService {
private final de.accso.flexinale.backoffice.domain.services.VorfuehrungService vorfuehrungService;
public VorfuehrungService(de.accso.flexinale.backoffice.domain.services.VorfuehrungService vorfuehrungService) {
this.vorfuehrungService = vorfuehrungService;
}
public List<Vorfuehrung> vorfuehrungen() {
return vorfuehrungService.vorfuehrungen();
}
public Vorfuehrung vorfuehrung(Identifiable.Id vorfuehrungId) {
return vorfuehrungService.vorfuehrung(vorfuehrungId);
}
}

65
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/application/services/VorfuehrungUploadService.java Normal file
View file

@ -0,0 +1,65 @@
package de.accso.flexinale.backoffice.application.services;
import de.accso.flexinale.backoffice.domain.dao.FilmDao;
import de.accso.flexinale.backoffice.domain.dao.KinoSaalDao;
import de.accso.flexinale.backoffice.domain.dao.VorfuehrungDao;
import de.accso.flexinale.backoffice.domain.model.Film;
import de.accso.flexinale.backoffice.domain.model.KinoSaal;
import de.accso.flexinale.backoffice.domain.model.Vorfuehrung;
import de.accso.flexinale.common.domain.model.AbstractDao;
import de.accso.flexinale.common.application.services.AbstractExcelDataUploadService;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import jakarta.transaction.Transactional;
import org.apache.poi.ss.usermodel.Row;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.time.LocalDateTime;
@Transactional
public class VorfuehrungUploadService extends AbstractExcelDataUploadService<Vorfuehrung> {
private static final Logger LOGGER = LoggerFactory.getLogger(VorfuehrungUploadService.class);
private final FilmDao filmDao;
private final KinoSaalDao kinoSaalDao;
private final VorfuehrungDao vorfuehrungDao;
public VorfuehrungUploadService(final VorfuehrungDao vorfuehrungDao,
final FilmDao filmDao,
final KinoSaalDao kinoSaalDao) {
this.filmDao = filmDao;
this.kinoSaalDao = kinoSaalDao;
this.vorfuehrungDao = vorfuehrungDao;
}
@Override
public AbstractDao<Vorfuehrung> getDao() {
return vorfuehrungDao;
}
@Override
public String getNameOfExcelDataType() {
return Vorfuehrung.class.getSimpleName();
}
@Override
public Vorfuehrung createDataFromExcelRow(final Row excelRow) {
String vorfuehrungId = excelRow.getCell(0).getStringCellValue();
// expects date/time in format like for example 2023-02-20T17:45
LocalDateTime zeit = LocalDateTime.parse(excelRow.getCell(1).getStringCellValue());
String filmId = excelRow.getCell(2).getStringCellValue();
Film film = filmDao.findById(Identifiable.Id.of(filmId)).orElseThrow(IllegalStateException::new);
String kinoSaalId = excelRow.getCell(3).getStringCellValue();
KinoSaal kinoSaal = kinoSaalDao.findById(Identifiable.Id.of(kinoSaalId)).orElseThrow(IllegalStateException::new);
Vorfuehrung vorfuehrung = new Vorfuehrung(Identifiable.Id.of(vorfuehrungId), new Vorfuehrung.Zeit(zeit), film, kinoSaal);
LOGGER.debug("New Vorfuehrung created: " + vorfuehrung);
return vorfuehrung;
}
}

13
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/domain/dao/FilmDao.java Normal file
View file

@ -0,0 +1,13 @@
package de.accso.flexinale.backoffice.domain.dao;
import de.accso.flexinale.backoffice.domain.model.Film;
import de.accso.flexinale.common.domain.model.AbstractDao;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import java.util.Optional;
public interface FilmDao extends AbstractDao<Film> {
@Override
Optional<Film> findById(final Identifiable.Id id);
}

13
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/domain/dao/KinoDao.java Normal file
View file

@ -0,0 +1,13 @@
package de.accso.flexinale.backoffice.domain.dao;
import de.accso.flexinale.backoffice.domain.model.Kino;
import de.accso.flexinale.common.domain.model.AbstractDao;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import java.util.Optional;
public interface KinoDao extends AbstractDao<Kino> {
@Override
Optional<Kino> findById(final Identifiable.Id id);
}

13
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/domain/dao/KinoSaalDao.java Normal file
View file

@ -0,0 +1,13 @@
package de.accso.flexinale.backoffice.domain.dao;
import de.accso.flexinale.backoffice.domain.model.KinoSaal;
import de.accso.flexinale.common.domain.model.AbstractDao;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import java.util.Optional;
public interface KinoSaalDao extends AbstractDao<KinoSaal> {
@Override
Optional<KinoSaal> findById(final Identifiable.Id id);
}

17
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/domain/dao/VorfuehrungDao.java Normal file
View file

@ -0,0 +1,17 @@
package de.accso.flexinale.backoffice.domain.dao;
import de.accso.flexinale.backoffice.domain.model.Vorfuehrung;
import de.accso.flexinale.common.domain.model.AbstractDao;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import java.util.List;
import java.util.Optional;
@SuppressWarnings("unused")
public interface VorfuehrungDao extends AbstractDao<Vorfuehrung> {
@Override
Optional<Vorfuehrung> findById(final Identifiable.Id id);
List<Vorfuehrung> findByFilmId(final Identifiable.Id filmId);
}

95
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/domain/model/Film.java Normal file
View file

@ -0,0 +1,95 @@
package de.accso.flexinale.backoffice.domain.model;
import de.accso.flexinale.common.shared_kernel.*;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
public class Film implements Identifiable, Versionable, Mergeable<Film>, EqualsByContent {
public record Titel(String raw) implements RawWrapper<String> {}
public record ImdbUrl(String raw) implements RawWrapper<String> {}
public record DauerInMinuten(Integer raw) implements RawWrapper<Integer> {}
public final Id id;
public final Version version;
public Titel titel;
public ImdbUrl imdbUrl;
public DauerInMinuten dauerInMinuten;
public Film(final Id id) {
this(id, Versionable.unknownVersion());
}
public Film(final Id id, final Version version) {
this.id = id;
this.version = version;
}
public Film(final Id id,
final Titel titel, final ImdbUrl imdbUrl, final DauerInMinuten dauerInMinuten) {
this(id, Versionable.unknownVersion(), titel, imdbUrl, dauerInMinuten);
}
public Film(final Id id, final Version version,
final Titel titel, final ImdbUrl imdbUrl, final DauerInMinuten dauerInMinuten) {
this.id = id;
this.version = version;
this.titel = titel;
this.imdbUrl = imdbUrl;
this.dauerInMinuten = dauerInMinuten;
}
@Override
public Id id() {
return id;
}
@Override
public Version version() {
return version;
}
@Override
public Film merge(final Film newData) {
return new Film(this.id, this.version,
newData.titel, newData.imdbUrl, newData.dauerInMinuten);
}
@Override
public String toString() {
return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE);
}
@Override
public boolean equals(final Object o) {
if (!equalsByContent(o)) return false;
if (this == o) {return true;}
if (o == null || getClass() != o.getClass()) {return false;}
final Film that = (Film) o;
return new EqualsBuilder().append(version, that.version).isEquals();
}
@Override
public boolean equalsByContent(final Object o) {
if (this == o) {return true;}
if (o == null || getClass() != o.getClass()) {return false;}
final Film that = (Film) o;
return new EqualsBuilder()
.append(id, that.id)
.append(titel, that.titel).append(imdbUrl, that.imdbUrl)
.append(dauerInMinuten, that.dauerInMinuten).isEquals();
}
@Override
public int hashCode() {
return new HashCodeBuilder(17, 37)
.append(id).append(version)
.append(titel).append(imdbUrl).append(dauerInMinuten).toHashCode();
}
}

145
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/domain/model/Kino.java Normal file
View file

@ -0,0 +1,145 @@
package de.accso.flexinale.backoffice.domain.model;
import de.accso.flexinale.common.shared_kernel.*;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import java.util.*;
import java.util.stream.Collectors;
public class Kino implements Identifiable, Versionable, Mergeable<Kino>, EqualsByContent {
public record Name(String raw) implements RawWrapper<String> {}
public record Adresse(String raw) implements RawWrapper<String> {}
public record EmailAdresse(String raw) implements RawWrapper<String> {}
public final Id id;
public final Version version;
public Name name;
public Adresse adresse;
public EmailAdresse emailAdresse;
@DoNotCheckInArchitectureTests
public Set<KinoSaal> kinoSaele = new HashSet<>();
public Kino(final Id id) {
this(id, Versionable.unknownVersion());
}
public Kino(final Id id, final Version version) {
this.id = id;
this.version = version;
}
public Kino(final Id id,
final Name name, final Adresse adresse,
final EmailAdresse emailAdresse, final Set<KinoSaal> kinoSaele) {
this(id, Versionable.unknownVersion(), name, adresse, emailAdresse, kinoSaele);
}
public Kino(final Id id, final Version version,
final Name name, final Adresse adresse,
final EmailAdresse emailAdresse, final Set<KinoSaal> kinoSaele) {
this.id = id;
this.version = version;
this.name = name;
this.adresse = adresse;
this.emailAdresse = emailAdresse;
this.kinoSaele = kinoSaele;
}
@Override
public Id id() {
return id;
}
@Override
public Version version() {
return version;
}
@Override
public Kino merge(final Kino newData) {
Map<Id, KinoSaal> mapIdToOldKinoSaal = new HashMap<>();
this.kinoSaele.forEach(oldKinoSaal -> {
mapIdToOldKinoSaal.put(oldKinoSaal.id(), oldKinoSaal);
});
Set<KinoSaal> mergedKinoSaele = newData.kinoSaele.stream().map(newKinoSaal -> {
KinoSaal oldKinoSaal = mapIdToOldKinoSaal.get(newKinoSaal.id);
if (oldKinoSaal != null) {
return oldKinoSaal.merge(newKinoSaal);
}
else {
return newKinoSaal;
}
})
.collect(Collectors.toSet());
Kino mergedKino = new Kino(this.id, this.version,
newData.name, newData.adresse, newData.emailAdresse, mergedKinoSaele);
mergedKinoSaele.forEach(kinoSaal -> kinoSaal.kino = mergedKino);
return mergedKino;
}
public void addSaele(Collection<KinoSaal> saele) {
kinoSaele.addAll(saele);
}
@Override
public String toString() {
return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE);
}
@Override
public boolean equals(final Object o) {
if (!equalsByContent(o)) return false;
if (this == o) {return true;}
if (o == null || getClass() != o.getClass()) {return false;}
Kino that = (Kino) o;
return new EqualsBuilder().append(version, that.version).isEquals();
}
@SuppressWarnings("ConstantValue")
@Override
public boolean equalsByContent(final Object o) {
if (this == o) {return true;}
if (o == null || getClass() != o.getClass()) {return false;}
Kino that = (Kino) o;
boolean result = new EqualsBuilder()
.append(id, that.id)
.append(name, that.name)
.append(adresse, that.adresse).append(emailAdresse, that.emailAdresse)
.isEquals();
if (!result) return false;
if (kinoSaele == null && that.kinoSaele == null) return true;
if (kinoSaele == null && that.kinoSaele != null) return false;
if (kinoSaele != null && that.kinoSaele == null) return false;
List<KinoSaal> thisKSList = kinoSaele.stream().toList();
List<KinoSaal> thatKSList = that.kinoSaele.stream().toList();
if (thisKSList.size() != thatKSList.size()) return false;
for (int counter = 0; counter < thisKSList.size(); counter++) {
if (!thisKSList.get(counter).equalsByContent(thatKSList.get(counter))) return false;
}
return true;
}
@Override
public int hashCode() {
return new HashCodeBuilder(17, 37)
.append(id).append(version)
.append(name).append(adresse).append(emailAdresse)
.append(kinoSaele.stream().toList()) // need to use list, as Set does not support deep equals
.toHashCode();
}
}

118
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/domain/model/KinoSaal.java Normal file
View file

@ -0,0 +1,118 @@
package de.accso.flexinale.backoffice.domain.model;
import com.fasterxml.jackson.annotation.JsonIgnore;
import de.accso.flexinale.common.shared_kernel.*;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
public class KinoSaal implements Identifiable, Versionable, Mergeable<KinoSaal>, EqualsByContent {
public record Name(String raw) implements RawWrapper<String> {}
public record AnzahlPlaetze(Integer raw) implements RawWrapper<Integer> {}
public final Id id;
public final Version version;
public Name name;
public AnzahlPlaetze anzahlPlaetze = new KinoSaal.AnzahlPlaetze(0);
@JsonIgnore
@DoNotCheckInArchitectureTests
public Kino kino;
public KinoSaal(final Id id) {
this(id, Versionable.unknownVersion());
}
public KinoSaal(final Id id, final Version version) {
this.id = id;
this.version = version;
}
public KinoSaal(final Id id,
final Name name, final AnzahlPlaetze anzahlPlaetze, final Kino kino) {
this(id, Versionable.unknownVersion(), name, anzahlPlaetze, kino);
}
public KinoSaal(final Id id, final Version version,
final Name name, final AnzahlPlaetze anzahlPlaetze, final Kino kino) {
this.id = id;
this.version = version;
this.name = name;
this.anzahlPlaetze = anzahlPlaetze;
this.kino = kino;
}
@Override
public Id id() {
return id;
}
@Override
public Version version() {
return version;
}
@Override
public KinoSaal merge(final KinoSaal newData) {
return new KinoSaal(this.id,
newData.name, newData.anzahlPlaetze,
/* needs to be corrected outside */ null);
}
@Override
public String toString() {
return "KinoSaal{" +
"id='" + id + '\'' +
", version=" + version +
", name='" + name + '\'' +
", anzahlPlaetze=" + anzahlPlaetze +
(kino != null ? ", kino.id=" + kino.id : ", kino=null") +
'}';
}
@Override
public boolean equals(final Object o) {
if (!equalsByContent(o)) return false;
if (this == o) {return true;}
if (o == null || getClass() != o.getClass()) {return false;}
KinoSaal that = (KinoSaal) o;
return new EqualsBuilder().append(version, that.version).isEquals();
}
@SuppressWarnings("ConstantValue")
@Override
public boolean equalsByContent(final Object o) {
if (this == o) {return true;}
if (o == null || getClass() != o.getClass()) {return false;}
KinoSaal that = (KinoSaal) o;
boolean result = new EqualsBuilder()
.append(id, that.id)
.append(name, that.name)
.append(anzahlPlaetze, that.anzahlPlaetze).
isEquals();
if (!result) return false;
if (kino == null && that.kino == null) return true;
if (kino == null && that.kino != null) return false;
if (kino != null) {
result = kino.id.equals(that.kino.id); // do not check kino but only its id (otherwise Stackoverflow error)
}
return result;
}
@Override
public int hashCode() {
HashCodeBuilder builder = new HashCodeBuilder(17, 37)
.append(id).append(version)
.append(name).append(anzahlPlaetze);
if (kino != null) {
builder.append(kino.id); // do not use kino but only its id (otherwise Stackoverflow error)
}
return builder.toHashCode();
}
}

141
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/domain/model/Vorfuehrung.java Normal file
View file

@ -0,0 +1,141 @@
package de.accso.flexinale.backoffice.domain.model;
import de.accso.flexinale.common.shared_kernel.*;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import java.time.LocalDateTime;
import java.util.Optional;
public final class Vorfuehrung implements Identifiable, Versionable, Mergeable<Vorfuehrung>, EqualsByContent { // TODO is only final as otherwise Spotbugs complains, get rid of Exception in constructor!
public record Zeit(LocalDateTime raw) implements RawWrapper<LocalDateTime> {
public Zeit(LocalDateTime raw) {
this.raw = raw.withNano(0); // precision is second
}
}
public final Id id;
public final Version version;
public final Zeit zeit;
@DoNotCheckInArchitectureTests
public final Film film;
@DoNotCheckInArchitectureTests
public final KinoSaal kinoSaal;
public Vorfuehrung(final Id id,
final Zeit zeit,
final Film film,
final KinoSaal kinoSaal) {
this(id, Versionable.unknownVersion(), zeit, film, kinoSaal);
}
public Vorfuehrung(final Id id, final Version version,
final Zeit zeit,
final Film film,
final KinoSaal kinoSaal) {
this.id = id;
this.version = version;
this.zeit = zeit;
this.film = film;
this.kinoSaal = kinoSaal;
//TODO this validation should not be done here. If class is not final, Spotbugs complains. For DB entities use "nullable=false" and "optional=false" for DB checks. In domain classes check with jakarta.annotation NonNull? Also: Why is KinoSaal obligatory but not Film?
if (kinoSaal == null) {
throw new FlexinaleIllegalArgumentException("KinoSaal of Vorfuehrung " + this +
" must not be null");
}
//TODO this validation should not be done here but in KinoSaal itself
if (kinoSaal.anzahlPlaetze == null) {
throw new FlexinaleIllegalArgumentException("KinoSaal's Anzahl Plaetze of Vorfuehrung " + this +
" must not be null");
}
}
@Override
public Id id() {
return id;
}
@Override
public Version version() {
return version;
}
@Override
public Vorfuehrung merge(final Vorfuehrung newData) {
// merging Vorfuehrung has some business flaws - like when its film or its kinoSaal is changed,
// then all sold tickets might get obsolete - we ignore this here but care for that in Ticketing
Film mergedFilm = this.film.merge(newData.film);
Kino mergedKino = this.kinoSaal.kino.merge(newData.kinoSaal.kino);
Optional<KinoSaal> mergedKinoSaal = mergedKino.kinoSaele.stream().filter(
kinoSaal -> kinoSaal.id.equals(this.kinoSaal.id)).findFirst();
if (mergedKinoSaal.isEmpty()) {
throw new DeveloperMistakeException("merged KinoSaal from Vorfuehrung could not be retrieved");
}
return new Vorfuehrung(this.id, this.version,
newData.zeit, mergedFilm, mergedKinoSaal.get());
}
@Override
public String toString() {
return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE);
}
@Override
public boolean equals(final Object o) {
if (!equalsByContent(o)) return false;
if (this == o) {return true;}
if (o == null || getClass() != o.getClass()) {return false;}
Vorfuehrung that = (Vorfuehrung) o;
return new EqualsBuilder().append(version, that.version).isEquals();
}
@SuppressWarnings({"UnusedAssignment", "DataFlowIssue"})
@Override
public boolean equalsByContent(final Object o) {
if (this == o) {return true;}
if (o == null || getClass() != o.getClass()) {return false;}
Vorfuehrung that = (Vorfuehrung) o;
boolean result = new EqualsBuilder()
.append(id, that.id)
.append(zeit, that.zeit)
.isEquals();
if (!result) return false;
if (film == null && that.film == null) result = true;
if (film == null && that.film != null) return false;
if (film != null) {
result = film.equalsByContent(that.film);
if (!result) return false;
}
if (kinoSaal == null && that.kinoSaal == null) result = true;
if (kinoSaal == null && that.kinoSaal != null) return false;
if (kinoSaal != null) {
result = kinoSaal.equalsByContent(that.kinoSaal);
return result;
}
return true;
}
@Override
public int hashCode() {
return new HashCodeBuilder(17, 37)
.append(id).append(version)
.append(zeit)
.append(film)
.append(kinoSaal)
.toHashCode();
}
}

24
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/domain/services/FilmService.java Normal file
View file

@ -0,0 +1,24 @@
package de.accso.flexinale.backoffice.domain.services;
import de.accso.flexinale.backoffice.domain.dao.FilmDao;
import de.accso.flexinale.backoffice.domain.model.Film;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import java.util.List;
public class FilmService {
private final FilmDao filmDao;
public FilmService(final FilmDao filmDao) {
this.filmDao = filmDao;
}
public List<Film> filme() {
return filmDao.findAll();
}
public Film film(final Identifiable.Id id) {
return filmDao.findById(id).orElse(null);
}
}

24
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/domain/services/KinoService.java Normal file
View file

@ -0,0 +1,24 @@
package de.accso.flexinale.backoffice.domain.services;
import de.accso.flexinale.backoffice.domain.dao.KinoDao;
import de.accso.flexinale.backoffice.domain.model.Kino;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import java.util.List;
public class KinoService {
private final KinoDao kinoDao;
public KinoService(final KinoDao kinoDao) {
this.kinoDao = kinoDao;
}
public List<Kino> kinos() {
return kinoDao.findAll();
}
public Kino kino(final Identifiable.Id id) {
return kinoDao.findById(id).orElse(null);
}
}

24
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/domain/services/VorfuehrungService.java Normal file
View file

@ -0,0 +1,24 @@
package de.accso.flexinale.backoffice.domain.services;
import de.accso.flexinale.backoffice.domain.dao.VorfuehrungDao;
import de.accso.flexinale.backoffice.domain.model.Vorfuehrung;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import java.util.List;
public class VorfuehrungService {
private final VorfuehrungDao vorfuehrungDao;
public VorfuehrungService(final VorfuehrungDao vorfuehrungDao) {
this.vorfuehrungDao = vorfuehrungDao;
}
public List<Vorfuehrung> vorfuehrungen() {
return vorfuehrungDao.findAll();
}
public Vorfuehrung vorfuehrung(final Identifiable.Id id) {
return vorfuehrungDao.findById(id).orElse(null);
}
}

34
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/FlexinaleBackofficeActuatorEndpointEventsPublished.java Normal file
View file

@ -0,0 +1,34 @@
package de.accso.flexinale.backoffice.infrastructure;
import de.accso.flexinale.common.api.eventbus.EventNotification;
import de.accso.flexinale.common.api.event.Event;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
import org.springframework.boot.actuate.endpoint.annotation.ReadOperation;
import org.springframework.boot.actuate.endpoint.annotation.Selector;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
@Component
@Endpoint(id = "backofficeEventsPublished")
public class FlexinaleBackofficeActuatorEndpointEventsPublished implements EventNotification {
private final Queue<Event> eventsPublished = new ConcurrentLinkedQueue<>(); // event list is ordered by production time
@ReadOperation
public List<Event> eventsPublished() {
return eventsPublished.stream().toList();
}
@ReadOperation
public List<Event> eventsPublishedFilteredBy(@Selector Identifiable.Id correlationId) {
return eventsPublished.stream().filter(event -> event.correlationId().equals(correlationId)).toList();
}
@Override
public void notify(final Event event) {// might want to use a generic subscriber
eventsPublished.add(event);
}
}

137
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/FlexinaleBackofficeSpringFactory.java Normal file
View file

@ -0,0 +1,137 @@
package de.accso.flexinale.backoffice.infrastructure;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import de.accso.flexinale.backoffice.api_out.event.FilmPublisher;
import de.accso.flexinale.backoffice.api_out.event.KinoPublisher;
import de.accso.flexinale.backoffice.api_out.event.VorfuehrungPublisher;
import de.accso.flexinale.backoffice.application.services.FilmService;
import de.accso.flexinale.backoffice.application.services.KinoService;
import de.accso.flexinale.backoffice.application.services.VorfuehrungService;
import de.accso.flexinale.backoffice.application.services.FilmUploadService;
import de.accso.flexinale.backoffice.application.services.KinoUploadService;
import de.accso.flexinale.backoffice.application.services.KinoSaalUploadService;
import de.accso.flexinale.backoffice.application.services.VorfuehrungUploadService;
import de.accso.flexinale.backoffice.domain.dao.FilmDao;
import de.accso.flexinale.backoffice.domain.dao.KinoDao;
import de.accso.flexinale.backoffice.domain.dao.KinoSaalDao;
import de.accso.flexinale.backoffice.domain.dao.VorfuehrungDao;
import de.accso.flexinale.backoffice.infrastructure.persistence.*;
import de.accso.flexinale.common.api.eventbus.EventBusFactory;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration
@Profile({ "!testdata-besucherportal & !testdata-ticketing" })
@EnableJpaRepositories({"de.accso.flexinale.backoffice.infrastructure.persistence"})
@EnableTransactionManagement
@EntityScan(basePackages={"de.accso.flexinale.backoffice.infrastructure.persistence"})
public class FlexinaleBackofficeSpringFactory {
@Bean
public FilmService createApplicationFilmService(final de.accso.flexinale.backoffice.domain.services.FilmService filmService) {
return new FilmService(filmService);
}
@Bean
public de.accso.flexinale.backoffice.domain.services.FilmService createBackofficeFilmService(final FilmDao filmDao) {
return new de.accso.flexinale.backoffice.domain.services.FilmService(filmDao);
}
@Bean
public FilmUploadService createBackofficeFilmUploadService(final FilmDao filmDao) {
return new FilmUploadService(filmDao);
}
@Bean
public FilmDao createBackofficeFilmDao(final FilmJpaRepository filmJpaRepository) {
return new FilmJpaRepositoryDelegate(filmJpaRepository);
}
@Bean
public FilmPublisher createBackofficeFilmPublisher(final EventBusFactory eventBusFactory,
final FlexinaleBackofficeActuatorEndpointEventsPublished endpointEventsPublished) {
return new FilmPublisher(eventBusFactory, endpointEventsPublished);
}
// ------------------------------------------------------------------------------------------------
@Bean
public KinoService createApplicationKinoService(final de.accso.flexinale.backoffice.domain.services.KinoService kinoService) {
return new KinoService(kinoService);
}
@Bean
public de.accso.flexinale.backoffice.domain.services.KinoService createBackofficeKinoService(final KinoDao KinoDao) {
return new de.accso.flexinale.backoffice.domain.services.KinoService(KinoDao);
}
@Bean
public KinoUploadService createBackofficeKinoUploadService(final KinoDao kinoDao) {
return new KinoUploadService(kinoDao);
}
@Bean
public KinoSaalUploadService createBackofficeKinoSaalUploadService(final KinoSaalDao kinoSaalDao) {
return new KinoSaalUploadService(kinoSaalDao);
}
@Bean
public KinoDao createBackofficeKinoDao(final KinoJpaRepository kinoJpaRepository) {
return new KinoJpaRepositoryDelegate(kinoJpaRepository);
}
@Bean
public KinoSaalDao createBackofficeKinoSaalDao(final KinoSaalJpaRepository kinoSaalJpaRepository) {
return new KinoSaalJpaRepositoryDelegate(kinoSaalJpaRepository);
}
@Bean
public KinoPublisher createBackofficeKinoPublisher(final EventBusFactory eventBusFactory,
final FlexinaleBackofficeActuatorEndpointEventsPublished endpointEventsPublished) {
return new KinoPublisher(eventBusFactory, endpointEventsPublished);
}
// ------------------------------------------------------------------------------------------------
@Bean
public VorfuehrungService createApplicationVorfuehrungService(final de.accso.flexinale.backoffice.domain.services.VorfuehrungService vorfuehrungService) {
return new VorfuehrungService(vorfuehrungService);
}
@Bean
public de.accso.flexinale.backoffice.domain.services.VorfuehrungService createBackofficeVorfuehrungService(final VorfuehrungDao vorfuehrungDao) {
return new de.accso.flexinale.backoffice.domain.services.VorfuehrungService(vorfuehrungDao);
}
@Bean
public VorfuehrungUploadService createBackofficeVorfuehrungUploadService(final VorfuehrungDao vorfuehrungDao,
final FilmDao filmDao,
final KinoSaalDao kinoSaalDao) {
return new VorfuehrungUploadService(vorfuehrungDao, filmDao, kinoSaalDao);
}
@Bean
public VorfuehrungDao createBackofficeVorfuehrungDao(final VorfuehrungJpaRepository vorfuehrungJpaRepository) {
return new VorfuehrungJpaRepositoryDelegate(vorfuehrungJpaRepository);
}
@Bean
public VorfuehrungPublisher createBackofficeVorfuehrungPublisher(final EventBusFactory eventBusFactory,
final FlexinaleBackofficeActuatorEndpointEventsPublished endpointEventsPublished) {
return new VorfuehrungPublisher(eventBusFactory, endpointEventsPublished);
}
// ------------------------------------------------------------------------------------------------
// Actuator Event serialization
@Bean
public Jackson2ObjectMapperBuilderCustomizer jsonBackofficeCustomizer() {
return builder -> builder.visibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
}
}

78
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/FilmEntity.java Normal file
View file

@ -0,0 +1,78 @@
package de.accso.flexinale.backoffice.infrastructure.persistence;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import de.accso.flexinale.common.shared_kernel.Versionable;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import java.io.Serializable;
@jakarta.persistence.Entity(name = "Film")
public class FilmEntity implements Identifiable, Versionable, Serializable {
@jakarta.persistence.Id
public String id; // primary key
@jakarta.persistence.Column
public String titel;
@jakarta.persistence.Column
public String imdbUrl;
@jakarta.persistence.Column
public Integer dauerInMinuten;
@jakarta.persistence.Version
private Integer version = 0;
protected FilmEntity() {
}
public FilmEntity(final String id, final Integer version,
final String titel, final String imdbUrl, final Integer dauerInMinuten) {
this.id = id;
this.version = version;
this.titel = titel;
this.imdbUrl = imdbUrl;
this.dauerInMinuten = dauerInMinuten;
}
@Override
public Id id() {
return Identifiable.Id.of(id);
}
@Override
public Version version() {
return Versionable.Version.of(version);
}
@Override
public String toString() {
return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE);
}
@Override
public boolean equals(final Object o) {
if (this == o) {return true;}
if (o == null || getClass() != o.getClass()) {return false;}
FilmEntity that = (FilmEntity) o;
return new EqualsBuilder()
.append(id, that.id).append(version, that.version)
.append(titel, that.titel)
.append(imdbUrl, that.imdbUrl)
.append(dauerInMinuten, that.dauerInMinuten)
.isEquals();
}
@Override
public int hashCode() {
return new HashCodeBuilder(17, 37)
.append(id).append(version)
.append(titel).append(imdbUrl).append(dauerInMinuten).toHashCode();
}
}

8
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/FilmJpaRepository.java Normal file
View file

@ -0,0 +1,8 @@
package de.accso.flexinale.backoffice.infrastructure.persistence;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface FilmJpaRepository extends JpaRepository<FilmEntity, String> {
}

59
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/FilmJpaRepositoryDelegate.java Normal file
View file

@ -0,0 +1,59 @@
package de.accso.flexinale.backoffice.infrastructure.persistence;
import de.accso.flexinale.backoffice.domain.dao.FilmDao;
import de.accso.flexinale.backoffice.domain.model.Film;
import de.accso.flexinale.backoffice.infrastructure.persistence.mapper.FilmEntity2FilmMapper;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
@SuppressWarnings("unused")
public class FilmJpaRepositoryDelegate implements FilmDao {
private final FilmJpaRepository filmJpaRepository;
public FilmJpaRepositoryDelegate(final FilmJpaRepository filmJpaRepository) {
this.filmJpaRepository = filmJpaRepository;
}
@Override
public List<Film> findAll() {
List<FilmEntity> filmEntities = filmJpaRepository.findAll();
return filmEntities.stream()
.map(FilmEntity2FilmMapper::map)
.collect(Collectors.toCollection(ArrayList::new));
}
@Override
public Optional<Film> findById(final Identifiable.Id id) {
Optional<FilmEntity> filmEntity = filmJpaRepository.findById(id.id());
return FilmEntity2FilmMapper.map(filmEntity);
}
@Override
public Film save(final Film film) {
FilmEntity filmEntity = FilmEntity2FilmMapper.map(film);
FilmEntity savedEntity = filmJpaRepository.save(filmEntity);
return FilmEntity2FilmMapper.map(savedEntity);
}
@Override
public void delete(final Film film) {
FilmEntity filmEntity = FilmEntity2FilmMapper.map(film);
filmJpaRepository.delete(filmEntity);
}
@Override
public void deleteById(final Identifiable.Id id) {
filmJpaRepository.deleteById(id.id());
}
@Override
public void deleteAll() {
filmJpaRepository.deleteAll();
}
}

89
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/KinoEntity.java Normal file
View file

@ -0,0 +1,89 @@
package de.accso.flexinale.backoffice.infrastructure.persistence;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import de.accso.flexinale.common.shared_kernel.Versionable;
import jakarta.persistence.CascadeType;
import jakarta.persistence.FetchType;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
@jakarta.persistence.Entity(name = "Kino")
public class KinoEntity implements Identifiable, Versionable, Serializable {
@jakarta.persistence.Id
public String id; // primary key
@jakarta.persistence.Column
public String name;
@jakarta.persistence.Column
public String adresse;
@jakarta.persistence.Column
public String emailAdresse;
@jakarta.persistence.Version
private Integer version = 0;
@jakarta.persistence.OneToMany(mappedBy = "kino", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
public Set<KinoSaalEntity> kinoSaele = new HashSet<>();
protected KinoEntity() {
}
public KinoEntity(final String id, final Integer version,
final String name, final String adresse, final String emailAdresse) {
this.id = id;
this.version = version;
this.name = name;
this.adresse = adresse;
this.emailAdresse = emailAdresse;
}
@Override
public Id id() {
return Identifiable.Id.of(id);
}
@Override
public Version version() {
return Versionable.Version.of(version);
}
@Override
public String toString() {
return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE);
}
@Override
public boolean equals(final Object o) {
if (this == o) {return true;}
if (o == null || getClass() != o.getClass()) {return false;}
KinoEntity that = (KinoEntity) o;
return new EqualsBuilder()
.append(id, that.id).append(version, that.version)
.append(name, that.name)
.append(adresse, that.adresse)
.append(emailAdresse, that.emailAdresse)
.append(kinoSaele.stream().toList(), that.kinoSaele.stream().toList()) // need to use list, as Set does not support deep equals
.isEquals();
}
@Override
public int hashCode() {
return new HashCodeBuilder(17, 37)
.append(id).append(version)
.append(name).append(adresse)
.append(emailAdresse)
.append(kinoSaele.stream().toList()) // need to use list, as Set does not support deep equals
.toHashCode();
}
}

8
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/KinoJpaRepository.java Normal file
View file

@ -0,0 +1,8 @@
package de.accso.flexinale.backoffice.infrastructure.persistence;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface KinoJpaRepository extends JpaRepository<KinoEntity, String> {
}

59
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/KinoJpaRepositoryDelegate.java Normal file
View file

@ -0,0 +1,59 @@
package de.accso.flexinale.backoffice.infrastructure.persistence;
import de.accso.flexinale.backoffice.domain.dao.KinoDao;
import de.accso.flexinale.backoffice.domain.model.Kino;
import de.accso.flexinale.backoffice.infrastructure.persistence.mapper.KinoKinoSaalEntity2KinoKinoSaalMapper;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
@SuppressWarnings("unused")
public class KinoJpaRepositoryDelegate implements KinoDao {
private final KinoJpaRepository kinoJpaRepository;
public KinoJpaRepositoryDelegate(final KinoJpaRepository KinoJpaRepository) {
this.kinoJpaRepository = KinoJpaRepository;
}
@Override
public List<Kino> findAll() {
List<KinoEntity> kinoEntities = kinoJpaRepository.findAll();
return kinoEntities.stream()
.map(KinoKinoSaalEntity2KinoKinoSaalMapper::mapKino)
.collect(Collectors.toCollection(ArrayList::new));
}
@Override
public Optional<Kino> findById(final Identifiable.Id id) {
Optional<KinoEntity> kinoEntity = kinoJpaRepository.findById(id.id());
return KinoKinoSaalEntity2KinoKinoSaalMapper.mapKino(kinoEntity);
}
@Override
public Kino save(final Kino kino) {
KinoEntity kinoEntity = KinoKinoSaalEntity2KinoKinoSaalMapper.mapKino(kino);
KinoEntity savedEntity = kinoJpaRepository.save(kinoEntity);
return KinoKinoSaalEntity2KinoKinoSaalMapper.mapKino(savedEntity);
}
@Override
public void delete(final Kino kino) {
KinoEntity kinoEntity = KinoKinoSaalEntity2KinoKinoSaalMapper.mapKino(kino);
kinoJpaRepository.delete(kinoEntity);
}
@Override
public void deleteById(final Identifiable.Id id) {
kinoJpaRepository.deleteById(id.id());
}
@Override
public void deleteAll() {
kinoJpaRepository.deleteAll();
}
}

88
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/KinoSaalEntity.java Normal file
View file

@ -0,0 +1,88 @@
package de.accso.flexinale.backoffice.infrastructure.persistence;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import de.accso.flexinale.common.shared_kernel.Versionable;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import java.io.Serializable;
@jakarta.persistence.Entity(name = "KinoSaal")
public class KinoSaalEntity implements Identifiable, Versionable, Serializable {
@jakarta.persistence.Id
public String id; // primary key
@jakarta.persistence.Column
public String name;
@jakarta.persistence.Column
public Integer anzahlPlaetze = 0;
@jakarta.persistence.ManyToOne
@jakarta.persistence.JoinColumn(name = "kino", nullable = false)
public KinoEntity kino;
@jakarta.persistence.Version
private Integer version = 0;
protected KinoSaalEntity() {
}
public KinoSaalEntity(final String id, final Integer version,
final String name, final Integer anzahlPlaetze, final KinoEntity kino) {
this.id = id;
this.version = version;
this.name = name;
this.anzahlPlaetze = anzahlPlaetze;
this.kino = kino;
}
@Override
public Id id() {
return Identifiable.Id.of(id);
}
@Override
public Version version() {
return Versionable.Version.of(version);
}
@Override
public String toString() {
return "KinoSaalEntity{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", anzahlPlaetze=" + anzahlPlaetze +
(kino != null ? ", kino.id=" + kino.id : ", kino=null") +
", version=" + version +
'}';
}
@Override
public boolean equals(final Object o) {
if (this == o) {return true;}
if (o == null || getClass() != o.getClass()) {return false;}
KinoSaalEntity that = (KinoSaalEntity) o;
EqualsBuilder builder = new EqualsBuilder()
.append(id, that.id).append(version, that.version)
.append(name, that.name).append(anzahlPlaetze, that.anzahlPlaetze);
if (kino != null) {
builder.append(kino.id, that.kino.id); // do not check kino but only its id (otherwise Stackoverflow error)
}
return builder.isEquals();
}
@Override
public int hashCode() {
HashCodeBuilder builder = new HashCodeBuilder(17, 37)
.append(id).append(version)
.append(name).append(anzahlPlaetze);
if (kino != null) {
builder.append(kino.id); // do not check kino but only its id (otherwise Stackoverflow error)
}
return builder.toHashCode();
}
}

8
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/KinoSaalJpaRepository.java Normal file
View file

@ -0,0 +1,8 @@
package de.accso.flexinale.backoffice.infrastructure.persistence;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface KinoSaalJpaRepository extends JpaRepository<KinoSaalEntity, String> {
}

58
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/KinoSaalJpaRepositoryDelegate.java Normal file
View file

@ -0,0 +1,58 @@
package de.accso.flexinale.backoffice.infrastructure.persistence;
import de.accso.flexinale.backoffice.domain.dao.KinoSaalDao;
import de.accso.flexinale.backoffice.domain.model.KinoSaal;
import de.accso.flexinale.backoffice.infrastructure.persistence.mapper.KinoKinoSaalEntity2KinoKinoSaalMapper;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
@SuppressWarnings("unused")
public class KinoSaalJpaRepositoryDelegate implements KinoSaalDao {
private final KinoSaalJpaRepository kinoSaalJpaRepository;
public KinoSaalJpaRepositoryDelegate(final KinoSaalJpaRepository kinoSaalJpaRepository) {
this.kinoSaalJpaRepository = kinoSaalJpaRepository;
}
@Override
public List<KinoSaal> findAll() {
List<KinoSaalEntity> kinoSaalEntities = kinoSaalJpaRepository.findAll();
return kinoSaalEntities.stream()
.map(KinoKinoSaalEntity2KinoKinoSaalMapper::mapKinoSaal)
.collect(Collectors.toList());
}
@Override
public Optional<KinoSaal> findById(final Identifiable.Id id) {
Optional<KinoSaalEntity> kinoSaalEntity = kinoSaalJpaRepository.findById(id.id());
return KinoKinoSaalEntity2KinoKinoSaalMapper.mapToKinoSaal(kinoSaalEntity);
}
@Override
public KinoSaal save(final KinoSaal kinoSaal) {
KinoSaalEntity kinoSaalEntity = KinoKinoSaalEntity2KinoKinoSaalMapper.mapKinoSaal(kinoSaal);
KinoSaalEntity savedEntity = kinoSaalJpaRepository.save(kinoSaalEntity);
return KinoKinoSaalEntity2KinoKinoSaalMapper.mapKinoSaal(savedEntity);
}
@Override
public void delete(final KinoSaal kinoSaal) {
KinoSaalEntity kinoSaalEntity = KinoKinoSaalEntity2KinoKinoSaalMapper.mapKinoSaal(kinoSaal);
kinoSaalJpaRepository.delete(kinoSaalEntity);
}
@Override
public void deleteById(final Identifiable.Id id) {
kinoSaalJpaRepository.deleteById(id.id());
}
@Override
public void deleteAll() {
kinoSaalJpaRepository.deleteAll();
}
}

96
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/VorfuehrungEntity.java Normal file
View file

@ -0,0 +1,96 @@
package de.accso.flexinale.backoffice.infrastructure.persistence;
import de.accso.flexinale.common.shared_kernel.DateTimeHelper;
import de.accso.flexinale.common.shared_kernel.FlexinaleIllegalArgumentException;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import de.accso.flexinale.common.shared_kernel.Versionable;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import java.io.Serializable;
import java.time.LocalDateTime;
@jakarta.persistence.Entity(name = "Vorfuehrung")
public final class VorfuehrungEntity implements Identifiable, Versionable, Serializable { // TODO is only final as otherwise Spotbugs complains, get rid of Exception in constructor!
@jakarta.persistence.Id
public String id; // primary key
@jakarta.persistence.Column
public Long zeit; // save EPOCH seconds instead of Date/Time (Timezone is UTC)
@jakarta.persistence.ManyToOne
public FilmEntity film;
@jakarta.persistence.ManyToOne
public KinoSaalEntity kinoSaal;
@jakarta.persistence.Version
private Integer version = 0;
protected VorfuehrungEntity() {
}
public VorfuehrungEntity(final String id, final Integer version,
final LocalDateTime zeit,
final FilmEntity film,
final KinoSaalEntity kinoSaal) {
this.id = id;
this.version = version;
this.zeit = DateTimeHelper.toEpochSeconds(zeit);
this.film = film;
this.kinoSaal = kinoSaal;
//TODO this validation should not be done here. If class is not final, Spotbugs complains. For DB entities use "nullable=false" and "optional=false" for DB checks. In domain classes check with jakarta.annotation NonNull? Also: Why is KinoSaal obligatory but not Film?
if (kinoSaal == null) {
throw new FlexinaleIllegalArgumentException("KinoSaal of Vorfuehrung " + this +
" must not be null");
}
//TODO this validation should not be done here but in KinoSaal itself
if (kinoSaal.anzahlPlaetze == null) {
throw new FlexinaleIllegalArgumentException("KinoSaal's Anzahl Plaetze of Vorfuehrung " + this +
" must not be null");
}
}
@Override
public Id id() {
return Identifiable.Id.of(id);
}
@Override
public Version version() {
return Versionable.Version.of(version);
}
@Override
public String toString() {
return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE);
}
@Override
public boolean equals(final Object o) {
if (this == o) {return true;}
if (o == null || getClass() != o.getClass()) {return false;}
VorfuehrungEntity that = (VorfuehrungEntity) o;
return new EqualsBuilder()
.append(id, that.id).append(version, that.version)
.append(zeit, that.zeit)
.append(film, that.film).append(kinoSaal, that.kinoSaal)
.isEquals();
}
@Override
public int hashCode() {
return new HashCodeBuilder(17, 37)
.append(id).append(version)
.append(zeit).append(film).append(kinoSaal)
.toHashCode();
}
}

14
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/VorfuehrungJpaRepository.java Normal file
View file

@ -0,0 +1,14 @@
package de.accso.flexinale.backoffice.infrastructure.persistence;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface VorfuehrungJpaRepository extends JpaRepository<VorfuehrungEntity, String> {
@Query("SELECT v FROM Vorfuehrung v WHERE v.film.id = :filmId ORDER BY v.zeit")
List<VorfuehrungEntity> findByFilmId(final String filmId);
}

65
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/VorfuehrungJpaRepositoryDelegate.java Normal file
View file

@ -0,0 +1,65 @@
package de.accso.flexinale.backoffice.infrastructure.persistence;
import de.accso.flexinale.backoffice.domain.dao.VorfuehrungDao;
import de.accso.flexinale.backoffice.domain.model.Vorfuehrung;
import de.accso.flexinale.backoffice.infrastructure.persistence.mapper.VorfuehrungEntity2VorfuehrungMapper;
import de.accso.flexinale.common.shared_kernel.Identifiable;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
@SuppressWarnings("unused")
public class VorfuehrungJpaRepositoryDelegate implements VorfuehrungDao {
private final VorfuehrungJpaRepository vorfuehrungJpaRepository;
public VorfuehrungJpaRepositoryDelegate(final VorfuehrungJpaRepository vorfuehrungJpaRepository) {
this.vorfuehrungJpaRepository = vorfuehrungJpaRepository;
}
@Override
public List<Vorfuehrung> findAll() {
List<VorfuehrungEntity> vorfuehrungEntities = vorfuehrungJpaRepository.findAll();
return vorfuehrungEntities.stream()
.map(VorfuehrungEntity2VorfuehrungMapper::map)
.collect(Collectors.toCollection(ArrayList::new));
}
@Override
public Optional<Vorfuehrung> findById(final Identifiable.Id id) {
Optional<VorfuehrungEntity> vorfuehrungEntity = vorfuehrungJpaRepository.findById(id.id());
return VorfuehrungEntity2VorfuehrungMapper.map(vorfuehrungEntity);
}
@Override
public List<Vorfuehrung> findByFilmId(final Identifiable.Id filmId) {
List<VorfuehrungEntity> vorfuehrungEntities = vorfuehrungJpaRepository.findByFilmId(filmId.id());
return VorfuehrungEntity2VorfuehrungMapper.map(vorfuehrungEntities);
}
@Override
public Vorfuehrung save(final Vorfuehrung vorfuehrung) {
VorfuehrungEntity vorfuehrungEntity = VorfuehrungEntity2VorfuehrungMapper.map(vorfuehrung);
VorfuehrungEntity savedEntity = vorfuehrungJpaRepository.save(vorfuehrungEntity);
return VorfuehrungEntity2VorfuehrungMapper.map(savedEntity);
}
@Override
public void delete(final Vorfuehrung vorfuehrung) {
VorfuehrungEntity vorfuehrungEntity = VorfuehrungEntity2VorfuehrungMapper.map(vorfuehrung);
vorfuehrungJpaRepository.delete(vorfuehrungEntity);
}
@Override
public void deleteById(final Identifiable.Id id) {
vorfuehrungJpaRepository.deleteById(id.id());
}
@Override
public void deleteAll() {
vorfuehrungJpaRepository.deleteAll();
}
}

33
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/mapper/FilmEntity2FilmMapper.java Normal file
View file

@ -0,0 +1,33 @@
package de.accso.flexinale.backoffice.infrastructure.persistence.mapper;
import de.accso.flexinale.backoffice.domain.model.Film;
import de.accso.flexinale.backoffice.infrastructure.persistence.FilmEntity;
import java.util.Optional;
import static de.accso.flexinale.common.shared_kernel.RawWrapper.getRawOrNull;
public final class FilmEntity2FilmMapper {
public static Film map(final FilmEntity filmEntity) {
return new Film(filmEntity.id(), filmEntity.version(),
new Film.Titel(filmEntity.titel), new Film.ImdbUrl(filmEntity.imdbUrl),
new Film.DauerInMinuten(filmEntity.dauerInMinuten));
}
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
public static Optional<Film> map(final Optional<FilmEntity> optionalFilmEntity) {
if (optionalFilmEntity.isEmpty()) {
return Optional.empty();
}
else {
FilmEntity filmEntity = optionalFilmEntity.get();
return Optional.of(map(filmEntity));
}
}
public static FilmEntity map(final Film film) {
return new FilmEntity(film.id().id(), film.version().version(),
getRawOrNull(film.titel), getRawOrNull(film.imdbUrl), getRawOrNull(film.dauerInMinuten));
}
}

86
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/mapper/KinoKinoSaalEntity2KinoKinoSaalMapper.java Normal file
View file

@ -0,0 +1,86 @@
package de.accso.flexinale.backoffice.infrastructure.persistence.mapper;
import de.accso.flexinale.backoffice.domain.model.Kino;
import de.accso.flexinale.backoffice.domain.model.KinoSaal;
import de.accso.flexinale.backoffice.infrastructure.persistence.KinoEntity;
import de.accso.flexinale.backoffice.infrastructure.persistence.KinoSaalEntity;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import static de.accso.flexinale.common.shared_kernel.RawWrapper.getRawOrNull;
public final class KinoKinoSaalEntity2KinoKinoSaalMapper {
public static Kino mapKino(final KinoEntity kinoEntity) {
final Kino kino = new Kino(kinoEntity.id(), kinoEntity.version());
Set<KinoSaal> mappedKinoSaele = kinoEntity.kinoSaele.stream()
.map(kinoSaalEntity -> mapKinoSaal(kinoSaalEntity, kino))
.collect(Collectors.toCollection(HashSet::new));
kino.name = new Kino.Name(kinoEntity.name);
kino.adresse = new Kino.Adresse(kinoEntity.adresse);
kino.emailAdresse = new Kino.EmailAdresse(kinoEntity.emailAdresse);
kino.kinoSaele = mappedKinoSaele;
return kino;
}
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
public static Optional<Kino> mapKino(final Optional<KinoEntity> optionalKinoEntity) {
if (optionalKinoEntity.isEmpty()) {
return Optional.empty();
}
else {
KinoEntity kinoEntity = optionalKinoEntity.get();
return Optional.of(mapKino(kinoEntity));
}
}
public static KinoEntity mapKino(final Kino kino) {
final KinoEntity kinoEntity = new KinoEntity(kino.id().id(), kino.version().version(),
getRawOrNull(kino.name), getRawOrNull(kino.adresse), getRawOrNull(kino.emailAdresse));
kinoEntity.kinoSaele = kino.kinoSaele.stream()
.map(kinoSaal -> mapKinoSaal(kinoSaal, kinoEntity))
.collect(Collectors.toCollection(HashSet::new));
return kinoEntity;
}
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
public static Optional<KinoSaal> mapToKinoSaal(final Optional<KinoSaalEntity> kinoSaalEntity) {
return kinoSaalEntity.map(KinoKinoSaalEntity2KinoKinoSaalMapper::mapKinoSaal);
}
public static KinoSaal mapKinoSaal(KinoSaalEntity kinoSaalEntity) {
KinoEntity kinoEntity = kinoSaalEntity.kino;
Kino mappedKino = mapKino(kinoEntity);
return new KinoSaal(kinoSaalEntity.id(), kinoEntity.version(),
new KinoSaal.Name(kinoSaalEntity.name), new KinoSaal.AnzahlPlaetze(kinoSaalEntity.anzahlPlaetze), mappedKino);
}
private static KinoSaal mapKinoSaal(final KinoSaalEntity kinoSaalEntity, Kino kino) {
return new KinoSaal(kinoSaalEntity.id(), kinoSaalEntity.version(),
new KinoSaal.Name(kinoSaalEntity.name), new KinoSaal.AnzahlPlaetze(kinoSaalEntity.anzahlPlaetze), kino);
}
@SuppressWarnings({"OptionalUsedAsFieldOrParameterType", "unused"})
public static Optional<KinoSaalEntity> mapFromKinoSaal(final Optional<KinoSaal> kinoSaal) {
return kinoSaal.map(KinoKinoSaalEntity2KinoKinoSaalMapper::mapKinoSaal);
}
public static KinoSaalEntity mapKinoSaal(final KinoSaal kinoSaal) {
Kino kino = kinoSaal.kino;
KinoEntity mappedKino = mapKino(kino);
return new KinoSaalEntity(kinoSaal.id().id(), kinoSaal.version().version(),
getRawOrNull(kinoSaal.name), getRawOrNull(kinoSaal.anzahlPlaetze), mappedKino);
}
private static KinoSaalEntity mapKinoSaal(final KinoSaal kinoSaal, final KinoEntity kinoEntity) {
return new KinoSaalEntity(kinoSaal.id().id(), kinoEntity.version().version(),
getRawOrNull(kinoSaal.name), getRawOrNull(kinoSaal.anzahlPlaetze), kinoEntity);
}
}

52
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/java/de/accso/flexinale/backoffice/infrastructure/persistence/mapper/VorfuehrungEntity2VorfuehrungMapper.java Normal file
View file

@ -0,0 +1,52 @@
package de.accso.flexinale.backoffice.infrastructure.persistence.mapper;
import de.accso.flexinale.backoffice.domain.model.Film;
import de.accso.flexinale.backoffice.domain.model.KinoSaal;
import de.accso.flexinale.backoffice.domain.model.Vorfuehrung;
import de.accso.flexinale.backoffice.infrastructure.persistence.FilmEntity;
import de.accso.flexinale.backoffice.infrastructure.persistence.KinoSaalEntity;
import de.accso.flexinale.backoffice.infrastructure.persistence.VorfuehrungEntity;
import de.accso.flexinale.common.shared_kernel.DateTimeHelper;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import static de.accso.flexinale.common.shared_kernel.RawWrapper.getRawOrNull;
public class VorfuehrungEntity2VorfuehrungMapper {
public static Vorfuehrung map(final VorfuehrungEntity vorfuehrungEntity) {
Film mappedFilm = FilmEntity2FilmMapper.map(vorfuehrungEntity.film);
KinoSaal mappedKinoSaal = KinoKinoSaalEntity2KinoKinoSaalMapper.mapKinoSaal(vorfuehrungEntity.kinoSaal);
return new Vorfuehrung(vorfuehrungEntity.id(), vorfuehrungEntity.version(),
new Vorfuehrung.Zeit(DateTimeHelper.fromEpochSeconds(vorfuehrungEntity.zeit)),
mappedFilm, mappedKinoSaal);
}
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
public static Optional<Vorfuehrung> map(final Optional<VorfuehrungEntity> optionalVorfuehrungEntity) {
if (optionalVorfuehrungEntity.isEmpty()) {
return Optional.empty();
}
else {
VorfuehrungEntity vorfuehrungEntity = optionalVorfuehrungEntity.get();
return Optional.of(map(vorfuehrungEntity));
}
}
public static VorfuehrungEntity map(final Vorfuehrung vorfuehrung) {
FilmEntity mappedFilm = FilmEntity2FilmMapper.map(vorfuehrung.film);
KinoSaalEntity mappedKinoSaal = KinoKinoSaalEntity2KinoKinoSaalMapper.mapKinoSaal(vorfuehrung.kinoSaal);
return new VorfuehrungEntity(vorfuehrung.id().id(), vorfuehrung.version().version(),
getRawOrNull(vorfuehrung.zeit), mappedFilm, mappedKinoSaal);
}
public static List<Vorfuehrung> map(final List<VorfuehrungEntity> vorfuehrungEntities) {
return vorfuehrungEntities.stream().map(VorfuehrungEntity2VorfuehrungMapper::map)
.collect(Collectors.toCollection(ArrayList::new));
}
}

70
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/resources/application.properties Normal file
View file

@ -0,0 +1,70 @@
application.title=FLEXinale as Distributed Services, Backoffice
application.version=@pom.version@ @maven.build.timestamp@
spring.banner.location=classpath:/flexinale-banner.txt
#########################################################################
# For endpoint /version
#########################################################################
build.version=@pom.version@
build.date=@maven.build.timestamp@
#########################################################################
# Persistence
#########################################################################
spring.datasource.url=jdbc:postgresql://127.0.0.1:5432/distributed-backoffice
spring.datasource.name=flexinale
spring.datasource.username=flexinale
spring.datasource.password=flexinale
spring.datasource.driver-class-name=org.postgresql.Driver
spring.jpa.database=postgresql
spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect
spring.jpa.generate-ddl=true
# uses schema if existing (or creates anew)
# in a real production environment one should use 'validate' which does just validation but doesn't change anything
spring.jpa.hibernate.ddl-auto=update
# Pros and Cons: See https://www.baeldung.com/spring-open-session-in-view,
# https://stackoverflow.com/questions/30549489/what-is-this-spring-jpa-open-in-view-true-property-in-spring-boot
spring.jpa.open-in-view=false
# spring.jpa.show-sql=true
#########################################################################
# Web
#########################################################################
server.error.path=/error
server.error.include-stacktrace=always
server.error.include-exception=true
server.error.include-message=always
server.error.whitelabel.enabled=false
server.port=8081
#########################################################################
# Security
#########################################################################
security.enable-csrf=true
#########################################################################
# Kafka
#########################################################################
spring.kafka.consumer.group-id=flexinale-distributed-backoffice
# Spring Kafka Consumer
spring.kafka.consumer.bootstrap-servers=localhost:29092
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
# Spring Kafka Producer
spring.kafka.producer.bootstrap-servers=localhost:29092
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
#########################################################################
# Metrics endpoints, micrometer/prometheus/grafana
#########################################################################
# enable and expose
management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always
spring.jackson.serialization.FAIL_ON_EMPTY_BEANS=false
#########################################################################
# flexinale properties
#########################################################################

10
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/resources/flexinale-banner.txt Normal file
View file

@ -0,0 +1,10 @@
-------------------------------------------------------------------------
,------. ,--. ,------. ,--. ,--. ,--. ,--.
| .---' | | | .---' \ `.' / `--' ,--,--, ,--,--. | | ,---.
| `--, | | | `--, .' \ ,--. | \ ' ,-. | | | | .-. :
| |` | '--. | `---. / .'. \ | | | || | \ '-' | | | \ --.
`--' `-----' `------' '--' '--' `--' `--''--' `--`--' `--' `----'
${application.title} on port ${server.port}
(version ${application.version})
Powered by Spring Boot ${spring-boot.version}
-------------------------------------------------------------------------

20
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/resources/logback.xml Normal file
View file

@ -0,0 +1,20 @@
<configuration>
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{YYYYMMdd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<logger name="org.springframework.orm.jpa" level="INFO"/>
<logger name="org.springframework.boot.autoconfigure.domain.EntityScan" level="INFO"/>
<logger name="org.apache.kafka" level="WARN"/>
<logger name="org.apache.kafka.clients.admin.AdminClient" level="INFO"/>
<logger name="org.apache.kafka.clients.consumer.ConsumerConfig" level="INFO"/>
<logger name="org.apache.kafka.clients.producer.ProducerConfig" level="INFO"/>
<logger name="de.accso" level="INFO"/>
<root level="WARN">
<appender-ref ref="STDOUT" />
</root>
</configuration>

12
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/main/resources/static/index.html Normal file
View file

@ -0,0 +1,12 @@
<!DOCTYPE html>
<html lang="de" xmlns:th="http://www.thymeleaf.org">
<head>
<title>Flexinale Distributed - Backoffice</title>
<meta content="text/html; charset=UTF-8" http-equiv="Content-Type"/>
</head>
<body>
Flexinale Distributed - Backoffice
</body>
</html>

3
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/test/curl/backoffice-actuator-events-published.http Normal file
View file

@ -0,0 +1,3 @@
# curl -v -X GET -u admin:admin1 http://localhost:8081/actuator/backofficeEventsPublished
GET http://localhost:8081/actuator/backofficeEventsPublished
Authorization: Basic admin admin1

3
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/test/curl/backoffice-actuator-health.http Normal file
View file

@ -0,0 +1,3 @@
# curl -v -X GET -u admin:admin1 http://localhost:8081/actuator/health
GET http://localhost:8081/actuator/health
Authorization: Basic admin admin1

3
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/test/curl/backoffice-actuator-info.http Normal file
View file

@ -0,0 +1,3 @@
# curl -v -X GET -u admin:admin1 http://localhost:8081/actuator/info
GET http://localhost:8081/actuator/info
Authorization: Basic admin admin1

3
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/test/curl/backoffice-actuator-metrics.http Normal file
View file

@ -0,0 +1,3 @@
# curl -v -X GET -u admin:admin1 http://localhost:8081/actuator/metrics
GET http://localhost:8081/actuator/metrics
Authorization: Basic admin admin1

3
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/test/curl/backoffice-actuator-prometheus.http Normal file
View file

@ -0,0 +1,3 @@
# curl -v -X GET -u admin:admin1 http://localhost:8081/actuator/prometheus
GET http://localhost:8081/actuator/prometheus
Authorization: Basic admin admin1

21
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/test/java/de/accso/flexinale/ApplicationPropertiesFileTest.java Normal file
View file

@ -0,0 +1,21 @@
package de.accso.flexinale;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(classes = {FlexinaleDistributedApplicationBackoffice.class})
@ActiveProfiles("smoketest")
public class ApplicationPropertiesFileTest {
@Value("${application.version}")
private String propertyApplicationVersion;
@Test
public void testReadsTestPropertiesFile() {
assertThat(propertyApplicationVersion).isEqualTo("test");
}
}

20
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/test/java/de/accso/flexinale/FlexinaleDistributedApplicationBackofficeSmokeTest.java Normal file
View file

@ -0,0 +1,20 @@
package de.accso.flexinale;
import de.accso.flexinale.common.shared_kernel.DoNotCheckInArchitectureTests;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ActiveProfiles;
@SpringBootTest(classes = {FlexinaleDistributedApplicationBackoffice.class})
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
@ActiveProfiles("smoketest")
@DoNotCheckInArchitectureTests
class FlexinaleDistributedApplicationBackofficeSmokeTest {
@Test
@SuppressWarnings("EmptyMethod")
void testLoadInitialApplicationContext() {
// nope
}
}

31
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/test/java/de/accso/flexinale/FlexinaleDistributedApplicationBackofficeSpringConfigTest.java Normal file
View file

@ -0,0 +1,31 @@
package de.accso.flexinale;
import de.accso.flexinale.common.application.Config;
import de.accso.flexinale.common.shared_kernel.DoNotCheckInArchitectureTests;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ActiveProfiles;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(classes = {FlexinaleDistributedApplicationBackoffice.class})
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
@ActiveProfiles("configtest")
@DoNotCheckInArchitectureTests
class FlexinaleDistributedApplicationBackofficeSpringConfigTest {
@Autowired
Config config;
@Test
void testLoadSpringConfig() {
// arrange, act
// nope, is loaded auto-magically by Spring, see application-configtest.properties
// assert
assertThat(config.getQuoteOnline()).isEqualTo(33); // default
assertThat(config.getMinZeitZwischenVorfuehrungenInMinuten()).isEqualTo(30); // default
}
}

1
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/test/resources/application-configtest.properties Normal file
View file

@ -0,0 +1 @@
# empty

39
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/test/resources/application.properties Normal file
View file

@ -0,0 +1,39 @@
application.title=FLEXinale as Distributed Services, Backoffice
application.version=test
spring.banner.location=classpath:/flexinale-banner.txt
#########################################################################
# For endpoint /version
#########################################################################
build.version=@pom.version@
build.date=@maven.build.timestamp@
#########################################################################
# Persistence
#########################################################################
spring.datasource.url=jdbc:postgresql://127.0.0.1:5432/distributed-backoffice
spring.datasource.name=flexinale
spring.datasource.username=flexinale
spring.datasource.password=flexinale
spring.datasource.driver-class-name=org.postgresql.Driver
spring.jpa.database=postgresql
spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect
spring.jpa.generate-ddl=true
# spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=create
#########################################################################
# Web
#########################################################################
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
server.error.path=/error
server.port=9091
#########################################################################
# flexinale properties
#########################################################################
# Quote for online kontingent in percent
de.accso.flexinale.kontingent.quote.online=33
# time in minutes
de.accso.flexinale.vorfuehrung.min-zeit-zwischen-vorfuehrungen-in-minuten=30

20
flex-training-flexinale/flexinale-distributed/flexinale-distributed-backoffice/src/test/resources/logback-test.xml Normal file
View file

@ -0,0 +1,20 @@
<configuration>
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{YYYYMMdd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<logger name="org.springframework.orm.jpa" level="INFO"/>
<logger name="org.springframework.boot.autoconfigure.domain.EntityScan" level="INFO"/>
<logger name="org.apache.kafka" level="WARN"/>
<logger name="org.apache.kafka.clients.admin.AdminClient" level="INFO"/>
<logger name="org.apache.kafka.clients.consumer.ConsumerConfig" level="INFO"/>
<logger name="org.apache.kafka.clients.producer.ProducerConfig" level="INFO"/>
<logger name="de.accso" level="INFO"/>
<root level="INFO">
<appender-ref ref="STDOUT" />
</root>
</configuration>