Skip to content
Snippets Groups Projects
Commit 9f72fe85 authored by Tobias Bruns's avatar Tobias Bruns
Browse files

Alfa Client Version 1.1.1

parent d9956e57
Branches
No related tags found
No related merge requests found
Showing
with 1548 additions and 0 deletions
<!--
Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
Ministerpräsidenten des Landes Schleswig-Holstein
Staatskanzlei
Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
Lizenziert unter der EUPL, Version 1.2 oder - sobald
diese von der Europäischen Kommission genehmigt wurden -
Folgeversionen der EUPL ("Lizenz");
Sie dürfen dieses Werk ausschließlich gemäß
dieser Lizenz nutzen.
Eine Kopie der Lizenz finden Sie hier:
https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
Sofern nicht durch anwendbare Rechtsvorschriften
gefordert oder in schriftlicher Form vereinbart, wird
die unter der Lizenz verbreitete Software "so wie sie
ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
ausdrücklich oder stillschweigend - verbreitet.
Die sprachspezifischen Genehmigungen und Beschränkungen
unter der Lizenz sind dem Lizenztext zu entnehmen.
-->
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>de.itvsh.ozg</groupId>
<artifactId>goofy</artifactId>
<version>1.1.1</version>
</parent>
<artifactId>goofy-server</artifactId>
<name>Goofy Server</name>
<description>Projekt packaging deployment artefact</description>
<packaging>jar</packaging>
<properties>
<maven.compiler.source>${java.version}</maven.compiler.source>
<maven.compiler.target>${java.version}</maven.compiler.target>
<spring-boot.build-image.imageName>docker.ozg-sh.de/goofy:build-latest</spring-boot.build-image.imageName>
</properties>
<dependencies>
<!-- Spring -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-log4j2</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-hateoas</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<dependency>
<groupId>net.devh</groupId>
<artifactId>grpc-client-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.keycloak</groupId>
<artifactId>keycloak-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.keycloak</groupId>
<artifactId>keycloak-admin-client</artifactId>
</dependency>
<!-- jwt -->
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
</dependency>
<!-- own projects -->
<dependency>
<groupId>de.itvsh.ozg.pluto</groupId>
<artifactId>pluto-interface</artifactId>
</dependency>
<dependency>
<groupId>de.itvsh.ozg.pluto</groupId>
<artifactId>pluto-utils</artifactId>
</dependency>
<dependency>
<groupId>de.itvsh.kop.common</groupId>
<artifactId>kop-common-pdf</artifactId>
</dependency>
<!-- tools -->
<dependency>
<groupId>org.mapstruct</groupId>
<artifactId>mapstruct</artifactId>
</dependency>
<dependency>
<groupId>org.jsoup</groupId>
<artifactId>jsoup</artifactId>
</dependency>
<!-- aspectJ -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
</dependency>
<!-- Dev -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
</dependency>
<!-- commons -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
</dependency>
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
</dependency>
<!-- Test -->
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>de.itvsh.ozg.pluto</groupId>
<artifactId>pluto-utils</artifactId>
<type>test-jar</type>
<scope>test</scope>
<version>${pluto.version}</version>
</dependency>
<dependency>
<groupId>com.thedeanda</groupId>
<artifactId>lorem</artifactId>
</dependency>
</dependencies>
<build>
<finalName>${project.artifactId}</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<docker>
<publishRegistry>
<username>${docker-username}</username>
<password>${docker-password}</password>
<url>${docker-url}</url>
</publishRegistry>
</docker>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-failsafe-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>pl.project13.maven</groupId>
<artifactId>git-commit-id-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<executions>
<execution>
<id>copy-client</id>
<phase>compile</phase>
<goals>
<goal>copy-resources</goal>
</goals>
<configuration>
<outputDirectory>${project.build.directory}/classes/META-INF/resources</outputDirectory>
<resources>
<resource>
<directory>../${project.parent.artifactId}-client/dist/apps/goofy/</directory>
</resource>
</resources>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
#
# Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
# Ministerpräsidenten des Landes Schleswig-Holstein
# Staatskanzlei
# Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
#
# Lizenziert unter der EUPL, Version 1.2 oder - sobald
# diese von der Europäischen Kommission genehmigt wurden -
# Folgeversionen der EUPL ("Lizenz");
# Sie dürfen dieses Werk ausschließlich gemäß
# dieser Lizenz nutzen.
# Eine Kopie der Lizenz finden Sie hier:
#
# https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
#
# Sofern nicht durch anwendbare Rechtsvorschriften
# gefordert oder in schriftlicher Form vereinbart, wird
# die unter der Lizenz verbreitete Software "so wie sie
# ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
# ausdrücklich oder stillschweigend - verbreitet.
# Die sprachspezifischen Genehmigungen und Beschränkungen
# unter der Lizenz sind dem Lizenztext zu entnehmen.
#
sonar.java.coveragePlugin=jacoco
sonar.jacoco.reportPath=target/jacoco.exec
\ No newline at end of file
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
public class CallBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
private final CallScope callScope;
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
beanFactory.registerScope(CallScope.SCOPE_NAME, callScope);
}
}
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.Scope;
import org.springframework.core.NamedInheritableThreadLocal;
import lombok.extern.log4j.Log4j2;
@Log4j2
public class CallScope implements Scope {
public static final String SCOPE_NAME = "call";
private static final ThreadLocal<Map<String, Object>> scopedObjectsHolder = new NamedInheritableThreadLocal<>("Call Context");
private static final ThreadLocal<Map<String, Runnable>> destructionCallbacksHolder = new NamedInheritableThreadLocal<>(
"Call Context Desctruction Callbacks");
public void startScope() {
LOG.info("START Call-Scope");
scopedObjectsHolder.set(new ConcurrentHashMap<>());
destructionCallbacksHolder.set(new ConcurrentHashMap<>());
}
public void endScope() {
scopedObjectsHolder.remove();
callAllDestructionCallbacks();
destructionCallbacksHolder.remove();
}
private void callAllDestructionCallbacks() {
destructionCallbacksHolder.get().values().forEach(Runnable::run);
}
@Override
public Object get(String name, ObjectFactory<?> objectFactory) {
if (!scopedObjectsHolder.get().containsKey(name)) {
scopedObjectsHolder.get().put(name, objectFactory.getObject());
}
return scopedObjectsHolder.get().get(name);
}
@Override
public Object remove(String name) {
destructionCallbacksHolder.get().remove(name);
return scopedObjectsHolder.get().remove(name);
}
@Override
public void registerDestructionCallback(String name, Runnable callback) {
destructionCallbacksHolder.get().put(name, callback);
}
@Override
public Object resolveContextualObject(String key) {
return scopedObjectsHolder.get().get(key);
}
@Override
public String getConversationId() {
return Thread.currentThread().getName();
}
}
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy;
import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.*;
import org.keycloak.adapters.springboot.KeycloakSpringBootProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api/environment")
public class EnvironmentController {
@Autowired
private KeycloakSpringBootProperties kcProperties;
@Value("${goofy.production}")
private boolean production = true;
@GetMapping
public FrontendEnvironment getFrontendEnvironment() {
return FrontendEnvironment.builder()//
.production(production)//
.remoteHost(apiRoot())//
.authServer(kcProperties.getAuthServerUrl())//
.clientId(kcProperties.getResource())//
.realm(kcProperties.getRealm())
.build();
}
private String apiRoot() {
return linkTo(RootController.class).toUri().toString();
}
}
\ No newline at end of file
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy;
import lombok.Builder;
import lombok.Getter;
@Getter
@Builder
public class FrontendEnvironment {
private boolean production;
private String remoteHost;
private String authServer;
private String realm;
private String clientId;
}
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy;
import java.util.TimeZone;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.security.concurrent.DelegatingSecurityContextRunnable;
import org.springframework.web.filter.ForwardedHeaderFilter;
@SpringBootApplication
@EnableAsync
@EnableAspectJAutoProxy(proxyTargetClass = true)
@ComponentScan({ "de.itvsh.*" })
public class GoofyServerApplication {
public static final String GRPC_CLIENT = "pluto";
public static void main(String[] args) {
TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
SpringApplication.run(GoofyServerApplication.class, args);
}
@Bean
public FilterRegistrationBean<ForwardedHeaderFilter> forwardedHeaderFilter() {
FilterRegistrationBean<ForwardedHeaderFilter> bean = new FilterRegistrationBean<>();
bean.setFilter(new ForwardedHeaderFilter());
return bean;
}
@Bean
public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setThreadNamePrefix("async-");
executor.setTaskDecorator(DelegatingSecurityContextRunnable::new);
return executor;
}
@Bean
public CallScope callScope() {
return new CallScope();
}
@Bean
public BeanFactoryPostProcessor beanFactoryPostProcessor(CallScope callScope) {
return new CallBeanFactoryPostProcessor(callScope);
}
}
\ No newline at end of file
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Component;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTVerificationException;
import de.itvsh.goofy.common.binaryfile.FileId;
import de.itvsh.goofy.common.downloadtoken.DownloadTokenProperties;
import de.itvsh.goofy.common.user.UserProfile;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
@Component
public class JwtTokenUtil {
public static final String TOKEN_TYP_KEY = "typ";
public static final String TOKEN_TYPE = "JWT";
public static final String TOKEN_ISSUER = "secure-api";
public static final String TOKEN_AUDIENCE = "secure-app";
public static final String ROLE_CLAIM = "roles";
public static final String USERID_CLAIM = "userId";
public static final String FIRSTNAME_CLAIM = "firstName";
public static final String LASTNAME_CLAIM = "lastName";
public static final String FILEID_CLAIM = "fileId";
public static final String ORGANSIATIONSEINHEIT_IDS_CLAIM = "organisationseinheitIds";
@Autowired
private DownloadTokenProperties downloadTokenProperties;
@SuppressWarnings("unchecked")
private List<Map<String, String>> getRoleClaims(String token) {
List<Map<String, String>> roleClaims = new ArrayList<>();
getAllClaimsFromToken(token).ifPresent(claims -> roleClaims.addAll((List<Map<String, String>>) claims.get(ROLE_CLAIM)));
return roleClaims;
}
public Optional<Claims> getAllClaimsFromToken(String token) {
return Optional.of(Jwts.parser().setSigningKey(downloadTokenProperties.getSecret().getBytes()).parseClaimsJws(token).getBody());
}
public List<SimpleGrantedAuthority> getRolesFromToken(String token) {
List<Map<String, String>> claimsList = getRoleClaims(token);
return claimsList.stream()
.flatMap(rolesMap -> rolesMap.entrySet().stream())
.map(roleEntry -> new SimpleGrantedAuthority(roleEntry.getValue()))
.toList();
}
@SuppressWarnings({ "unchecked" })
public Collection<String> getOrganisationseinheitIdsFromToken(String token) {
List<String> organisationseinheitIds = new ArrayList<>();
getAllClaimsFromToken(token)
.ifPresent(claims -> {
if (claims.get(ORGANSIATIONSEINHEIT_IDS_CLAIM) != null) {
organisationseinheitIds.addAll((Collection<String>) claims.get(ORGANSIATIONSEINHEIT_IDS_CLAIM));
}
});
return organisationseinheitIds;
}
public String generateToken(FileId fileId, UserProfile user) {
var claims = new HashMap<String, Object>();
claims.put(USERID_CLAIM, user.getId().toString());
claims.put(FIRSTNAME_CLAIM, user.getFirstName());
claims.put(LASTNAME_CLAIM, user.getLastName());
claims.put(ROLE_CLAIM, user.getAuthorities());
claims.put(FILEID_CLAIM, fileId.toString());
claims.put(ORGANSIATIONSEINHEIT_IDS_CLAIM, user.getOrganisationseinheitIds());
return doGenerateToken(claims, user.getId().toString());
}
private String doGenerateToken(Map<String, Object> claims, String subject) {
return Jwts.builder()
.setClaims(claims)
.setSubject(subject)
.setHeaderParam(TOKEN_TYP_KEY, TOKEN_TYPE)
.setIssuer(TOKEN_ISSUER).setIssuedAt(new Date(System.currentTimeMillis()))
.setExpiration(new Date(System.currentTimeMillis() + downloadTokenProperties.getValidity()))
.setAudience(TOKEN_AUDIENCE)
.signWith(SignatureAlgorithm.HS512, downloadTokenProperties.getSecret().getBytes())
.compact();
}
public void verifyToken(String token) throws JWTVerificationException {
var algorithm = Algorithm.HMAC512(downloadTokenProperties.getSecret());
var verifier = JWT.require(algorithm).build();
verifier.verify(token);
}
}
\ No newline at end of file
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy;
import java.util.UUID;
import org.springframework.context.annotation.Scope;
import org.springframework.context.annotation.ScopedProxyMode;
import org.springframework.stereotype.Component;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Component
@Scope(scopeName = "call", proxyMode = ScopedProxyMode.TARGET_CLASS)
@Getter
@Builder
@AllArgsConstructor(access = AccessLevel.PRIVATE)
@NoArgsConstructor
public class RequestAttributes {
@Builder.Default
private String requestId = UUID.randomUUID().toString();
}
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy;
import java.io.IOException;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.logging.log4j.CloseableThreadContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import lombok.extern.log4j.Log4j2;
@Component
@Log4j2
class RequestIdFilter extends OncePerRequestFilter {
private static final String REQUEST_ID_KEY = "requestId";
@Autowired
private RequestAttributes reqAttributes;
@Autowired
private CallScope callScope;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
callScope.startScope();
try (CloseableThreadContext.Instance ctc = CloseableThreadContext.put(REQUEST_ID_KEY, reqAttributes.getRequestId())) {
LOG.info("START of Request with ID '{}'.", reqAttributes.getRequestId());
filterChain.doFilter(request, response);
} finally {
LOG.info("END of Request with ID '{}'", reqAttributes.getRequestId());
callScope.endScope();
}
}
}
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy;
import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.*;
import java.time.Instant;
import java.util.Optional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.info.BuildProperties;
import org.springframework.hateoas.EntityModel;
import org.springframework.hateoas.Link;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import de.itvsh.goofy.common.ModelBuilder;
import de.itvsh.goofy.common.downloadtoken.DownloadTokenController;
import de.itvsh.goofy.common.user.CurrentUserService;
import de.itvsh.goofy.common.user.UserId;
import de.itvsh.goofy.common.user.UserManagerUrlProvider;
import de.itvsh.goofy.common.user.UserRemoteService;
import de.itvsh.goofy.common.user.UserRole;
import de.itvsh.goofy.system.SystemStatusService;
import de.itvsh.goofy.vorgang.VorgangController;
@RestController
@RequestMapping(RootController.PATH)
public class RootController {
static final String PATH = "/api"; // NOSONAR
static final String REL_VORGAENGE = "vorgaenge";
static final String REL_SEARCH = "search";
static final String REL_SEARCH_USER = "search-user-profiles";
static final String REL_MY_VORGAENGE = "myVorgaenge";
static final String REL_SEARCH_MY_VORGAENGE = "searchMyVorgaenge";
static final String REL_DOWNLOAD_TOKEN = "downloadToken";
static final String REL_CURRENT_USER = "currentUser";
@Autowired(required = false)
public BuildProperties buildProperties;
@Autowired
private CurrentUserService currentUserService;
@Autowired
private SystemStatusService systemStatusService;
@Autowired
private UserRemoteService internalUserIdService;
@Autowired
private UserManagerUrlProvider userManagerUrlProvider;
@GetMapping
public EntityModel<RootResource> getRootResource() {
var internalUserId = internalUserIdService.getUserId(currentUserService.getUserId());
var modelBuilder = ModelBuilder.fromEntity(new RootResource())
.ifMatch(this::hasRole).addLinks(
linkTo(RootController.class).withSelfRel(),
linkTo(VorgangController.class).withRel(REL_VORGAENGE),
linkTo(DownloadTokenController.class).withRel(REL_DOWNLOAD_TOKEN),
Link.of(userManagerUrlProvider.getUserProfileSearchTemplate(), REL_SEARCH_USER))
.ifMatch(this::hasRoleAndSearchServerAvailable).addLinks(
buildVorgangListByPageLink(REL_SEARCH, Optional.empty()));
internalUserId.ifPresent(userId -> modelBuilder
.ifMatch(this::hasVerwaltungRole).addLink(
buildVorgangListByPageLink(REL_MY_VORGAENGE, Optional.of(userId)))
.ifMatch(this::hasVerwaltungRoleAndSearchServerAvailable).addLink(
buildVorgangListByPageLink(REL_SEARCH_MY_VORGAENGE, Optional.of(userId))));
var model = modelBuilder.buildModel();
getUserProfilesUrl()
.ifPresent(urlTemplate -> model.add(Link.of(String.format(urlTemplate, currentUserService.getUserId()), REL_CURRENT_USER)));
return model;
}
private boolean hasRoleAndSearchServerAvailable() {
return hasRole() && systemStatusService.isSearchServerAvailable();
}
private boolean hasVerwaltungRoleAndSearchServerAvailable() {
return hasVerwaltungRole() && systemStatusService.isSearchServerAvailable();
}
boolean hasRole() {
return hasVerwaltungRole() || currentUserService.hasRole(UserRole.EINHEITLICHER_ANSPRECHPARTNER);
}
boolean hasVerwaltungRole() {
return currentUserService.hasRole(UserRole.VERWALTUNG_USER)
|| currentUserService.hasRole(UserRole.VERWALTUNG_POSTSTELLE);
}
private Link buildVorgangListByPageLink(String linkRel, Optional<UserId> assignedTo) {
return linkTo(methodOn(VorgangController.class).getVorgangListByPage(0, null, null, assignedTo)).withRel(linkRel);
}
Optional<String> getUserProfilesUrl() {
if (userManagerUrlProvider.isConfiguredForUserProfile()) {
return Optional.of(userManagerUrlProvider.getUserProfileTemplate());
}
return Optional.empty();
}
class RootResource {
public String getVersion() {
return buildProperties == null ? "--" : buildProperties.getVersion();
}
public Instant getBuildTime() {
return buildProperties == null ? null : buildProperties.getTime();
}
public String getJavaVersion() {
return System.getProperty("java.version");
}
}
}
\ No newline at end of file
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy;
import org.keycloak.adapters.springsecurity.KeycloakConfiguration;
import org.keycloak.adapters.springsecurity.authentication.KeycloakAuthenticationProvider;
import org.keycloak.adapters.springsecurity.config.KeycloakWebSecurityConfigurerAdapter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.authority.mapping.SimpleAuthorityMapper;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.authentication.session.NullAuthenticatedSessionStrategy;
import org.springframework.security.web.authentication.session.SessionAuthenticationStrategy;
import org.springframework.security.web.csrf.CookieCsrfTokenRepository;
import org.springframework.security.web.header.writers.frameoptions.XFrameOptionsHeaderWriter;
import org.springframework.security.web.header.writers.frameoptions.XFrameOptionsHeaderWriter.XFrameOptionsMode;
import de.itvsh.goofy.common.downloadtoken.DownloadTokenAuthenticationFilter;
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
@KeycloakConfiguration
public class SecurityConfiguration extends KeycloakWebSecurityConfigurerAdapter {
@Autowired
private DownloadTokenAuthenticationFilter downloadTokenFilter;
@Override
protected void configure(HttpSecurity http) throws Exception {
super.configure(http);
http.csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse());
http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and().authorizeRequests()//
.antMatchers(HttpMethod.GET, "/api/environment").permitAll()//
.antMatchers(HttpMethod.GET, "/assets/**").permitAll()//
.antMatchers(HttpMethod.GET, "/vorgang/**").permitAll()//
.antMatchers(HttpMethod.GET, "/search/**").permitAll()//
.antMatchers("/api").authenticated()//
.antMatchers("/api/**").authenticated()//
.antMatchers("/actuator").permitAll()//
.antMatchers("/actuator/**").permitAll()//
.antMatchers("/").permitAll()//
.antMatchers("/*").permitAll()//
.anyRequest().denyAll();
http.headers().addHeaderWriter(new XFrameOptionsHeaderWriter(XFrameOptionsMode.SAMEORIGIN));
http.addFilterBefore(downloadTokenFilter, UsernamePasswordAuthenticationFilter.class);
}
@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) {
KeycloakAuthenticationProvider keyCloakAuthProvider = keycloakAuthenticationProvider();
keyCloakAuthProvider.setGrantedAuthoritiesMapper(new SimpleAuthorityMapper());
auth.authenticationProvider(keyCloakAuthProvider);
}
@Override
protected SessionAuthenticationStrategy sessionAuthenticationStrategy() {
return new NullAuthenticatedSessionStrategy();
}
}
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
import org.keycloak.adapters.KeycloakConfigResolver;
import org.keycloak.adapters.springboot.KeycloakSpringBootConfigResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.http.CacheControl;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.resource.PathResourceResolver;
@Configuration
public class WebConfig implements WebMvcConfigurer {
private static final String RESOURCE_LOCATION = "classpath:/META-INF/resources/";
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/*.js", "/*.css", "/*.ttf", "/*.woff", "/*.woff2", "/*.eot",
"/**/*.svg", "/*.svf", "/*.otf", "/*.ico", "/**/*.png")
.addResourceLocations(RESOURCE_LOCATION)
.setCacheControl(CacheControl.maxAge(30, TimeUnit.DAYS).cachePublic())
.resourceChain(true)
.addResolver(new PathResourceResolver());
registry.addResourceHandler("/**/*")
.addResourceLocations(RESOURCE_LOCATION)
.setCacheControl(CacheControl.noStore())
.setUseLastModified(false)
.resourceChain(true)
.addResolver(new PathResourceResolver() {
@Override
protected Resource getResource(String resourcePath, Resource location) throws IOException {
Resource requestedResource = location.createRelative(resourcePath);
return requestedResource.exists() && requestedResource.isReadable() ? requestedResource
: super.getResource("index.html", location);
}
});
}
@Bean
public KeycloakConfigResolver keyCloakConfigResolver() {
return new KeycloakSpringBootConfigResolver();
}
}
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy.attachment;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.hateoas.CollectionModel;
import org.springframework.hateoas.EntityModel;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import de.itvsh.goofy.common.binaryfile.BinaryFileModelAssembler;
import de.itvsh.goofy.common.file.OzgFile;
import de.itvsh.goofy.common.file.OzgFileService;
@RestController
@RequestMapping(AttachmentController.ATTACHMENT_PATH)
public class AttachmentController {
static final String ATTACHMENT_PATH = "/api/attachments"; // NOSONAR
static final String PARAM_EINGANG_ID = "eingangId";
@Autowired
private OzgFileService fileService;
@Autowired
private BinaryFileModelAssembler modelAssembler;
@GetMapping(params = PARAM_EINGANG_ID)
public CollectionModel<EntityModel<OzgFile>> getAllByEingang(@RequestParam String eingangId) {
return modelAssembler.toCollectionModel(fileService.getAttachmentsByEingang(eingangId));
}
}
\ No newline at end of file
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy.common;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
import org.apache.commons.lang3.StringUtils;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
import de.itvsh.kop.common.datatype.StringBasedValue;
import lombok.Getter;
abstract class AbstractLinkedResourceDeserializer extends StdDeserializer<Object> implements ContextualDeserializer {
private static final long serialVersionUID = 1L;
@Getter
private BeanProperty beanProperty;
@Getter
private final JavaType targetType;
protected AbstractLinkedResourceDeserializer() {
super(Object.class);
targetType = null;
}
protected AbstractLinkedResourceDeserializer(BeanProperty beanProperty) {
super(Object.class);
this.beanProperty = beanProperty;
this.targetType = beanProperty.getType();
}
@Override
public Object deserialize(JsonParser jsonParser, DeserializationContext ctxt) throws IOException {
if (jsonParser.isExpectedStartArrayToken()) {
Collection<Object> idList = targetType.getRawClass().isAssignableFrom(Set.class) ? new HashSet<>() : new ArrayList<>();
while (!jsonParser.nextToken().isStructEnd()) {
idList.add(extractId(jsonParser.getText()));
}
return idList;
} else {
return extractId(jsonParser.getText());
}
}
Object extractId(String url) {
Class<?> type;
if (targetType.isCollectionLikeType()) {
type = targetType.getContentType().getRawClass();
} else {
type = targetType.getRawClass();
}
if (String.class.isAssignableFrom(type)) {
return extractStringId(url);
}
if (Long.class.isAssignableFrom(type) || Long.TYPE.isAssignableFrom(type)) {
return extractLongId(url);
}
if (StringBasedValue.class.isAssignableFrom(type)) {
return extractStringBasedValue(type, url);
}
return buildByBuilder(url);
}
abstract Object buildByBuilder(String url);
public static Long extractLongId(String uri) {
var trimedUri = StringUtils.trimToNull(uri);
if (Objects.isNull(trimedUri)) {
return null;
}
return Long.parseLong(URLDecoder.decode(trimedUri.substring(trimedUri.lastIndexOf('/') + 1), StandardCharsets.UTF_8));
}
private StringBasedValue extractStringBasedValue(Class<?> type, String url) {
String value = extractStringId(url);
Method fromMethod;
try {
fromMethod = type.getMethod("from", String.class);
} catch (NoSuchMethodException e) {
throw new IllegalStateException(
String.format("Cannot generate Id from type '%s'. Missing 'from' Method.", targetType.getRawClass().getSimpleName()));
}
try {
return (StringBasedValue) fromMethod.invoke(null, value);
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
throw new IllegalStateException(
String.format("Cannot generate Id from type '%s'. Error calling 'from' Method.", targetType.getRawClass().getSimpleName()),
e);
}
}
public static String extractStringId(String url) {
return URLDecoder.decode(url.substring(url.lastIndexOf('/') + 1), StandardCharsets.UTF_8);
}
}
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy.common;
import java.io.IOException;
import java.util.Collection;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import de.itvsh.kop.common.errorhandling.TechnicalException;
abstract class AbstractLinkedResourceSerializer extends JsonSerializer<Object> implements ContextualSerializer {
@Override
public void serialize(Object value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
if (value instanceof Collection) {
gen.writeStartArray();
((Collection<?>) value).forEach(val -> writeObject(gen, buildLink(val)));
gen.writeEndArray();
} else {
writeObject(gen, buildLink(value));
}
}
abstract String buildLink(Object id);
abstract IdExtractor<Object> getExtractor();
void writeObject(JsonGenerator gen, Object value) {
try {
gen.writeObject(value);
} catch (IOException e) {
throw new TechnicalException("Error writing String to json", e);
}
}
}
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy.common;
import java.time.ZonedDateTime;
import java.util.Optional;
import org.apache.commons.lang3.StringUtils;
import org.mapstruct.Mapper;
@Mapper
public interface BaseTypesMapper {
default String fromString(String in) {
return StringUtils.trimToNull(in);
}
default ZonedDateTime mapDateTime(String inStr) {
return Optional.ofNullable(fromString(inStr)).map(ZonedDateTime::parse).orElse(null);
}
}
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy.common;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.Optional;
import java.util.stream.StreamSupport;
import io.grpc.Metadata;
import io.grpc.Metadata.Key;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class GrpcUtil {
public static Key<byte[]> createKeyOf(String key) {
return Key.of(key, Metadata.BINARY_BYTE_MARSHALLER);
}
public static String getFromHeaders(String key, Metadata headers) {
return Optional.ofNullable(headers.get(createKeyOf(key)))
.map(val -> new String(val, StandardCharsets.UTF_8))
.orElse(null);
}
public static Collection<String> getCollection(String key, Metadata headers) {
return StreamSupport.stream(headers.getAll(createKeyOf(key)).spliterator(), false)
.map(bytes -> new String(bytes, StandardCharsets.UTF_8))
.toList();
}
}
\ No newline at end of file
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy.common;
import com.fasterxml.jackson.databind.BeanProperty;
import lombok.NoArgsConstructor;
@NoArgsConstructor
class IdBuilder implements ObjectBuilder<Object> {
@Override
public Object build(Object id) {
return id;
}
@Override
public ObjectBuilder<Object> constructContextAware(BeanProperty property) {
return new IdBuilder();
}
}
/*
* Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
* Ministerpräsidenten des Landes Schleswig-Holstein
* Staatskanzlei
* Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
*
* Lizenziert unter der EUPL, Version 1.2 oder - sobald
* diese von der Europäischen Kommission genehmigt wurden -
* Folgeversionen der EUPL ("Lizenz");
* Sie dürfen dieses Werk ausschließlich gemäß
* dieser Lizenz nutzen.
* Eine Kopie der Lizenz finden Sie hier:
*
* https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
*
* Sofern nicht durch anwendbare Rechtsvorschriften
* gefordert oder in schriftlicher Form vereinbart, wird
* die unter der Lizenz verbreitete Software "so wie sie
* ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
* ausdrücklich oder stillschweigend - verbreitet.
* Die sprachspezifischen Genehmigungen und Beschränkungen
* unter der Lizenz sind dem Lizenztext zu entnehmen.
*/
package de.itvsh.goofy.common;
@FunctionalInterface
public interface IdExtractor<T> {
String extractId(T object);
}
\ No newline at end of file
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment